From 282aa9fd2f98759c827f82147f73fc5d9b2fa5ab Mon Sep 17 00:00:00 2001
From: "C. Scott Ananian" <cscott@cscott.net>
Date: Sat, 13 Oct 2018 07:32:06 -0400
Subject: [PATCH] Update the JavaScript codegen target

---
 runtime/JavaScript/build/README               |   7 +-
 runtime/JavaScript/build/antlr3.properties    |   2 +-
 .../tests/functional/t009lexer.html           |   4 +-
 .../tests/functional/t044trace.html           |   8 +-
 .../codegen/templates/JavaScript/AST.stg      | 101 ++---
 .../templates/JavaScript/ASTParser.stg        |  76 ++--
 .../templates/JavaScript/ASTTreeParser.stg    | 103 +++--
 .../templates/JavaScript/JavaScript.stg       | 382 ++++++++++++------
 8 files changed, 430 insertions(+), 253 deletions(-)

diff --git a/runtime/JavaScript/build/README b/runtime/JavaScript/build/README
index 4095054db..c7b30bde2 100755
--- a/runtime/JavaScript/build/README
+++ b/runtime/JavaScript/build/README
@@ -19,9 +19,8 @@ party open source libraries:
   * Unzip the downloaded file.
   * Move the unzipped folder to runtime/JavaScript/third/jsdoc-toolkit
 
-  * jsunit: Download here: https://sourceforge.net/project/showfiles.php?group_id=28041&package_id=19823&release_id=404277 
-  * Unzip the downloaded file.
-  * Move the unzipped folder to runtime/JavaScript/tests/jsunit
+  * jsunit:
+  * cd runtime/JavaScript/tests && git clone https://github.com/pivotal-legacy/jsunit.git
 
 ### BUILD ###
 1) In a shell cd to runtime/JavaScript/build.
@@ -32,7 +31,7 @@ party open source libraries:
 Compile Tests:
 1) Build the Antlr tool itself (see main Antlr documentation for details).
    This is most easily done by cd'ing to the root of the antlr code and running
-   'mvn -Dmaven.test.skip=true package assembly:assembly'.  If using a
+   'mvn -Dmaven.test.skip=true package'.  If using a
    different build method, update runtime/JavaScript/build/antlr3.properties to
    point to the alternative jar.
 2) In a shell cd to runtime/JavaScript/build.
diff --git a/runtime/JavaScript/build/antlr3.properties b/runtime/JavaScript/build/antlr3.properties
index 81014e70d..2e1b6fc84 100755
--- a/runtime/JavaScript/build/antlr3.properties
+++ b/runtime/JavaScript/build/antlr3.properties
@@ -55,4 +55,4 @@ antlr3.cli.list=\
     org/antlr/runtime/ANTLRFileStream.js
 
 # path to antlr tool jar
-antlr3.tool=../../target/antlr-master-3.2.1-SNAPSHOT-completejar.jar
+antlr3.tool=../../antlr-complete/target/antlr-complete-3.5.3-SNAPSHOT.jar
diff --git a/runtime/JavaScript/tests/functional/t009lexer.html b/runtime/JavaScript/tests/functional/t009lexer.html
index 68f6289bd..2a8353302 100755
--- a/runtime/JavaScript/tests/functional/t009lexer.html
+++ b/runtime/JavaScript/tests/functional/t009lexer.html
@@ -60,8 +60,8 @@
             token = lexer.nextToken();
             fail("nextToken should have thrown error on invalid input");
         } catch (e) {
-            assertEquals(e.a, '0');
-            assertEquals(e.b, '9');
+            /* TODO: This shoud provide more useful information */
+            assertEquals(e.expecting, null);
             assertEquals(e.getUnexpectedType(), 'a');
             assertEquals(e.charPositionInLine, 1);
             assertEquals(e.line, 1);
diff --git a/runtime/JavaScript/tests/functional/t044trace.html b/runtime/JavaScript/tests/functional/t044trace.html
index e0b99cf5b..fb4466d0c 100755
--- a/runtime/JavaScript/tests/functional/t044trace.html
+++ b/runtime/JavaScript/tests/functional/t044trace.html
@@ -57,10 +57,10 @@
 
         parser.a();
         assertArrayEquals(lexer.traces,
-            [ '>T__6', '<T__6', '>WS', '<WS', '>INT', '<INT', '>WS', '<WS',
-              '>T__8', '<T__8', '>WS', '<WS', '>INT', '<INT', '>WS', '<WS',
-              '>T__8', '<T__8', '>WS', '<WS', '>INT', '<INT', '>WS', '<WS',
-              '>T__7', '<T__7']
+            [ '>T__7', '<T__7', '>WS', '<WS', '>INT', '<INT', '>WS', '<WS',
+              '>T__6', '<T__6', '>WS', '<WS', '>INT', '<INT', '>WS', '<WS',
+              '>T__6', '<T__6', '>WS', '<WS', '>INT', '<INT', '>WS', '<WS',
+              '>T__8', '<T__8']
         );
         assertArrayEquals(parser.traces,
             [ '>a', '>synpred1_t044trace_fragment', '<synpred1_t044trace_fragment', '>b', '>c',
diff --git a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/AST.stg b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/AST.stg
index 678038764..46b4f3315 100755
--- a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/AST.stg
+++ b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/AST.stg
@@ -25,7 +25,16 @@
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-group AST;
+
+finishedBacktracking(block) ::= <<
+<if(backtracking)>
+if( <actions.(actionScope).synpredgate> ) {
+    <block>
+}
+<else>
+<block>
+<endif>
+>>
 
 @outputFile.imports() ::= <<
 <@super.imports()>
@@ -33,15 +42,15 @@ group AST;
 
 @genericParser.members() ::= <<
 <@super.members()>
-<parserMembers()>
+<astAccessor()>
 >>
 
 /** Add an adaptor property that knows how to build trees */
-parserMembers() ::= <<
+astAccessor() ::= <<
 <!protected TreeAdaptor adaptor = new CommonTreeAdaptor();<\n>!>
 setTreeAdaptor: function(adaptor) {
     this.adaptor = adaptor;
-    <grammar.directDelegates:{g|<g:delegateName()>.setTreeAdaptor(this.adaptor);}>
+    <grammar.directDelegates:{g|<g:delegateName()>.setTreeAdaptor(this.adaptor);}; separator="\n">
 },
 getTreeAdaptor: function() {
     return this.adaptor;
@@ -60,12 +69,14 @@ var root_0 = null;<\n>
 
 ruleLabelDefs() ::= <<
 <super.ruleLabelDefs()>
-<ruleDescriptor.tokenLabels:{var <it.label.text>_tree=null;}; separator="\n">
-<ruleDescriptor.tokenListLabels:{var <it.label.text>_tree=null;}; separator="\n">
+<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels,
+  ruleDescriptor.wildcardTreeListLabels]
+    :{it | var <it.label.text>_tree=null;}; separator="\n">
+<ruleDescriptor.tokenListLabels:{it | var <it.label.text>_tree=null;}; separator="\n">
 <ruleDescriptor.allTokenRefsInAltsWithRewrites
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token <it>");}; separator="\n">
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token <it>");}; separator="\n">
 <ruleDescriptor.allRuleRefsInAltsWithRewrites
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule <it>");}; separator="\n">
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule <it>");}; separator="\n">
 >>
 
 /** When doing auto AST construction, we must define some variables;
@@ -86,57 +97,53 @@ root_0 = this.adaptor.nil();<\n>
 // T r a c k i n g  R u l e  E l e m e n t s
 
 /** ID and track it for use in a rewrite rule */
-tokenRefTrack(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefTrack(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRefBang(...)> <! Track implies no auto AST construction!>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<token>.add(<label>);<\n>
+<finishedBacktracking({stream_<token>.add(<label>);})>
 >>
 
 /** ids+=ID and track it for use in a rewrite rule; adds to ids *and*
  *  to the tracking list stream_ID for use in the rewrite.
  */
-tokenRefTrackAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefTrackAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRefTrack(...)>
 <listLabel(elem=label,...)>
 >>
 
 /** ^(ID ...) track for rewrite */
-tokenRefRuleRootTrack(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefRuleRootTrack(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRefBang(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<token>.add(<label>);<\n>
+<finishedBacktracaking({stream_<token>.add(<label>);})>
 >>
 
 /** Match ^(label+=TOKEN ...) track for rewrite */
-tokenRefRuleRootTrackAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefRuleRootTrackAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRefRuleRootTrack(...)>
 <listLabel(elem=label,...)>
 >>
 
-wildcardTrack(label,elementIndex) ::= <<
-<super.wildcard(...)>
->>
-
 /** rule when output=AST and tracking for rewrite */
 ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
 <super.ruleRef(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<rule.name>.add(<label>.getTree());
+<finishedBacktracking({stream_<rule.name>.add(<label>.getTree());})>
 >>
 
 /** x+=rule when output=AST and tracking for rewrite */
 ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRefTrack(...)>
-<listLabel(elem=label+".getTree()",...)>
+<listLabel(label, {<label>.getTree()})>
 >>
 
 /** ^(rule ...) rewrite */
 ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
 <ruleRefRuleRoot(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<rule>.add(<label>.getTree());
+<finishedBacktracking({stream_<rule>.add(<label>.getTree());})>
 >>
 
 /** ^(x+=rule ...) rewrite */
 ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRefRuleRootTrack(...)>
-<listLabel(elem=label+".getTree()",...)>
+<listLabel(label, {<label>.getTree()})>
 >>
 
 // R e w r i t e
@@ -148,8 +155,8 @@ rewriteCode(
 	referencedTokenListLabels,
 	referencedRuleLabels,
 	referencedRuleListLabels,
-    referencedWildcardLabels,
-    referencedWildcardListLabels,
+	referencedWildcardLabels,
+	referencedWildcardListLabels,
 	rewriteBlockLevel, enclosingTreeLevel, treeLevel) ::=
 <<
 
@@ -159,9 +166,7 @@ rewriteCode(
 // rule labels: <referencedRuleLabels; separator=", ">
 // token list labels: <referencedTokenListLabels; separator=", ">
 // rule list labels: <referencedRuleListLabels; separator=", ">
-<if(backtracking)>
-if ( <actions.(actionScope).synpredgate> ) {<\n>
-<endif>
+<finishedBacktracking({
 <prevRuleRootRef()>.tree = root_0;
 <rewriteCodeLabels()>
 root_0 = this.adaptor.nil();
@@ -173,9 +178,10 @@ root_0 = this.adaptor.nil();
 this.input.replaceChildren(this.adaptor.getParent(retval.start),
                       this.adaptor.getChildIndex(retval.start),
                       this.adaptor.getChildIndex(_last),
-                      retval.tree);
+                      retval.tree);<\n>
 <endif>
 <endif>
+
 <! if parser or tree-parser && rewrite!=true, we need to set result !>
 <if(!TREE_PARSER)>
 <prevRuleRootRef()>.tree = root_0;
@@ -184,34 +190,32 @@ this.input.replaceChildren(this.adaptor.getParent(retval.start),
 <prevRuleRootRef()>.tree = root_0;
 <endif>
 <endif>
-<if(backtracking)>
-}
-<endif>
+})>
 >>
 
 rewriteCodeLabels() ::= <<
 <referencedTokenLabels
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRule<rewriteElementType>Stream(this.adaptor,"token <it>",<it>);};
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRule<rewriteElementType>Stream(this.adaptor,"token <it>",<it>);};
     separator="\n"
 >
 <referencedTokenListLabels
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRule<rewriteElementType>Stream(this.adaptor,"token <it>", list_<it>);};
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRule<rewriteElementType>Stream(this.adaptor,"token <it>", list_<it>);};
     separator="\n"
 >
 <referencedWildcardLabels
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"wildcard <it>",<it>);};
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"wildcard <it>",<it>);};
     separator="\n"
 >
 <referencedWildcardListLabels
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"wildcard <it>",list_<it>);};
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"wildcard <it>",list_<it>);};
     separator="\n"
 >
 <referencedRuleLabels
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token <it>",<it>!=null?<it>.tree:null);};
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token <it>",<it>!=null?<it>.tree:null);};
     separator="\n"
 >
 <referencedRuleListLabels
-    :{var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token <it>",list_<it>);};
+    :{it | var stream_<it>=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token <it>",list_<it>);};
     separator="\n"
 >
 >>
@@ -261,13 +265,14 @@ while ( <referencedElements:{el | stream_<el>.hasNext()}; separator="||"> ) {
 >>
 
 rewriteAlt(a) ::= <<
-// <a.description>
 <if(a.pred)>
 if (<a.pred>) {
+    // a.description
     <a.alt>
 }<\n>
 <else>
 {
+    // a.description
     <a.alt>
 }<\n>
 <endif>
@@ -294,7 +299,7 @@ rewriteElement(e) ::= <<
 >>
 
 /** Gen ID or ID[args] */
-rewriteTokenRef(token,elementIndex,terminalOptions,args) ::= <<
+rewriteTokenRef(token,elementIndex,args,terminalOptions={}) ::= <<
 this.adaptor.addChild(root_<treeLevel>, <createRewriteNodeFromElement(...)>);<\n>
 >>
 
@@ -317,16 +322,16 @@ root_<treeLevel> = this.adaptor.becomeRoot(stream_<label>.nextNode(), root_<tree
 rewriteTokenListLabelRefRoot ::= rewriteTokenLabelRefRoot
 
 /** Gen ^(ID ...) or ^(ID[args] ...) */
-rewriteTokenRefRoot(token,elementIndex,terminalOptions,args) ::= <<
+rewriteTokenRefRoot(token,elementIndex,args,terminalOptions={}) ::= <<
 root_<treeLevel> = this.adaptor.becomeRoot(<createRewriteNodeFromElement(...)>, root_<treeLevel>);<\n>
 >>
 
-rewriteImaginaryTokenRef(args,token,terminalOptions,elementIndex) ::= <<
-this.adaptor.addChild(root_<treeLevel>, <createImaginaryNode(tokenType=token, ...)>);<\n>
+rewriteImaginaryTokenRef(args,token,elementIndex,terminalOptions={}) ::= <<
+this.adaptor.addChild(root_<treeLevel>, <createImaginaryNode(token, args, terminalOptions)>);<\n>
 >>
 
-rewriteImaginaryTokenRefRoot(args,token,terminalOptions,elementIndex) ::= <<
-root_<treeLevel> = this.adaptor.becomeRoot(<createImaginaryNode(tokenType=token, ...)>, root_<treeLevel>);<\n>
+rewriteImaginaryTokenRefRoot(args,token,elementIndex,terminalOptions={}) ::= <<
+root_<treeLevel> = this.adaptor.becomeRoot(<createImaginaryNode(token, args, terminalOptions)>, root_<treeLevel>);<\n>
 >>
 
 /** plain -> {foo} action */
@@ -381,16 +386,16 @@ rewriteWildcardLabelRef(label) ::= <<
 this.adaptor.addChild(root_<treeLevel>, stream_<label>.nextTree());<\n>
 >>
 
-createImaginaryNode(tokenType,terminalOptions,args) ::= <<
+createImaginaryNode(tokenType,args,terminalOptions={}) ::= <%
 <if(terminalOptions.node)>
 <! new MethodNode(IDLabel, args) !>
 new <terminalOptions.node>(<tokenType><if(args)>, <args; separator=", "><endif>)
 <else>
 this.adaptor.create(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>)
 <endif>
->>
+%>
 
-createRewriteNodeFromElement(token,terminalOptions,args) ::= <<
+createRewriteNodeFromElement(token,args,terminalOptions={}) ::= <%
 <if(terminalOptions.node)>
 new <terminalOptions.node>(stream_<token>.nextToken()<if(args)>, <args; separator=", "><endif>)
 <else>
@@ -400,4 +405,4 @@ this.adaptor.create(<token>, <args; separator=", ">)
 stream_<token>.nextNode()
 <endif>
 <endif>
->>
+%>
diff --git a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTParser.stg b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTParser.stg
index 743d77cc9..a4e7dea65 100755
--- a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTParser.stg
+++ b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTParser.stg
@@ -9,49 +9,61 @@
  *  The situation is not too bad as rewrite (->) usage makes ^ and !
  *  invalid. There is no huge explosion of combinations.
  */
-group ASTParser;
 
-@rule.setErrorReturnValue() ::= <<
+finishedBacktracking(block) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<if(backtracking)>
+if( <actions.(actionScope).synpredgate> ) {
+    <block>
+}
+<else>
+<block>
+<endif>
+<endif>
+>>
+
+
+@ruleBody.setErrorReturnValue() ::= <<
 retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
 >>
 
 // TOKEN AST STUFF
 
 /** ID and output=AST */
-tokenRef(token,label,elementIndex,terminalOptions) ::= <<
+tokenRef(token,label,elementIndex,terminalOptions={}) ::= <<
 <super.tokenRef(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <label>_tree = <createNodeFromToken(...)>;
 this.adaptor.addChild(root_0, <label>_tree);
-<if(backtracking)>}<endif>
+})>
 >>
 
 /** ID! and output=AST (same as plain tokenRef) */
-tokenRefBang(token,label,elementIndex) ::= "<super.tokenRef(...)>"
+tokenRefBang(token,label,elementIndex,terminalOptions={}) ::= "<super.tokenRef(...)>"
 
 /** ID^ and output=AST */
-tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefRuleRoot(token,label,elementIndex,terminalOptions={}) ::= <<
 <super.tokenRef(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <label>_tree = <createNodeFromToken(...)>;
 root_0 = this.adaptor.becomeRoot(<label>_tree, root_0);
-<if(backtracking)>}<endif>
+})>
 >>
 
 /** ids+=ID! and output=AST */
-tokenRefBangAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefBangAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRefBang(...)>
 <listLabel(elem=label,...)>
 >>
 
 /** label+=TOKEN when output=AST but not rewrite alt */
-tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRef(...)>
 <listLabel(elem=label,...)>
 >>
 
 /** Match label+=TOKEN^ when output=AST but not rewrite alt */
-tokenRefRuleRootAndListLabel(token,label,terminalOptions,elementIndex) ::= <<
+tokenRefRuleRootAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRefRuleRoot(...)>
 <listLabel(elem=label,...)>
 >>
@@ -69,24 +81,24 @@ tokenRefRuleRootAndListLabel(token,label,terminalOptions,elementIndex) ::= <<
 // rather than just added on code.  Investigate that refactoring when
 // I have more time.
 
-matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
-<super.matchSet(..., postmatchCode={<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>this.adaptor.addChild(root_0, <createNodeFromToken(...)>);})>
+matchSet(s,label,elementIndex,postmatchCode,terminalOptions={}) ::= <<
+<super.matchSet(postmatchCode={<finishedBacktracking({this.adaptor.addChild(root_0, <createNodeFromToken(...)>);})>}, ...)>
 >>
 
-matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
+matchRuleBlockSet(s,label,elementIndex,postmatchCode,treeLevel="0",terminalOptions={}) ::= <<
 <matchSet(...)>
 >>
 
-matchSetBang(s,label,elementIndex,postmatchCode) ::= "<super.matchSet(...)>"
+matchSetBang(s,label,elementIndex,postmatchCode,terminalOptions={}) ::= "<super.matchSet(...)>"
 
 // note there is no matchSetTrack because -> rewrites force sets to be
 // plain old blocks of alts: (A|B|...|C)
 
-matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
+matchSetRuleRoot(s,label,elementIndex,debug,terminalOptions={}) ::= <<
 <if(label)>
 <label>=input.LT(1);<\n>
 <endif>
-<super.matchSet(..., postmatchCode={<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>root_0 = this.adaptor.becomeRoot(<createNodeFromToken(...)>, root_0);})>
+<super.matchSet(postmatchCode={<finishedBacktracking({root_0 = this.adaptor.becomeRoot(<createNodeFromToken(...)>, root_0);})>}, ...)>
 >>
 
 // RULE REF AST
@@ -94,7 +106,7 @@ matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
 /** rule when output=AST */
 ruleRef(rule,label,elementIndex,args,scope) ::= <<
 <super.ruleRef(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>this.adaptor.addChild(root_0, <label>.getTree());
+<finishedBacktracking({this.adaptor.addChild(root_0, <label>.getTree());})>
 >>
 
 /** rule! is same as normal rule ref */
@@ -103,48 +115,48 @@ ruleRefBang(rule,label,elementIndex,args,scope) ::= "<super.ruleRef(...)>"
 /** rule^ */
 ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
 <super.ruleRef(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>root_0 = this.adaptor.becomeRoot(<label>.getTree(), root_0);
+<finishedBacktracking({root_0 = this.adaptor.becomeRoot(<label>.getTree(), root_0);})>
 >>
 
 /** x+=rule when output=AST */
 ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRef(...)>
-<listLabel(elem=label+".getTree()",...)>
+<listLabel(label, {<label>.getTree()})>
 >>
 
 /** x+=rule! when output=AST is a rule ref with list addition */
 ruleRefBangAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRefBang(...)>
-<listLabel(elem=label+".getTree()",...)>
+<listLabel(label, {<label>.getTree()})>
 >>
 
 /** x+=rule^ */
 ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRefRuleRoot(...)>
-<listLabel(elem=label+".getTree()",...)>
+<listLabel(label, {<label>.getTree()})>
 >>
 
 // WILDCARD AST
 
-wildcard(label,elementIndex) ::= <<
+wildcard(token,label,elementIndex,terminalOptions={}) ::= <<
 <super.wildcard(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <label>_tree = this.adaptor.create(<label>);
 this.adaptor.addChild(root_0, <label>_tree);
-<if(backtracking)>}<endif>
+})>
 >>
 
 wildcardBang(label,elementIndex) ::= "<super.wildcard(...)>"
 
-wildcardRuleRoot(label,elementIndex) ::= <<
+wildcardRuleRoot(token,label,elementIndex,terminalOptions={}) ::= <<
 <super.wildcard(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <label>_tree = this.adaptor.create(<label>);
 root_0 = this.adaptor.becomeRoot(<label>_tree, root_0);
-<if(backtracking)>}<endif>
+})>
 >>
 
-createNodeFromToken(label,terminalOptions) ::= <<
+createNodeFromToken(label,terminalOptions={}) ::= <<
 <if(terminalOptions.node)>
 new <terminalOptions.node>(<label>) <! new MethodNode(IDLabel) !>
 <else>
@@ -154,8 +166,8 @@ this.adaptor.create(<label>)
 
 ruleCleanUp() ::= <<
 <super.ruleCleanUp()>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<\n><endif>
+<finishedBacktracking({
 retval.tree = this.adaptor.rulePostProcessing(root_0);
 this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
-<if(backtracking)>}<endif>
+})>
 >>
diff --git a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTTreeParser.stg b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTTreeParser.stg
index df15de15f..bc80968b4 100755
--- a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTTreeParser.stg
+++ b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/ASTTreeParser.stg
@@ -9,7 +9,16 @@
  *  Each combination has its own template except that label/no label
  *  is combined into tokenRef, ruleRef, ...
  */
-group ASTTreeParser;
+
+finishedBacktracking(block) ::= <<
+<if(backtracking)>
+if( <actions.(actionScope).synpredgate> ) {
+    <block>
+}
+<else>
+<block>
+<endif>
+>>
 
 /** Add a variable to track last element matched */
 ruleDeclarations() ::= <<
@@ -22,13 +31,13 @@ var _last = null;<\n>
  *  mode, does nothing.
  */
 noRewrite(rewriteBlockLevel, treeLevel) ::= <<
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <if(rewriteMode)>
 retval.tree = _first_0;
 if ( this.adaptor.getParent(retval.tree) && this.adaptor.isNil( this.adaptor.getParent(retval.tree) ) )
     retval.tree = this.adaptor.getParent(retval.tree);
 <endif>
-<if(backtracking)>}<endif>
+})>
 >>
 
 /** match ^(root children) in tree parser; override here to
@@ -45,12 +54,13 @@ var root_<treeLevel> = this.adaptor.nil();
 <endif>
 <root:element()>
 <if(rewriteMode)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> )<endif>
+<finishedBacktracking({
 <if(root.el.rule)>
 if ( !_first_<enclosingTreeLevel> ) _first_<enclosingTreeLevel> = <root.el.label>.tree;
 <else>
 if ( !_first_<enclosingTreeLevel> ) _first_<enclosingTreeLevel> = <root.el.label>;
 <endif>
+})>
 <endif>
 <actionsAfterRoot:element()>
 <if(nullableChildList)>
@@ -76,121 +86,140 @@ _last = _save_last_<treeLevel>;
 /** ID! and output=AST (same as plain tokenRef) 'cept add
  *  setting of _last
  */
-tokenRefBang(token,label,elementIndex) ::= <<
+tokenRefBang(token,label,elementIndex,terminalOptions={}) ::= <<
 _last = this.input.LT(1);
 <super.tokenRef(...)>
 >>
 
 /** ID auto construct */
-tokenRef(token,label,elementIndex,terminalOptions) ::= <<
+tokenRef(token,label,elementIndex,terminalOptions={}) ::= <<
 _last = this.input.LT(1);
 <super.tokenRef(...)>
 <if(!rewriteMode)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <if(terminalOptions.node)>
 <label>_tree = new <terminalOptions.node>(<label>);
 <else>
 <label>_tree = this.adaptor.dupNode(<label>);
 <endif><\n>
 this.adaptor.addChild(root_<treeLevel>, <label>_tree);
-<if(backtracking)>}<endif>
+})>
 <else> <! rewrite mode !>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> )<endif>
+<finishedBacktracking({
 if ( !_first_<treeLevel> ) _first_<treeLevel> = <label>;
+})>
 <endif>
 >>
 
 /** label+=TOKEN auto construct */
-tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRef(...)>
 <listLabel(elem=label,...)>
 >>
 
 /** ^(ID ...) auto construct */
-tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefRuleRoot(token,label,elementIndex,terminalOptions={}) ::= <<
 _last = this.input.LT(1);
 <super.tokenRef(...)>
 <if(!rewriteMode)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <if(terminalOptions.node)>
 <label>_tree = new <terminalOptions.node>(<label>);
 <else>
 <label>_tree = this.adaptor.dupNode(<label>);
 <endif><\n>
 root_<treeLevel> = this.adaptor.becomeRoot(<label>_tree, root_<treeLevel>);
-<if(backtracking)>}<endif>
+})>
 <endif>
 >>
 
 /** Match ^(label+=TOKEN ...) auto construct */
-tokenRefRuleRootAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+tokenRefRuleRootAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <tokenRefRuleRoot(...)>
 <listLabel(elem=label,...)>
 >>
 
-// SET AST
+/** Match . wildcard and auto dup the node/subtree */
+wildcard(token,label,elementIndex,terminalOptions={}) ::= <<
+_last = this.input.LT(1);
+<super.wildcard(...)>
+<if(!rewriteMode)>
+<finishedBacktracking({
+<label>_tree = this.adaptor.dupTree(<label>);
+this.adaptor.addChild(root_<treeLevel>, <label>_tree);
+})>
+<else> <! rewrite mode !>
+<finishedBacktracking({
+if ( !_first_<treeLevel> ) _first_<treeLevel> = <label>;
+})>
+<endif>
+>>
 
-matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
+// SET AST
+matchSet(s,label,elementIndex,postmatchCode,terminalOptions={}) ::= <<
 _last = this.input.LT(1);
-<super.matchSet(..., postmatchCode={
+<super.matchSet(postmatchCode={
 <if(!rewriteMode)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <if(terminalOptions.node)>
 <label>_tree = new <terminalOptions.node>(<label>);
 <else>
 <label>_tree = this.adaptor.dupNode(<label>);
 <endif><\n>
 this.adaptor.addChild(root_<treeLevel>, <label>_tree);
-<if(backtracking)>}<endif>
+})>
 <endif>
-}
-)>
+}, ...)>
 >>
 
-matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
+matchRuleBlockSet(s,label,elementIndex,postmatchCode,treeLevel="0",terminalOptions={}) ::= <<
 <matchSet(...)>
 <noRewrite()> <! set return tree !>
 >>
 
-matchSetBang(s,label,elementIndex,postmatchCode) ::= <<
+matchSetBang(s,label,elementIndex,postmatchCode,terminalOptions={}) ::= <<
 _last = this.input.LT(1);
 <super.matchSet(...)>
 >>
 
-matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
-<super.matchSet(..., postmatchCode={
+matchSetRuleRoot(s,label,elementIndex,debug,terminalOptions={}) ::= <<
+<super.matchSet(postmatchCode={
 <if(!rewriteMode)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<endif>
+<finishedBacktracking({
 <if(terminalOptions.node)>
 <label>_tree = new <terminalOptions.node>(<label>);
 <else>
 <label>_tree = this.adaptor.dupNode(<label>);
 <endif><\n>
 root_<treeLevel> = this.adaptor.becomeRoot(<label>_tree, root_<treeLevel>);
-<if(backtracking)>}<endif>
+})>
 <endif>
-}
-)>
+}, ...)>
 >>
 
 // RULE REF AST
 
 /** rule auto construct */
 ruleRef(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
 _last = this.input.LT(1);
 <super.ruleRef(...)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>
+<finishedBacktracking({
 <if(!rewriteMode)>
 this.adaptor.addChild(root_<treeLevel>, <label>.getTree());
 <else> <! rewrite mode !>
 if ( !_first_<treeLevel> ) _first_<treeLevel> = <label>.tree;
 <endif>
+})>
+<else>
+<super.ruleRef(...)>
+<endif>
 >>
 
 /** x+=rule auto construct */
 ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRef(...)>
-<listLabel(elem=label+".getTree()",...)>
+<listLabel(label, {<label>.getTree()})>
 >>
 
 /** ^(rule ...) auto construct */
@@ -198,14 +227,16 @@ ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
 _last = this.input.LT(1);
 <super.ruleRef(...)>
 <if(!rewriteMode)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>root_<treeLevel> = this.adaptor.becomeRoot(<label>.getTree(), root_<treeLevel>);
+<finishedBacktracking({
+root_<treeLevel> = this.adaptor.becomeRoot(<label>.getTree(), root_<treeLevel>);
+})>
 <endif>
 >>
 
 /** ^(x+=rule ...) auto construct */
 ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRefRuleRoot(...)>
-<listLabel(elem=label+".getTree()",...)>
+<listLabel(label, {<label>.tree})>
 >>
 
 /** rule when output=AST and tracking for rewrite */
@@ -235,7 +266,7 @@ _last = this.input.LT(1);
 /** Streams for token refs are tree nodes now; override to
  *  change nextToken to nextNode.
  */
-createRewriteNodeFromElement(token,terminalOptions,scope) ::= <<
+createRewriteNodeFromElement(token,scope,terminalOptions={}) ::= <<
 <if(terminalOptions.node)>
 new <terminalOptions.node>(stream_<token>.nextNode())
 <else>
@@ -246,8 +277,8 @@ stream_<token>.nextNode()
 ruleCleanUp() ::= <<
 <super.ruleCleanUp()>
 <if(!rewriteMode)>
-<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) {<\n><endif>
+<finishedBacktracking({
 retval.tree = this.adaptor.rulePostProcessing(root_0);
-<if(backtracking)>}<endif>
+})>
 <endif>
 >>
diff --git a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/JavaScript.stg b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/JavaScript.stg
index 73cbaf42c..31a11bcc6 100755
--- a/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/JavaScript.stg
+++ b/tool/src/main/resources/org/antlr/codegen/templates/JavaScript/JavaScript.stg
@@ -1,5 +1,20 @@
 group JavaScript;
 
+/** The API version of the runtime that recognizers generated by this runtime
+ *  need.
+ */
+apiVersion() ::= "1"
+
+// System.Boolean.ToString() returns "True" and "False", but the proper C# literals are "true" and "false"
+// The Java version of Boolean returns "true" and "false", so they map to themselves here.
+booleanLiteral ::= [
+	       "True":"true",
+	       "False":"false",
+	       "true":"true",
+	       "false":"false",
+	       default:"false"
+]
+
 /** The overall file structure of a recognizer; stores methods for rules
  *  and cyclic DFAs plus support code.
  */
@@ -21,10 +36,12 @@ outputFile(LEXER,PARSER,TREE_PARSER, actionScope, actions,
 
 <docComment>
 <recognizer>
+
+<actions.(actionScope).footer>
 >>
 
-lexer(grammar, name, tokens, scopes, rules, numRules, labelType="Token",
-      filterMode, superClass="org.antlr.runtime.Lexer") ::= <<
+lexer(grammar, name, tokens, scopes, rules, numRules, filterMode,
+      labelType="Token", superClass="org.antlr.runtime.Lexer") ::= <<
 var <grammar.recognizerName> = function(input, state<grammar.delegators:{g|, <g:delegateName()>}>) {
 // alternate constructor @todo
 // public <grammar.recognizerName>(CharStream input<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
@@ -49,21 +66,22 @@ var <grammar.recognizerName> = function(input, state<grammar.delegators:{g|, <g:
        {g|this.<g:delegateName()> = new <g.recognizerName>(input, state<trunc(g.delegators):{p|, <p:delegateName()>}>, this);}; separator="\n">
     <grammar.delegators:
        {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
-    <last(grammar.delegators):{g|this.gParent = this.<g:delegateName()>;}>
+    <last(grammar.delegators):
+       {g|this.gParent = this.<g:delegateName()>;}; separator="\n">
 
     <actions.lexer.init>
 };
 
 org.antlr.lang.augmentObject(<grammar.recognizerName>, {
-    <tokens:{<it.name>: <it.type>}; separator=",\n">
+    <tokens:{it | <it.name>: <it.type>}; separator=",\n">
 });
 
 (function(){
 var HIDDEN = org.antlr.runtime.Token.HIDDEN_CHANNEL,
     EOF = org.antlr.runtime.Token.EOF;
 org.antlr.lang.extend(<grammar.recognizerName>, <@superClassName><superClass><@end>, {
-    <tokens:{<it.name> : <it.type>,}; separator="\n">
-    <scopes:{<if(it.isDynamicGlobalScope)><globalAttributeScope(scope=it)><endif>}>
+    <tokens:{it | <it.name> : <it.type>,}; separator="\n">
+    <scopes:{it | <if(it.isDynamicGlobalScope)><globalAttributeScope(scope=it)><endif>}>
     getGrammarFileName: function() { return "<fileName>"; }
 });
 org.antlr.lang.augmentObject(<grammar.recognizerName>.prototype, {
@@ -147,9 +165,10 @@ actionGate() ::= "this.state.backtracking===0"
 filteringActionGate() ::= "this.state.backtracking===1"
 
 /** How to generate a parser */
+
 genericParser(grammar, name, scopes, tokens, tokenNames, rules, numRules,
-              bitsets, inputStreamType, superClass,
-              ASTLabelType="Object", labelType, members, rewriteElementType) ::= <<
+              bitsets, inputStreamType, superClass, labelType, members,
+              rewriteElementType, filterMode, init, ASTLabelType="Object") ::= <<
 <! WARNING. bug in ST: this is cut-n-paste into Dbg.stg !>
 var <grammar.recognizerName> = function(input, state<grammar.delegators:{g|, <g:delegateName()>}>) {
     if (!state) {
@@ -175,12 +194,12 @@ var <grammar.recognizerName> = function(input, state<grammar.delegators:{g|, <g:
 };
 
 org.antlr.lang.augmentObject(<grammar.recognizerName>, {
-    <tokens:{<it.name>: <it.type>}; separator=",\n">
+    <tokens:{it | <it.name>: <it.type>}; separator=",\n">
 });
 
 (function(){
 // public class variables
-var <tokens:{<it.name>= <it.type>}; separator=",\n    ">;
+var <tokens:{it | <it.name> = <it.type>}; separator=",\n    ">;
 <if(TREE_PARSER)>
 var UP = org.antlr.runtime.Token.UP,
     DOWN = org.antlr.runtime.Token.DOWN;
@@ -191,7 +210,7 @@ var UP = org.antlr.runtime.Token.UP,
 org.antlr.lang.extend(<grammar.recognizerName>, org.antlr.runtime.<@superClassName><superClass><@end>, {
     <@members>
     <@end>
-    <scopes:{<if(it.isDynamicGlobalScope)><globalAttributeScope(scope=it)><endif>}>
+    <scopes:{it|<if(it.isDynamicGlobalScope)><globalAttributeScope(it)><endif>}>
 
     getTokenNames: function() { return <grammar.composite.rootGrammar.recognizerName>.tokenNames; },
     getGrammarFileName: function() { return "<fileName>"; }
@@ -204,7 +223,7 @@ org.antlr.lang.augmentObject(<grammar.recognizerName>.prototype, {
    appear to be defined in this recognizer. !>
     // Delegated rules
 <grammar.delegatedRules:{ruleDescriptor|
-    , <ruleDescriptor.name>: function(<ruleDescriptor.parameterScope:parameterScope(scope=it)>) \{ <if(ruleDescriptor.hasReturnValue)>return <endif>this.<ruleDescriptor.grammar:delegateName()>.<ruleDescriptor.name>(<ruleDescriptor.parameterScope.attributes:{a|<a.name>}; separator=", ">); \}}>
+    , <ruleDescriptor.name>: function(<ruleDescriptor.parameterScope:parameterScope()>) { <if(ruleDescriptor.hasReturnValue)>return <endif>this.<ruleDescriptor.grammar:delegateName()>.<ruleDescriptor.name>(<ruleDescriptor.parameterScope.attributes:{a|<a.name>}; separator=", ">); \}}>
 
 
 
@@ -219,8 +238,8 @@ org.antlr.lang.augmentObject(<grammar.recognizerName>, {
 <if(grammar.grammarIsRoot)>
     tokenNames: ["\<invalid>", "\<EOR>", "\<DOWN>", "\<UP>", <tokenNames; separator=", ">],<\n>
 <endif>
-    <bitsets:bitset(name={FOLLOW_<it.name>_in_<it.inName><it.tokenIndex>},
-                    words64=it.bits); separator=",\n">
+    <bitsets:{it | <bitset(name={FOLLOW_<tokenWorkaround(it.name)>_in_<it.inName><it.tokenIndex>},
+                    words64=it.bits)>}; separator=",\n">
 });
 
 })();
@@ -236,15 +255,30 @@ this.state.ruleMemo = {};<\n> <! index from 1..n !>
  {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
 >>
 
-parser(grammar, name, scopes, tokens, tokenNames, rules, numRules, bitsets, ASTLabelType="Object", superClass="Parser", labelType="Token", members={<actions.parser.members>}) ::= <<
-<genericParser(inputStreamType="TokenStream", rewriteElementType="Token", ...)>
+parser(grammar, name, scopes, tokens, tokenNames, rules, numRules, bitsets,
+       ASTLabelType="Object", superClass="Parser", labelType="Token",
+       members={<actions.parser.members>},
+       init={<actions.parser.init>}
+       ) ::= <<
+<genericParser(grammar, name, scopes, tokens, tokenNames, rules, numRules,
+              bitsets, "TokenStream", superClass,
+              labelType, members, "Token",
+              false, init, ASTLabelType)>
 >>
 
 /** How to generate a tree parser; same as parser except the input
  *  stream is a different type.
  */
-treeParser(grammar, name, scopes, tokens, tokenNames, globalAction, rules, numRules, bitsets, labelType={<ASTLabelType>}, ASTLabelType="var", superClass="tree.TreeParser", members={<actions.treeparser.members>}, filterMode) ::= <<
-<genericParser(inputStreamType="TreeNodeStream", rewriteElementType="Node", ...)>
+treeParser(grammar, name, scopes, tokens, tokenNames, globalAction, rules,
+           numRules, bitsets, filterMode, labelType={<ASTLabelType>}, ASTLabelType="var",
+           superClass="tree.TreeParser",
+           members={<actions.treeparser.members>},
+           init={<actions.treeparser.init>}
+           ) ::= <<
+<genericParser(grammar, name, scopes, tokens, tokenNames, rules, numRules,
+              bitsets, "TreeNodeStream", superClass,
+              labelType, members, "Node",
+              filterMode, init, ASTLabelType)>
 >>
 
 /** A simpler version of a rule template that is specific to the imaginary
@@ -257,7 +291,8 @@ treeParser(grammar, name, scopes, tokens, tokenNames, globalAction, rules, numRu
 synpredRule(ruleName, ruleDescriptor, block, description, nakedBlock) ::=
 <<
 // $ANTLR start "<ruleName>"
-<ruleName>_fragment: function(<ruleDescriptor.parameterScope:parameterScope(scope=it)>) {
+<ruleName>_fragment: function(<ruleDescriptor.parameterScope:parameterScope()>) {
+    <ruleLabelDefs()>
 <if(trace)>
     this.traceIn("<ruleName>_fragment", <ruleDescriptor.index>);
     try {
@@ -298,18 +333,18 @@ lexerSynpred(name) ::= <<
 
 ruleMemoization(name) ::= <<
 <if(memoize)>
-if ( this.state.backtracking>0 && this.alreadyParsedRule(this.input, <ruleDescriptor.index>) ) { return <ruleReturnValue()>; }
+if ( this.state.backtracking>0 && this.alreadyParsedRule(this.input, <ruleDescriptor.index>) ) { <returnStatement(({<ruleReturnValue()>}))> }
 <endif>
 >>
 
 /** How to test for failure and return from rule */
 checkRuleBacktrackFailure() ::= <<
-<if(backtracking)>if (this.state.failed) return <ruleReturnValue()>;<endif>
+<if(backtracking)>if (this.state.failed) <returnStatement(({<ruleReturnValue()>}))><endif>
 >>
 
 /** This rule has failed, exit indicating failure during backtrack */
 ruleBacktrackFailure() ::= <<
-<if(backtracking)>if (this.state.backtracking>0) {this.state.failed=true; return <ruleReturnValue()>;}<endif>
+<if(backtracking)>if (this.state.backtracking>0) {this.state.failed=true; <returnStatement(({<ruleReturnValue()>}))>}<endif>
 >>
 
 /** How to generate code for a rule.  This includes any return type
@@ -319,21 +354,42 @@ rule(ruleName,ruleDescriptor,block,emptyRule,description,exceptions,finally,memo
 <ruleAttributeScope(scope=ruleDescriptor.ruleScope)>
 <returnScope(scope=ruleDescriptor.returnScope)>
 
-// <fileName>:<description>
 // $ANTLR start "<ruleName>"
+// <fileName>:<description>
 <ruleDescriptor.actions.decorate>
-<ruleName>: function(<ruleDescriptor.parameterScope:parameterScope(scope=it)>) {
-    <if(trace)>this.traceIn("<ruleName>", <ruleDescriptor.index>);<endif>
+<ruleName>: function(<ruleDescriptor.parameterScope:parameterScope()>) {
+<if(trace)>
+    this.traceIn("<ruleName>", <ruleDescriptor.index>);
+<endif>
     <ruleScopeSetUp()>
     <ruleDeclarations()>
     <ruleLabelDefs()>
     <ruleDescriptor.actions.init>
     <@preamble()>
+    <@body><ruleBody()><@end>
+    <@postamble()>
+    <returnStatement(({<ruleReturnValue()>}), false)>
+} /* $ANTLR end "<ruleName>" */
+>>
+
+ruleBody() ::= <<
+<if(memoize)>
+<if(backtracking)>
+var success = false;<\n>
+<endif>
+<endif>
+try {
     try {
         <ruleMemoization(name=ruleName)>
         <block>
         <ruleCleanUp()>
         <(ruleDescriptor.actions.after):execAction()>
+
+<if(memoize)>
+<if(backtracking)>
+        success = true;<\n>
+<endif>
+<endif>
     }
 <if(exceptions)>
     <exceptions:{e|<catch(decl=e.decl,action=e.action)><\n>}>
@@ -354,17 +410,25 @@ rule(ruleName,ruleDescriptor,block,emptyRule,description,exceptions,finally,memo
 <endif>
 <endif>
 <endif>
-    finally {
-        <if(trace)>this.traceOut("<ruleName>", <ruleDescriptor.index>);<endif>
-        <memoize()>
-        <ruleScopeCleanUp()>
-        <finally>
-    }
-    <@postamble()>
-    return <ruleReturnValue()>;
+    finally { /* ensure the try isn't lonely */ }
+} finally {
+<if(trace)>
+    this.traceOut("<ruleName>", <ruleDescriptor.index>);<\n>
+<endif>
+    <memoize()>
+    <ruleScopeCleanUp()>
+    <finally>
 }
 >>
 
+returnStatement(returnValue, force=true) ::= <%
+<if(!isEmptyString.(returnValue))>
+	return <returnValue>;
+<elseif(force)>
+	return;
+<endif>
+%>
+
 catch(decl,action) ::= <<
 catch (<e.decl>) {
     <e.action>
@@ -375,7 +439,7 @@ ruleDeclarations() ::= <<
 <if(ruleDescriptor.hasMultipleReturnValues)>
 var retval = new <returnType()>();
 retval.start = this.input.LT(1);<\n>
-<else>
+<elseif(ruleDescriptor.returnScope)>
 <ruleDescriptor.returnScope.attributes:{ a |
 var <a.name> = <if(a.initValue)><a.initValue><else>null<endif>;
 }>
@@ -385,42 +449,45 @@ var <ruleDescriptor.name>_StartIndex = this.input.index();
 <endif>
 >>
 
+emptyObject() ::= "{}"
+
 ruleScopeSetUp() ::= <<
-<ruleDescriptor.useScopes:{this.<it>_stack.push({});}; separator="\n">
-<ruleDescriptor.ruleScope:{this.<it.name>_stack.push({});}; separator="\n">
+<ruleDescriptor.useScopes:{it | this.<it>_stack.push(<emptyObject()>);}; separator="\n">
+<ruleDescriptor.ruleScope:{it | this.<it.name>_stack.push(<emptyObject()>);}; separator="\n">
 >>
 
 ruleScopeCleanUp() ::= <<
-<ruleDescriptor.useScopes:{this.<it>_stack.pop();}; separator="\n">
-<ruleDescriptor.ruleScope:{this.<it.name>_stack.pop();}; separator="\n">
+<ruleDescriptor.useScopes:{it | this.<it>_stack.pop();}; separator="\n">
+<ruleDescriptor.ruleScope:{it | this.<it.name>_stack.pop();}; separator="\n">
 >>
 
 ruleLabelDefs() ::= <<
-<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels]
-    :{var <it.label.text> = null;}; separator="\n"
+<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels,
+  ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
+    :{it | var <it.label.text> = null;}; separator="\n"
 >
-<[ruleDescriptor.tokenListLabels,ruleDescriptor.ruleListLabels]
-    :{var list_<it.label.text>=null;}; separator="\n"
+<[ruleDescriptor.tokenListLabels,ruleDescriptor.ruleListLabels,
+  ruleDescriptor.wildcardTreeListLabels]
+    :{it | var list_<it.label.text>=null;}; separator="\n"
 >
-<ruleDescriptor.ruleLabels:ruleLabelDef(label=it); separator="\n">
-<ruleDescriptor.ruleListLabels:{ll|var <ll.label.text> = null;}; separator="\n">
+<ruleDescriptor.ruleLabels:ruleLabelDef(); separator="\n">
+<ruleDescriptor.ruleListLabels:{it | var <it.label.text> = null;}; separator="\n">
 >>
 
 lexerRuleLabelDefs() ::= <<
 <[ruleDescriptor.tokenLabels,
   ruleDescriptor.tokenListLabels,
   ruleDescriptor.ruleLabels]
-    :{var <it.label.text>=null;}; separator="\n"
+    :{it | var <it.label.text>=null;}; separator="\n"
 >
-<ruleDescriptor.charLabels:{var <it.label.text>;}; separator="\n">
+<ruleDescriptor.charLabels:{it | var <it.label.text>;}; separator="\n">
 <[ruleDescriptor.tokenListLabels,
-  ruleDescriptor.ruleListLabels,
   ruleDescriptor.ruleListLabels]
-    :{var list_<it.label.text>=null;}; separator="\n"
+    :{it | var list_<it.label.text>=null;}; separator="\n"
 >
 >>
 
-ruleReturnValue() ::= <<
+ruleReturnValue() ::= <%
 <if(!ruleDescriptor.isSynPred)>
 <if(ruleDescriptor.hasReturnValue)>
 <if(ruleDescriptor.hasSingleReturnValue)>
@@ -430,7 +497,7 @@ retval
 <endif>
 <endif>
 <endif>
->>
+%>
 
 ruleCleanUp() ::= <<
 <if(ruleDescriptor.hasMultipleReturnValues)>
@@ -443,7 +510,9 @@ retval.stop = this.input.LT(-1);<\n>
 memoize() ::= <<
 <if(memoize)>
 <if(backtracking)>
-if ( this.state.backtracking>0 ) { this.memoize(this.input, <ruleDescriptor.index>, <ruleDescriptor.name>_StartIndex); }
+if ( this.state.backtracking>0 ) {
+    this.memoize(this.input, <ruleDescriptor.index>, <ruleDescriptor.name>_StartIndex);
+}
 <endif>
 <endif>
 >>
@@ -453,10 +522,17 @@ if ( this.state.backtracking>0 ) { this.memoize(this.input, <ruleDescriptor.inde
  */
 lexerRule(ruleName,nakedBlock,ruleDescriptor,block,memoize) ::= <<
 // $ANTLR start <ruleName>
-m<ruleName>: function(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)  {
-    <if(trace)>this.traceIn("<ruleName>", <ruleDescriptor.index>);<endif>
+m<ruleName>: function(<ruleDescriptor.parameterScope:parameterScope()>)  {
+<if(trace)>
+    this.traceIn("<ruleName>", <ruleDescriptor.index>);<\n>
+<endif>
     <ruleScopeSetUp()>
     <ruleDeclarations()>
+<if(memoize)>
+<if(backtracking)>
+    var success = false;<\n>
+<endif>
+<endif>
     try {
 <if(nakedBlock)>
         <ruleMemoization(name=ruleName)>
@@ -466,6 +542,7 @@ m<ruleName>: function(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)
 <else>
         var _type = this.<ruleName>;
         var _channel = org.antlr.runtime.BaseRecognizer.DEFAULT_TOKEN_CHANNEL;
+
         <ruleMemoization(name=ruleName)>
         <lexerRuleLabelDefs()>
         <ruleDescriptor.actions.init>
@@ -475,9 +552,15 @@ m<ruleName>: function(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)
         this.state.channel = _channel;
         <(ruleDescriptor.actions.after):execAction()>
 <endif>
-    }
-    finally {
-        <if(trace)>this.traceOut("<ruleName>", <ruleDescriptor.index>);<endif>
+<if(memoize)>
+<if(backtracking)>
+        success = true<\n>
+<endif>
+<endif>
+    } finally {
+<if(trace)>
+        this.traceOut("<ruleName>", <ruleDescriptor.index>);<\n>
+<endif>
         <ruleScopeCleanUp()>
         <memoize()>
     }
@@ -501,12 +584,16 @@ block(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,max
 // <fileName>:<description>
 var alt<decisionNumber>=<maxAlt>;
 <decls>
+<@body><blockBody()><@end>
+>>
+
+blockBody() ::= <<
 <@predecision()>
-<decision>
+<@decision><decision><@end>
 <@postdecision()>
 <@prebranch()>
 switch (alt<decisionNumber>) {
-    <alts:altSwitchCase()>
+    <alts:{a | <altSwitchCase(i, a)>}>
 }
 <@postbranch()>
 >>
@@ -517,10 +604,10 @@ ruleBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK
 var alt<decisionNumber>=<maxAlt>;
 <decls>
 <@predecision()>
-<decision>
+<@decision><decision><@end>
 <@postdecision()>
 switch (alt<decisionNumber>) {
-    <alts:altSwitchCase()>
+    <alts:{a | <altSwitchCase(i, a)>}>
 }
 >>
 
@@ -547,26 +634,32 @@ positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decision
 var cnt<decisionNumber>=0;
 <decls>
 <@preloop()>
+<@loopBody>
+<positiveClosureBlockLoop()>
+<@end>
+<@postloop()>
+>>
+
+positiveClosureBlockLoop() ::= <<
 loop<decisionNumber>:
 do {
     var alt<decisionNumber>=<maxAlt>;
     <@predecision()>
-    <decision>
+    <@decisionBody><decision><@end>
     <@postdecision()>
     switch (alt<decisionNumber>) {
-    <alts:altSwitchCase()>
+    <alts:{a | <altSwitchCase(i,a)>}>
     default :
         if ( cnt<decisionNumber> >= 1 ) {
             break loop<decisionNumber>;
         }
         <ruleBacktrackFailure()>
-            var eee = new org.antlr.runtime.EarlyExitException(<decisionNumber>, this.input);
-            <@earlyExitException()>
-            throw eee;
+        var eee = new org.antlr.runtime.EarlyExitException(<decisionNumber>, this.input);
+        <@earlyExitException()>
+        throw eee;
     }
     cnt<decisionNumber>++;
 } while (true);
-<@postloop()>
 >>
 
 positiveClosureBlockSingleAlt ::= positiveClosureBlock
@@ -576,19 +669,25 @@ closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,m
 // <fileName>:<description>
 <decls>
 <@preloop()>
+<@loopBody>
+<closureBlockLoop()>
+<@end>
+<@postloop()>
+>>
+
+closureBlockLoop() ::= <<
 loop<decisionNumber>:
 do {
     var alt<decisionNumber>=<maxAlt>;
     <@predecision()>
-    <decision>
+    <@decisionBody><decision><@end>
     <@postdecision()>
     switch (alt<decisionNumber>) {
-    <alts:altSwitchCase()>
+    <alts:{a | <altSwitchCase(i,a)>}>
     default :
         break loop<decisionNumber>;
     }
 } while (true);
-<@postloop()>
 >>
 
 closureBlockSingleAlt ::= closureBlock
@@ -604,15 +703,15 @@ optionalBlockSingleAlt ::= block
  *  number.  A DFA predicts the alternative and then a simple switch
  *  does the jump to the code that actually matches that alternative.
  */
-altSwitchCase() ::= <<
-case <i> :
+altSwitchCase(altNum,alt) ::= <<
+case <altNum> :
     <@prealt()>
-    <it>
+    <alt>
     break;<\n>
 >>
 
 /** An alternative is just a list of elements; at outermost level */
-alt(elements,altNum,description,autoAST,outerAlt,treeLevel,rew) ::= <<
+alt(elements,altNum,description,autoAST,outerAlt, treeLevel,rew) ::= <<
 // <fileName>:<description>
 <! (function() { /* @todo4 (do we really need a new scope?) */ !>
 <@declarations()>
@@ -630,23 +729,23 @@ noRewrite(rewriteBlockLevel, treeLevel) ::= ""
 // E L E M E N T S
 
 /** Dump the elements one per line */
-element() ::= <<
+element(e) ::= <<
 <@prematch()>
-<it.el><\n>
+<e.el><\n>
 >>
 
 /** match a token optionally with a label in front */
-tokenRef(token,label,elementIndex,terminalOptions) ::= <<
-<if(label)><label>=<endif>this.match(this.input,<token>,<grammar.recognizerName>.FOLLOW_<token>_in_<ruleName><elementIndex>); <checkRuleBacktrackFailure()>
+tokenRef(token,label,elementIndex,terminalOptions={}) ::= <<
+<if(label)><label> = <endif>this.match(this.input, <tokenWorkaround(token)>, <grammar.recognizerName>.FOLLOW_<tokenWorkaround(token)>_in_<ruleName><elementIndex>); <checkRuleBacktrackFailure()>
 >>
 
 /** ids+=ID */
-tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
-<tokenRef(...)>
-<listLabel(elem=label,...)>
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
+<tokenRef(token,label,elementIndex,terminalOptions)>
+<listLabel(label, label)>
 >>
 
-listLabel(label,elem) ::= <<
+listLabel(label, elem) ::= <<
 if (org.antlr.lang.isNull(list_<label>)) list_<label> = [];
 list_<label>.push(<elem>);<\n>
 >>
@@ -668,7 +767,7 @@ this.matchRange(<a>,<b>); <checkRuleBacktrackFailure()>
 >>
 
 /** For now, sets are interval tests and must be tested inline */
-matchSet(s,label,elementIndex,postmatchCode="") ::= <<
+matchSet(s,label,elementIndex,postmatchCode="",terminalOptions={}) ::= <<
 <if(label)>
 <if(LEXER)>
 <label>= this.input.LA(1);<\n>
@@ -704,11 +803,11 @@ matchRuleBlockSet ::= matchSet
 
 matchSetAndListLabel(s,label,elementIndex,postmatchCode) ::= <<
 <matchSet(...)>
-<listLabel(elem=label,...)>
+<listLabel(label, label)>
 >>
 
 /** Match a string literal */
-lexerStringRef(string,label,elementIndex) ::= <<
+lexerStringRef(string,label,elementIndex="0") ::= <<
 <if(label)>
 var <label>Start = this.getCharIndex();
 this.match(<string>); <checkRuleBacktrackFailure()>
@@ -718,16 +817,16 @@ this.match(<string>); <checkRuleBacktrackFailure()><\n>
 <endif>
 >>
 
-wildcard(label,elementIndex) ::= <<
+wildcard(token,label,elementIndex,terminalOptions={}) ::= <<
 <if(label)>
 <label>=this.input.LT(1);<\n>
 <endif>
 this.matchAny(this.input); <checkRuleBacktrackFailure()>
 >>
 
-wildcardAndListLabel(label,elementIndex) ::= <<
+wildcardAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<
 <wildcard(...)>
-<listLabel(elem=label,...)>
+<listLabel(label,label)>
 >>
 
 /** Match . wildcard in lexer */
@@ -739,13 +838,15 @@ this.matchAny(); <checkRuleBacktrackFailure()>
 >>
 
 wildcardCharListLabel(label, elementIndex) ::= <<
-<wildcardChar(...)>
-<listLabel(elem=label,...)>
+<wildcardChar(label, elementIndex)>
+<listLabel(label,label)>
 >>
 
-// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 /** Match a rule reference by invoking it possibly with arguments
- *  and a return value or values.
+ *  and a return value or values. The 'rule' argument was the
+ *  target rule name, but now is type Rule, whose toString is
+ *  same: the rule name.  Now though you can access full rule
+ *  descriptor stuff.
  */
 ruleRef(rule,label,elementIndex,args,scope) ::= <<
 this.pushFollow(<grammar.recognizerName>.FOLLOW_<rule.name>_in_<ruleName><elementIndex>);
@@ -756,8 +857,8 @@ this.state._fsp--;
 
 /** ids+=r */
 ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
-<ruleRef(...)>
-<listLabel(elem=label,...)>
+<ruleRef(rule,label,elementIndex,args,scope)>
+<listLabel(label, label)>
 >>
 
 /** A lexer rule reference */
@@ -773,8 +874,8 @@ this.<if(scope)><scope:delegateName()>.<endif>m<rule.name>(<args; separator=", "
 
 /** i+=INT in lexer */
 lexerRuleRefAndListLabel(rule,label,args,elementIndex,scope) ::= <<
-<lexerRuleRef(...)>
-<listLabel(elem=label,...)>
+<lexerRuleRef(rule,label,args,elementIndex,scope)>
+<listLabel(label, label)>
 >>
 
 /** EOF in the lexer */
@@ -789,14 +890,15 @@ this.match(this.EOF); <checkRuleBacktrackFailure()>
 >>
 
 // used for left-recursive rules
-recRuleDefArg()                       ::= "int <recRuleArg()>"
+recRuleDefArg()                       ::= "<recRuleArg()>"
 recRuleArg()                          ::= "_p"
 recRuleAltPredicate(ruleName,opPrec)  ::= "<recRuleArg()> \<= <opPrec>"
-recRuleSetResultAction()              ::= "root_0=$<ruleName>_primary.tree;"
-recRuleSetReturnAction(src,name)      ::= "$<name>=$<src>.<name>;"
+recRuleSetResultAction()              ::= "root_0 = $<ruleName>_primary.getTree();"
+recRuleSetReturnAction(src,name)      ::= "$<name> = $<src>.<name>;"
 
 /** match ^(root children) in tree parser */
-tree(root, actionsAfterRoot, children, nullableChildList,enclosingTreeLevel, treeLevel) ::= <<
+tree(root, actionsAfterRoot, children, nullableChildList,
+     enclosingTreeLevel, treeLevel) ::= <<
 <root:element()>
 <actionsAfterRoot:element()>
 <if(nullableChildList)>
@@ -827,9 +929,10 @@ if ( !(<evalPredicate(...)>) ) {
 dfaState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
 var LA<decisionNumber>_<stateNumber> = this.input.LA(<k>);<\n>
 <edges; separator="\nelse ">
+<if((!isTrue.(last(edges).labelExpr)) && (!last(edges).predicates))>
 else {
 <if(eotPredictsAlt)>
-    alt<decisionNumber>=<eotPredictsAlt>;
+    alt<decisionNumber> = <eotPredictsAlt>;
 <else>
     <ruleBacktrackFailure()>
     var nvae =
@@ -838,6 +941,7 @@ else {
     throw nvae;<\n>
 <endif>
 }
+<endif>
 >>
 
 /** Same as a normal DFA state except that we don't examine lookahead
@@ -861,17 +965,17 @@ var LA<decisionNumber>_<stateNumber> = this.input.LA(<k>);<\n>
 <edges; separator="\nelse "><\n>
 <if(eotPredictsAlt)>
 <if(!edges)>
-alt<decisionNumber>=<eotPredictsAlt>; <! if no edges, don't gen ELSE !>
+alt<decisionNumber> = <eotPredictsAlt>; <! if no edges, don't gen ELSE !>
 <else>
 else {
-    alt<decisionNumber>=<eotPredictsAlt>;
+    alt<decisionNumber> = <eotPredictsAlt>;
 }<\n>
 <endif>
 <endif>
 >>
 
 /** An accept state indicates a unique alternative has been predicted */
-dfaAcceptState(alt) ::= "alt<decisionNumber>=<alt>;"
+dfaAcceptState(alt) ::= "alt<decisionNumber> = <alt>;"
 
 /** A simple edge with an expression.  If the expression is satisfied,
  *  enter to the target state.  To handle gated productions, we may
@@ -893,7 +997,7 @@ switch ( this.input.LA(<k>) ) {
 <edges; separator="\n">
 default:
 <if(eotPredictsAlt)>
-    alt<decisionNumber>=<eotPredictsAlt>;
+    alt<decisionNumber> = <eotPredictsAlt>;
 <else>
     <ruleBacktrackFailure()>
     var nvae =
@@ -915,14 +1019,14 @@ switch ( this.input.LA(<k>) ) {
 <edges; separator="\n"><\n>
 <if(eotPredictsAlt)>
 default:
-    alt<decisionNumber>=<eotPredictsAlt>;
+    alt<decisionNumber> = <eotPredictsAlt>;
     break;<\n>
 <endif>
 }<\n>
 >>
 
 dfaEdgeSwitch(labels, targetState) ::= <<
-<labels:{case <it>:}; separator="\n">
+<labels:{it|case <tokenWorkaround(it)>:}; separator="\n">
     <targetState>
     break;
 >>
@@ -1077,40 +1181,44 @@ evalPredicate(pred,description) ::= "(<pred>)"
 
 evalSynPredicate(pred,description) ::= "this.<pred>()"
 
-lookaheadTest(atom,k,atomAsInt) ::= "LA<decisionNumber>_<stateNumber>==<atom>"
+lookaheadTest(atom,k,atomAsInt) ::= "LA<decisionNumber>_<stateNumber> === <atom>"
 
 /** Sometimes a lookahead test cannot assume that LA(k) is in a temp variable
  *  somewhere.  Must ask for the lookahead directly.
  */
-isolatedLookaheadTest(atom,k,atomAsInt) ::= "this.input.LA(<k>)==<atom>"
+isolatedLookaheadTest(atom,k,atomAsInt) ::= "this.input.LA(<k>) === <atom>"
 
-lookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= <<
-(LA<decisionNumber>_<stateNumber>\>=<lower> && LA<decisionNumber>_<stateNumber>\<=<upper>)
->>
+lookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= <%
+(<lower> \<= LA<decisionNumber>_<stateNumber> && LA<decisionNumber>_<stateNumber> \<= <upper>)
+%>
 
-isolatedLookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= "(this.input.LA(<k>)\>=<lower> && this.input.LA(<k>)\<=<upper>)"
+isolatedLookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= "(<lower> \<= this.input.LA(<k>) && this.input.LA(<k>) \<= <upper>)"
 
 setTest(ranges) ::= "<ranges; separator=\"||\">"
 
 // A T T R I B U T E S
 
 globalAttributeScope(scope) ::= <<
+<if(scope)>
 <if(scope.attributes)>
 <scope.name>_stack: [],<\n>
 <endif>
+<endif>
 >>
 
 ruleAttributeScope(scope) ::= <<
+<if(scope)>
 <if(scope.attributes)>
 <scope.name>_stack: [],<\n>
 <endif>
+<endif>
 >>
 
-returnStructName() ::= "<it.name>_return"
+returnStructName(r) ::= "<r.name>_return"
 
-returnType() ::= <<
+returnType() ::= <%
 <if(ruleDescriptor.hasMultipleReturnValues)>
-<ruleDescriptor.grammar.recognizerName>.<ruleDescriptor:returnStructName()>
+this.<ruleDescriptor:returnStructName()>
 <else>
 <if(ruleDescriptor.hasSingleReturnValue)>
 <ruleDescriptor.singleValueReturnType>
@@ -1118,7 +1226,7 @@ returnType() ::= <<
 void
 <endif>
 <endif>
->>
+%>
 
 /** Generate the Java type associated with a single or multiple return
  *  values.
@@ -1135,8 +1243,8 @@ void
 <endif>
 >>
 
-delegateName() ::= <<
-<if(it.label)><it.label><else>g<it.name><endif>
+delegateName(d) ::= <<
+<if(d.label)><d.label><else>g<d.name><endif>
 >>
 
 /** Using a type to init value map, try to init a type; if not in table
@@ -1159,19 +1267,22 @@ returnScope(scope) ::= <<
 <if(ruleDescriptor.hasMultipleReturnValues)>
 // inline static return class
 <ruleDescriptor:returnStructName()>: (function() {
-    <returnType()> = function(){};
-    org.antlr.lang.extend(<returnType()>,
-                      org.antlr.runtime.<if(TREE_PARSER)>tree.Tree<else>Parser<endif>RuleReturnScope,
+    var <ruleDescriptor:returnStructName()> = function(){};
+    org.antlr.lang.extend(<ruleDescriptor:returnStructName()>, <returnScopeBaseType()>,
     {
         <@ruleReturnMembers()>
     });
-    return;
+    return <ruleDescriptor:returnStructName()>;
 })(),
 <endif>
 >>
 
+returnScopeBaseType() ::= <%
+org.antlr.runtime.<if(TREE_PARSER)>tree.Tree<else>Parser<endif>RuleReturnScope
+%>
+
 parameterScope(scope) ::= <<
-<scope.attributes:{<it.decl>}; separator=", ">
+<if(scope)><scope.attributes:{it | <it.decl>}; separator=", "><endif>
 >>
 
 parameterAttributeRef(attr) ::= "<attr.name>"
@@ -1324,10 +1435,29 @@ execForcedAction(action) ::= "<action>"
 
 bitset(name, words64) ::= <<
 <! @todo overflow issue !>
-<name>: new org.antlr.runtime.BitSet([<words64:{<it>};separator=",">])
+<name>: new org.antlr.runtime.BitSet([<words64:{it|<it>};separator=",">])
 >>
 
 codeFileExtension() ::= ".js"
 
-true() ::= "true"
-false() ::= "false"
+tokenWorkaround(token) ::= <%
+<if(isInvalid.(token))>0<else><token><endif>
+%>
+
+isInvalid ::= [
+    "<INVALID>": true,
+    default: false
+]
+
+true_value() ::= "true"
+false_value() ::= "false"
+
+isEmptyString ::= [
+    "" : true,
+    default : false
+]
+
+isTrue ::= [
+    "true" : true,
+    default : false
+]