groovy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From emil...@apache.org
Subject [groovy] branch master updated: format and reduce patch burden
Date Sun, 01 Sep 2019 20:39:57 GMT
This is an automated email from the ASF dual-hosted git repository.

emilles pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git


The following commit(s) were added to refs/heads/master by this push:
     new 1aec7dc  format and reduce patch burden
1aec7dc is described below

commit 1aec7dcb6ecbe4b162a6e34ea11b038d6d158eb5
Author: Eric Milles <eric.milles@thomsonreuters.com>
AuthorDate: Sun Sep 1 15:39:55 2019 -0500

    format and reduce patch burden
---
 src/main/antlr2/org/codehaus/groovy/antlr/groovy.g | 547 +++++++--------------
 1 file changed, 166 insertions(+), 381 deletions(-)

diff --git a/src/main/antlr2/org/codehaus/groovy/antlr/groovy.g b/src/main/antlr2/org/codehaus/groovy/antlr/groovy.g
index 49f3bad..3f29054 100644
--- a/src/main/antlr2/org/codehaus/groovy/antlr/groovy.g
+++ b/src/main/antlr2/org/codehaus/groovy/antlr/groovy.g
@@ -16,18 +16,19 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-// Note: Please don't use physical tabs.  Logical tabs for indent are width 4.
+
 header {
 package org.codehaus.groovy.antlr.parser;
-import org.codehaus.groovy.antlr.*;
+
+import java.io.*;
 import java.util.*;
-import java.io.InputStream;
-import java.io.Reader;
+
+import antlr.CommonToken;
 import antlr.InputBuffer;
 import antlr.LexerSharedInputState;
-import antlr.CommonToken;
-import org.codehaus.groovy.GroovyBugError;
 import antlr.TokenStreamRecognitionException;
+
+import org.codehaus.groovy.antlr.*;
 }
 
 /** JSR-241 Groovy Recognizer.
@@ -246,14 +247,12 @@ tokens {
 }
 
 {
-        /** This factory is the correct way to wire together a Groovy parser and lexer. */
+    /** This factory is the correct way to wire together a Groovy parser and lexer. */
     public static GroovyRecognizer make(GroovyLexer lexer) {
         GroovyRecognizer parser = new GroovyRecognizer(lexer.plumb());
-        // TODO: set up a common error-handling control block, to avoid excessive tangle between these guys
         parser.lexer = lexer;
         lexer.parser = parser;
         parser.getASTFactory().setASTNodeClass(GroovySourceAST.class);
-        parser.warningList = new ArrayList();
         return parser;
     }
     // Create a scanner that reads from the input stream passed to us...
@@ -262,25 +261,25 @@ tokens {
     public static GroovyRecognizer make(InputBuffer in) { return make(new GroovyLexer(in)); }
     public static GroovyRecognizer make(LexerSharedInputState in) { return make(new GroovyLexer(in)); }
 
-    private static GroovySourceAST dummyVariableToforceClassLoaderToFindASTClass = new GroovySourceAST();
+    @SuppressWarnings("unused")
+    private static GroovySourceAST dummyVariableToForceClassLoaderToFindASTClass = new GroovySourceAST();
 
-    List warningList;
+    List warningList = new ArrayList();
     public List getWarningList() { return warningList; }
 
     GroovyLexer lexer;
     public GroovyLexer getLexer() { return lexer; }
-    public void setFilename(String f) { super.setFilename(f); lexer.setFilename(f); }
-    private SourceBuffer sourceBuffer;
+    public void setFilename(String f) { lexer.setFilename(f); super.setFilename(f); }
+
+    @Deprecated
     public void setSourceBuffer(SourceBuffer sourceBuffer) {
-        this.sourceBuffer = sourceBuffer;
     }
 
-    /** Create an AST node with the token type and text passed in, but
-     *  with the same background information as another supplied Token (e.g.&nbsp;line numbers).
+    /**
+     * Creates an AST node with the token type and text passed in, but
+     * with the same background information as another supplied Token (e.g.&nbsp;line numbers).
      * To be used in place of antlr tree construction syntax,
      * i.e. #[TOKEN,"text"]  becomes  create(TOKEN,"text",anotherToken)
-     *
-     * todo - change antlr.ASTFactory to do this instead...
      */
     public AST create(int type, String txt, AST first) {
         AST t = astFactory.create(type,txt);
@@ -317,9 +316,6 @@ tokens {
         return attachLast(create(type, txt, first), last);
     }
 
-    /**
-    *   Clones the token
-    */
     public Token cloneToken(Token t) {
         CommonToken clone = new CommonToken(t.getType(),t.getText());
         clone.setLine(t.getLine());
@@ -327,7 +323,6 @@ tokens {
         return clone;
     }
 
-
     // stuff to adjust ANTLR's tracing machinery
     public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceParser
     public void traceIn(String rname) throws TokenStreamException {
@@ -374,7 +369,7 @@ tokens {
         row.put("filename", getFilename());
         row.put("line",     Integer.valueOf(lt.getLine()));
         row.put("column",   Integer.valueOf(lt.getColumn()));
-        // System.out.println(row);
+
         warningList.add(row);
     }
 
@@ -429,22 +424,6 @@ tokens {
         if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
         return cname.equals(x.getText());
     }
-    
-    private void dumpTree(AST ast, String offset) {
-        dump(ast, offset);
-        for (AST node = ast.getFirstChild(); node != null; node = node.getNextSibling()) {
-            dumpTree(node, offset+"\t");
-        }
-    }
-
-    private void dump(AST node, String offset) {
-        System.out.println(offset+"Type: " + getTokenName(node) + " text: " + node.getText());
-    }
-    
-    private String getTokenName(AST node) {
-        if (node == null) return "null";
-        return getTokenName(node.getType());
-    }
 
     // Scratch variable for last 'sep' token.
     // Written by the 'sep' rule, read only by immediate callers of 'sep'.
@@ -486,6 +465,7 @@ tokens {
     // an enclosing loop, which is why this ugly hack (a fake
     // empty alternative with always-false semantic predicate)
     // is necessary.
+    @SuppressWarnings("unused")
     private static final boolean ANTLR_LOOP_EXIT = false;
 }
 
@@ -500,7 +480,7 @@ compilationUnit
         nls!
 
         // A compilation unit starts with an optional package definition
-        (   (annotationsOpt "package")=> packageDefinition
+        (   (annotationsOpt "package") => packageDefinition
         |   (statement[EOF])?
         )
 
@@ -515,25 +495,26 @@ snippetUnit
     :   nls! blockBody[EOF]
     ;
 
-
-// Package statement: optional annotations followed by "package" then the package identifier.
+// Package statement: optional annotations followed by "package" then the package identifier
 packageDefinition
         {Token first = LT(1);}
-        //TODO? options {defaultErrorHandler = true;} // let ANTLR handle errors
     :   an:annotationsOpt! "package"! id:identifier!
-        {#packageDefinition = #(create(PACKAGE_DEF,"package",first,LT(1)),an,id);}
+        {
+            #packageDefinition = #(create(PACKAGE_DEF,"package",first,LT(1)), an, id);
+        }
     ;
 
-
 // Import statement: import followed by a package or class name
 importStatement
-        //TODO? options {defaultErrorHandler = true;}
-        { Token first = LT(1); boolean isStatic = false; }
-    :   an:annotationsOpt "import"! ( "static"! {isStatic=true;} )? is:identifierStar!
-        {if (isStatic)
-            #importStatement = #(create(STATIC_IMPORT,"static_import",first,LT(1)),an,is);
-         else
-            #importStatement = #(create(IMPORT,"import",first,LT(1)),an,is);}
+        {Token first = LT(1); boolean isStatic = false;}
+    :   an:annotationsOpt "import"! ("static"! {isStatic = true;})? is:identifierStar!
+        {
+            if (!isStatic) {
+                #importStatement = #(create(IMPORT,"import",first,LT(1)), an, is);
+            } else {
+                #importStatement = #(create(STATIC_IMPORT,"static_import",first,LT(1)), an, is);
+            }
+        }
     ;
 
 // Protected type definitions production for reuse in other productions
@@ -664,12 +645,10 @@ qualifiedTypeName!
  */
 constructorStart!
     :
-        modifiersOpt! id:IDENT! {isConstructorIdent(id)}? nls! LPAREN! //...
+        modifiersOpt! id:IDENT! {isConstructorIdent(id)}? nls! LPAREN!
     ;
 
-
 /** Used only as a lookahead predicate for nested type definitions. */
-
 typeDefinitionStart!
     :   modifiersOpt! ("class" | "interface" | "enum" | "trait" | AT "interface")
     ;
@@ -713,7 +692,7 @@ classOrInterfaceType[boolean addImagNode]  {Token first = LT(1);}
         (   options{greedy=true;}: // match as many as possible
             d:DOT!
             i2:IDENT! (ta:typeArguments!)?
-            {#i1 = #(create(DOT,".",first,LT(1)),i1,i2,ta);}
+            {#i1 = #(create(DOT,".",first,LT(1)), i1, i2, ta);}
         )*
         {
             #classOrInterfaceType = #i1;
@@ -740,14 +719,14 @@ typeArgument  {Token first = LT(1);}
 // Wildcard type indicating all types (with possible constraint)
 wildcardType
     :   QUESTION
-        (("extends" | "super")=> typeArgumentBounds)?
+        (("extends" | "super") => typeArgumentBounds)?
         {#wildcardType.setType(WILDCARD_TYPE);}
     ;
 
 typeArgumentsDiamond
 {Token first = LT(1);}
     :   LT! GT! nls!
-    {#typeArgumentsDiamond = #(create(TYPE_ARGUMENTS, "TYPE_ARGUMENTS",first,LT(1)), #typeArgumentsDiamond);}
+    {#typeArgumentsDiamond = #(create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS",first,LT(1)), #typeArgumentsDiamond);}
     ;
 
 // Type arguments to a class or interface type
@@ -774,7 +753,7 @@ int currentLtLevel = 0;}
         {matchGenericTypeBrackets(((currentLtLevel != 0) || ltCounter == currentLtLevel),
         "Missing closing bracket '>' for generics types", "Please specify the missing bracket!")}?
 
-        {#typeArguments = #(create(TYPE_ARGUMENTS, "TYPE_ARGUMENTS",first,LT(1)), #typeArguments);}
+        {#typeArguments = #(create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS",first,LT(1)), #typeArguments);}
     ;
 
 // this gobbles up *some* amount of '>' characters, and counts how many
@@ -857,7 +836,7 @@ identifier {Token first = LT(1);}
     :   i1:IDENT!
         (   options { greedy = true; } :
             d:DOT! nls! i2:IDENT!
-            {#i1 = #(create(DOT,".",first,LT(1)),i1,i2);}
+            {#i1 = #(create(DOT,".",first,LT(1)), i1, i2);}
         )*
         {#identifier = #i1;}
     ;
@@ -866,12 +845,12 @@ identifierStar {Token first = LT(1);}
     :   i1:IDENT!
         (   options { greedy = true; } :
             d1:DOT! nls! i2:IDENT!
-            {#i1 = #(create(DOT,".",first,LT(1)),i1,i2);}
+            {#i1 = #(create(DOT,".",first,LT(1)), i1, i2);}
         )*
         (   d2:DOT!  nls! s:STAR!
-            {#i1 = #(create(DOT,".",first,LT(1)),i1,s);}
+            {#i1 = #(create(DOT,".",first,LT(1)), i1, s);}
         |   "as"! nls! alias:IDENT!
-            {#i1 = #(create(LITERAL_as,"as",first,LT(1)),i1,alias);}
+            {#i1 = #(create(LITERAL_as,"as",first,LT(1)), i1, alias);}
         )?
         {#identifierStar = #i1;}
     ;
@@ -903,7 +882,7 @@ modifiersInternal
 /** A list of one or more modifier, annotation, or "def". */
 modifiers  {Token first = LT(1);}
     :   modifiersInternal
-        {#modifiers = #(create(MODIFIERS, "MODIFIERS",first,LT(1)), #modifiers);}
+        {#modifiers = #(create(MODIFIERS,"MODIFIERS",first,LT(1)), #modifiers);}
     ;
 
 /** A list of zero or more modifiers, annotations, or "def". */
@@ -913,7 +892,7 @@ modifiersOpt  {Token first = LT(1);}
             options{generateAmbigWarnings=false;}:
             modifiersInternal
         )?
-        {#modifiersOpt = #(create(MODIFIERS, "MODIFIERS",first,LT(1)), #modifiersOpt);}
+        {#modifiersOpt = #(create(MODIFIERS,"MODIFIERS",first,LT(1)), #modifiersOpt);}
     ;
 
 // modifiers for Java classes, interfaces, class/instance vars and methods
@@ -933,7 +912,7 @@ modifier
     ;
 
 annotation!  {Token first = LT(1);}
-    :   AT! i:identifier nls! (options{greedy=true;}: LPAREN! ( args:annotationArguments )? RPAREN! )?
+    :   AT! i:identifier nls! (options{greedy=true;}: LPAREN! (args:annotationArguments)? RPAREN!)?
         {#annotation = #(create(ANNOTATION,"ANNOTATION",first,LT(1)), i, args);}
     ;
 
@@ -943,34 +922,35 @@ annotationsInternal
             {break; /* go out of the ()* loop*/}
             AT "interface"
         |
-            annotation nls!)*
+            annotation nls!
+        )*
     ;
 
 annotationsOpt  {Token first = LT(1);}
     :   (
-               // See comment above on hushing warnings.
-               options{generateAmbigWarnings=false;}:
-               annotationsInternal
+            // See comment above on hushing warnings.
+            options{generateAmbigWarnings=false;}:
+            annotationsInternal
         )?
-        {#annotationsOpt = #(create(ANNOTATIONS, "ANNOTATIONS", first, LT(1)), #annotationsOpt);}
+        {#annotationsOpt = #(create(ANNOTATIONS,"ANNOTATIONS",first,LT(1)), #annotationsOpt);}
     ;
 
 annotationArguments
     :   v:annotationMemberValueInitializer
-            { Token itkn = new Token(IDENT, "value");
-              AST i;
-              #i = #(create(IDENT, "value", itkn, itkn));
-                #annotationArguments = #(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",LT(1),LT(1)), i, v);}
-            | annotationMemberValuePairs
+        {Token itkn = new Token(IDENT,"value"); AST i; #i = #(create(IDENT,"value",itkn,itkn));
+         #annotationArguments = #(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",LT(1),LT(1)), i, v);}
+        | annotationMemberValuePairs
     ;
 
 annotationMemberValuePairs
-    :   annotationMemberValuePair ( COMMA! nls! annotationMemberValuePair )*
+    :   annotationMemberValuePair (
+            COMMA! nls! annotationMemberValuePair
+        )*
     ;
 
 annotationMemberValuePair!  {Token first = LT(1);}
     :   i:annotationIdent ASSIGN! nls! v:annotationMemberValueInitializer
-            {#annotationMemberValuePair = #(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",first,LT(1)), i, v);}
+        {#annotationMemberValuePair = #(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",first,LT(1)), i, v);}
     ;
 
 annotationIdent
@@ -982,40 +962,11 @@ annotationMemberValueInitializer
     :   conditionalExpression[0] | annotation
     ;
 
-/*OBS*
-// This is an initializer used to set up an annotation member array.
-annotationMemberArrayInitializer
-    :   lc:LCURLY^ {#lc.setType(ANNOTATION_ARRAY_INIT);}
-        (   annotationMemberArrayValueInitializer
-            (
-                // CONFLICT: does a COMMA after an initializer start a new
-                // initializer or start the option ',' at end?
-                // ANTLR generates proper code by matching
-                // the comma as soon as possible.
-                options {
-                        warnWhenFollowAmbig = false;
-                }
-            :
-                COMMA! nls! annotationMemberArrayValueInitializer
-            )*
-            (COMMA! nls!)?
-        )?
-        RCURLY!
-    ;
-
-// The two things that can initialize an annotation array element are a conditional expression
-// and an annotation (nested annotation array initialisers are not valid)
-annotationMemberArrayValueInitializer
-    :   conditionalExpression[0]
-    |   annotation nls!
-    ;
-*OBS*/
-
 superClassClause!
     {Token first = LT(1);}
     :
         ( "extends" nls! c:classOrInterfaceType[false] nls! )?
-        {#superClassClause = #(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1)),c);}
+        {#superClassClause = #(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1)), c);}
     ;
 
 // Definition of a Java class
@@ -1035,8 +986,7 @@ if (modifiers != null) {
         ic:implementsClause
         // now parse the body of the class
         cb:classBlock
-        {#classDefinition = #(create(CLASS_DEF,"CLASS_DEF",first,LT(1)),
-                                                            modifiers,IDENT,tp,sc,ic,cb);}
+        {#classDefinition = #(create(CLASS_DEF,"CLASS_DEF",first,LT(1)), modifiers, IDENT, tp, sc, ic, cb);}
         { currentClass = prevCurrentClass; }
     ;
 
@@ -1057,8 +1007,7 @@ if (modifiers != null) {
         ic:implementsClause
         // now parse the body of the class
         cb:classBlock
-        {#traitDefinition = #(create(TRAIT_DEF, "TRAIT_DEF",first,LT(1)),
-                                                            modifiers,IDENT,tp,sc,ic,cb);}
+        {#traitDefinition = #(create(TRAIT_DEF,"TRAIT_DEF",first,LT(1)), modifiers, IDENT, tp, sc, ic, cb);}
         { currentClass = prevCurrentClass; }
     ;
 
@@ -1075,8 +1024,7 @@ interfaceDefinition![AST modifiers]  {Token first = cloneToken(LT(1));
         ie:interfaceExtends
         // now parse the body of the interface (looks like a class...)
         ib:interfaceBlock
-        {#interfaceDefinition = #(create(INTERFACE_DEF,"INTERFACE_DEF",first,LT(1)),
-                                  modifiers,IDENT,tp,ie,ib);}
+        {#interfaceDefinition = #(create(INTERFACE_DEF,"INTERFACE_DEF",first,LT(1)), modifiers, IDENT, tp, ie, ib);}
     ;
 
 enumDefinition![AST modifiers]  {Token first = cloneToken(LT(1)); AST prevCurrentClass = currentClass;
@@ -1092,8 +1040,7 @@ enumDefinition![AST modifiers]  {Token first = cloneToken(LT(1)); AST prevCurren
         nls!
         // now parse the body of the enum
         eb:enumBlock
-        {#enumDefinition = #(create(ENUM_DEF,"ENUM_DEF",first,LT(1)),
-                             modifiers,IDENT,ic,eb);}
+        {#enumDefinition = #(create(ENUM_DEF,"ENUM_DEF",first,LT(1)), modifiers, IDENT, ic, eb);}
         { currentClass = prevCurrentClass; }
     ;
 
@@ -1105,8 +1052,7 @@ annotationDefinition![AST modifiers]  {Token first = cloneToken(LT(1));
     :   AT "interface" IDENT nls!
         // now parse the body of the annotation
         ab:annotationBlock
-        {#annotationDefinition = #(create(ANNOTATION_DEF,"ANNOTATION_DEF",first,LT(1)),
-                                   modifiers,IDENT,ab);}
+        {#annotationDefinition = #(create(ANNOTATION_DEF,"ANNOTATION_DEF",first,LT(1)), modifiers, IDENT, ab);}
     ;
 
 typeParameters
@@ -1123,7 +1069,7 @@ typeParameters
         {matchGenericTypeBrackets(((currentLtLevel != 0) || ltCounter == currentLtLevel),
         "Missing closing bracket '>' for generics types", "Please specify the missing bracket!")}?
 
-        {#typeParameters = #(create(TYPE_PARAMETERS, "TYPE_PARAMETERS",first,LT(1)), #typeParameters);}
+        {#typeParameters = #(create(TYPE_PARAMETERS,"TYPE_PARAMETERS",first,LT(1)), #typeParameters);}
     ;
 
 typeParameter  {Token first = LT(1);}
@@ -1145,7 +1091,7 @@ classBlock  {Token first = LT(1);}
     :   LCURLY!
         ( classField )? ( sep! ( classField )? )*
         RCURLY!
-        {#classBlock = #(create(OBJBLOCK, "OBJBLOCK",first,LT(1)), #classBlock);}
+        {#classBlock = #(create(OBJBLOCK,"OBJBLOCK",first,LT(1)), #classBlock);}
     ;
 
 // This is the body of an interface. You can have interfaceField and extra semicolons.
@@ -1153,7 +1099,7 @@ interfaceBlock  {Token first = LT(1);}
     :   LCURLY!
         ( interfaceField )? ( sep! ( interfaceField )? )*
         RCURLY!
-        {#interfaceBlock = #(create(OBJBLOCK, "OBJBLOCK",first,LT(1)), #interfaceBlock);}
+        {#interfaceBlock = #(create(OBJBLOCK,"OBJBLOCK",first,LT(1)), #interfaceBlock);}
     ;
 
 // This is the body of an annotation. You can have annotation fields and extra semicolons,
@@ -1162,7 +1108,7 @@ annotationBlock  {Token first = LT(1);}
     :   LCURLY!
         ( annotationField )? ( sep! ( annotationField )? )*
         RCURLY!
-        {#annotationBlock = #(create(OBJBLOCK, "OBJBLOCK",first,LT(1)), #annotationBlock);}
+        {#annotationBlock = #(create(OBJBLOCK,"OBJBLOCK",first,LT(1)), #annotationBlock);}
     ;
 
 // This is the body of an enum. You can have zero or more enum constants
@@ -1179,7 +1125,7 @@ enumBlock  {Token first = LT(1);}
         )
         ( sep! (classField)? )*
         RCURLY!
-        {#enumBlock = #(create(OBJBLOCK, "OBJBLOCK",first,LT(1)), #enumBlock);}
+        {#enumBlock = #(create(OBJBLOCK,"OBJBLOCK",first,LT(1)), #enumBlock);}
     ;
 
 /** Guard for enumConstants.  */
@@ -1216,16 +1162,9 @@ annotationField!  {Token first = LT(1);}
                 i:IDENT              // the name of the field
                 LPAREN! RPAREN!
 
-                /*OBS* rt:declaratorBrackets[#t] *OBS*/
-
                 ( "default" nls! amvi:annotationMemberValueInitializer )?
 
-                {#annotationField =
-                        #(create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF",first,LT(1)),
-                                 mods,
-                                 #(create(TYPE,"TYPE",first,LT(1)),t),
-                                 i,amvi
-                                 );}
+                {#annotationField = #(create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF",first,LT(1)), mods, #(create(TYPE,"TYPE",first,LT(1)), t), i, amvi);}
             |   v:variableDefinitions[#mods,#t]    // variable
                 {#annotationField = #v;}
             )
@@ -1242,7 +1181,7 @@ enumConstant!  {Token first = LT(1);}
             RPAREN!
         )?
         ( b:enumConstantBlock )?
-        {#enumConstant = #(create(ENUM_CONSTANT_DEF, "ENUM_CONSTANT_DEF",first,LT(1)), an, i, a, b);}
+        {#enumConstant = #(create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF",first,LT(1)), an, i, a, b);}
     ;
 
 //The class-like body of an enum constant
@@ -1250,7 +1189,7 @@ enumConstantBlock  {Token first = LT(1);}
     :   LCURLY!
         (enumConstantField)? ( sep! (enumConstantField)? )*
         RCURLY!
-        {#enumConstantBlock = #(create(OBJBLOCK, "OBJBLOCK",first,LT(1)), #enumConstantBlock);}
+        {#enumConstantBlock = #(create(OBJBLOCK,"OBJBLOCK",first,LT(1)), #enumConstantBlock);}
     ;
 
 //An enum constant field is just like a class field but without
@@ -1296,7 +1235,7 @@ protected enumConstantFieldInternal![AST mods, AST tp, AST t, Token first]
         {
             #enumConstantFieldInternal = #(create(METHOD_DEF,"METHOD_DEF",first,LT(1)),
                     mods,
-                    #(create(TYPE,"TYPE",first,LT(1)),t),
+                    #(create(TYPE,"TYPE",first,LT(1)), t),
                     IDENT,
                     param,
                     tc,
@@ -1318,8 +1257,7 @@ interfaceExtends  {Token first = LT(1);}
             e:"extends"! nls!
             classOrInterfaceType[true] ( COMMA! nls! classOrInterfaceType[true] )* nls!
         )?
-        {#interfaceExtends = #(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1)),
-                               #interfaceExtends);}
+        {#interfaceExtends = #(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1)), #interfaceExtends);}
     ;
 
 // A class can implement several interfaces...
@@ -1328,8 +1266,7 @@ implementsClause  {Token first = LT(1);}
             i:"implements"! nls!
             classOrInterfaceType[true] ( COMMA! nls! classOrInterfaceType[true] )* nls!
         )?
-        {#implementsClause = #(create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE",first,LT(1)),
-                               #implementsClause);}
+        {#implementsClause = #(create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE",first,LT(1)), #implementsClause);}
     ;
 
 // Now the various things that can be defined inside a class
@@ -1393,13 +1330,14 @@ constructorBody  {Token first = LT(1);}
              |   bb2:blockBody[EOF]!
          )
          RCURLY!
-         {if (#eci != null)
-              #constructorBody = #(create(SLIST,"{",first,LT(1)),eci,bb1);
+         {LT(0).setColumn(LT(0).getColumn() + 1);
+          if (#eci != null)
+              #constructorBody = #(create(SLIST,"{",first,LT(0)), eci, bb1);
           else
-              #constructorBody = #(create(SLIST,"{",first,LT(1)),bb2);}
+              #constructorBody = #(create(SLIST,"{",first,LT(0)), bb2);
+         }
      ;
 
-
 /** Catch obvious constructor calls, but not the expr.super(...) calls */
 explicitConstructorInvocation
     :   (typeArguments)?
@@ -1447,7 +1385,7 @@ multipleAssignmentDeclaration {Token first = cloneToken(LT(1));}
           (LPAREN nls IDENT (COMMA nls IDENT)* RPAREN ASSIGN) => multipleAssignment[0]
           | assignmentExpression[0]
         )
-        {#multipleAssignmentDeclaration=#(create(VARIABLE_DEF,"VARIABLE_DEF",first,LT(1)), #mods, #(create(TYPE,"TYPE",first,LT(1)),#t), #multipleAssignmentDeclaration);}
+        {#multipleAssignmentDeclaration=#(create(VARIABLE_DEF,"VARIABLE_DEF",first,LT(1)), #mods, #(create(TYPE,"TYPE",first,LT(1)), #t), #multipleAssignmentDeclaration);}
     ;
 
 /** The tail of a declaration.
@@ -1478,11 +1416,9 @@ variableDefinitions[AST mods, AST t] {Token first = cloneToken(LT(1));
         // parse the formal parameter declarations.
         LPAREN! param:parameterDeclarationList! RPAREN!
 
-        /*OBS*rt:declaratorBrackets[#t]*/
-
         // get the list of exceptions that this method is
         // declared to throw
-        ((nls "throws") =>  tc:throwsClause!  )?
+        ((nls "throws") => tc:throwsClause!)?
 
         // the method body is an open block
         // but, it may have an optional constructor call (for constructors only)
@@ -1490,12 +1426,11 @@ variableDefinitions[AST mods, AST t] {Token first = cloneToken(LT(1));
         // which look like method declarations
         // since the block is optional and nls is part of sep we have to be sure
         // a newline is followed by a block or ignore the nls too
-        ((nls! LCURLY) =>  (nlsWarn! mb:openBlock!))?
+        ((nls! LCURLY) => (nlsWarn! mb:openBlock!))?
 
-        {   if (#qid != null)  #id = #qid;
-            #variableDefinitions =
-                    #(create(METHOD_DEF,"METHOD_DEF",first,LT(1)),
-                      mods, #(create(TYPE,"TYPE",first,LT(1)),t), id, param, tc, mb);
+        {
+         if (#qid != null) #id = #qid;
+         #variableDefinitions = #(create(METHOD_DEF,"METHOD_DEF",first,LT(1)), mods, #(create(TYPE,"TYPE",first,LT(1)), t), id, param, tc, mb);
         }
     ;
 
@@ -1510,23 +1445,15 @@ constructorDefinition[AST mods]  {Token first = cloneToken(LT(1));
     :
         id:IDENT
 
-        // parse the formal parameter declarations.
+        // parse the formal parameter declarations
         LPAREN! param:parameterDeclarationList! RPAREN!
 
-        /*OBS*rt:declaratorBrackets[#t]*/
-
         // get the list of exceptions that this method is
         // declared to throw
-        ((nls "throws") => tc:throwsClause!  )? nlsWarn!
-        // the method body is an open block
-        // but, it may have an optional constructor call (for constructors only)
-
-        // TODO assert that the id matches the class
-        { isConstructorIdent(id); }
+        ((nls "throws") => tc:throwsClause!)? nlsWarn!
 
         cb:constructorBody!
-        {   #constructorDefinition =  #(create(CTOR_IDENT,"CTOR_IDENT",first,LT(1)),  mods, param, tc, cb);
-        }
+        {#constructorDefinition = #(create(CTOR_IDENT,"CTOR_IDENT",first,LT(0)), mods, param, tc, cb);}
      ;
 
 /** Declaration of a variable. This can be a class/instance variable,
@@ -1536,9 +1463,8 @@ constructorDefinition[AST mods]  {Token first = cloneToken(LT(1));
 variableDeclarator![AST mods, AST t,Token first]
     :
         id:variableName
-        /*OBS*d:declaratorBrackets[t]*/
         (v:varInitializer)?
-        {#variableDeclarator = #(create(VARIABLE_DEF,"VARIABLE_DEF",first,LT(1)), mods, #(create(TYPE,"TYPE",first,LT(1)),t), id, v);}
+        {#variableDeclarator = #(create(VARIABLE_DEF,"VARIABLE_DEF",first,LT(1)), mods, #(create(TYPE,"TYPE",first,LT(1)), t), id, v);}
     ;
 
 /** Used in cases where a declaration cannot have commas, or ends with the "in" operator instead of '='. */
@@ -1562,8 +1488,7 @@ declaratorBrackets[AST typ]
             options {greedy=true;} :
             LBRACK!
             RBRACK!
-            {#declaratorBrackets = #(create(ARRAY_DECLARATOR,"[",typ,LT(1)),
-                               #declaratorBrackets);}
+            {#declaratorBrackets = #(create(ARRAY_DECLARATOR,"[",typ,LT(1)), #declaratorBrackets);}
         )*
     ;
 
@@ -1573,37 +1498,6 @@ varInitializer
         // In {T x = y}, the left-context of y is that of an initializer.
     ;
 
-/*OBS*
-// This is an initializer used to set up an array.
-arrayInitializer
-    :   lc:LCURLY^ {#lc.setType(ARRAY_INIT);}
-        (   initializer
-            (
-                // CONFLICT: does a COMMA after an initializer start a new
-                // initializer or start the option ',' at end?
-                // ANTLR generates proper code by matching
-                // the comma as soon as possible.
-                options {
-                        warnWhenFollowAmbig = false;
-                }
-            :
-                COMMA! initializer
-            )*
-            (COMMA!)?
-        )?
-        RCURLY!
-    ;
-*OBS*/
-
-/*OBS*  // Use [...] for initializing all sorts of sequences, including arrays.
-// The two "things" that can initialize an array element are an expression
-// and another (nested) array initializer.
-initializer
-    :   expression
-    |   arrayInitializer
-    ;
-*OBS*/
-
 // This is a list of exception classes that the method is declared to throw
 throwsClause
     :   nls! "throws"^ nls! identifier ( COMMA! nls! identifier )*
@@ -1624,8 +1518,7 @@ parameterDeclarationList  {Token first = LT(1);}
                 parameterDeclaration
             )*
         )?
-        {#parameterDeclarationList = #(create(PARAMETERS,"PARAMETERS",first,LT(1)),
-                                       #parameterDeclarationList);}
+        {#parameterDeclarationList = #(create(PARAMETERS,"PARAMETERS",first,LT(1)), #parameterDeclarationList);}
     ;
 
 /** A formal parameter for a method or closure. */
@@ -1647,14 +1540,11 @@ parameterDeclaration!
         // allow an optional default value expression
         (exp:varInitializer)?
 
-        /*OBS*pd:declaratorBrackets[#t]*/
         {
             if (spreadParam) {
-                #parameterDeclaration = #(create(VARIABLE_PARAMETER_DEF,"VARIABLE_PARAMETER_DEF",first,LT(1)),
-                      pm, #(create(TYPE,"TYPE",first,LT(1)),t), id, exp);
+                #parameterDeclaration = #(create(VARIABLE_PARAMETER_DEF,"VARIABLE_PARAMETER_DEF",first,LT(1)), pm, #(create(TYPE,"TYPE",first,LT(1)), t), id, exp);
             } else {
-                #parameterDeclaration = #(create(PARAMETER_DEF,"PARAMETER_DEF",first,LT(1)),
-                      pm, #(create(TYPE,"TYPE",first,LT(1)),t), id, exp);
+                #parameterDeclaration = #(create(PARAMETER_DEF,"PARAMETER_DEF",first,LT(1)), pm, #(create(TYPE,"TYPE",first,LT(1)), t), id, exp);
             }
         }
     ;
@@ -1668,27 +1558,17 @@ multicatch_types
             BOR! nls! classOrInterfaceType[false]
         )*
 
-        {#multicatch_types = #(create(MULTICATCH_TYPES, "MULTICATCH_TYPES",first,LT(1)), #multicatch_types);}
+        {#multicatch_types = #(create(MULTICATCH_TYPES,"MULTICATCH_TYPES",first,LT(1)), #multicatch_types);}
     ;
 
 multicatch
 {Token first = LT(1);}
     :   nls! (FINAL)? ("def")? (m:multicatch_types)? id:IDENT!
         {
-          #multicatch = #(create(MULTICATCH,"MULTICATCH",first, LT(1)),m,id);
+          #multicatch = #(create(MULTICATCH,"MULTICATCH",first,LT(1)), m, id);
         }
     ;
 
-/*OBS*
-variableLengthParameterDeclaration!  {Token first = LT(1);}
-    :   pm:parameterModifier t:typeSpec[false] TRIPLE_DOT! id:IDENT
-
-        pd:declaratorBrackets[#t]
-        {#variableLengthParameterDeclaration = #(create(VARIABLE_PARAMETER_DEF,"VARIABLE_PARAMETER_DEF",first,LT(1)),
-                                                                                            pm, #(create(TYPE,"TYPE",first,LT(1)),t), id);}
-    ;
-*OBS*/
-
 parameterModifiersOpt
         { Token first = LT(1);int seenDef = 0; }
         //final and/or def can appear amongst annotations in any order
@@ -1724,9 +1604,7 @@ closableBlockParamsStart!
 /** Simple names, as in {x|...}, are completely equivalent to {(def x)|...}.  Build the right AST. */
 closableBlockParam!  {Token first = LT(1);}
     :   id:IDENT!
-        {#closableBlockParam = #(create(PARAMETER_DEF,"PARAMETER_DEF",first,LT(1)),
-                               #(create(MODIFIERS,"MODIFIERS",first,LT(1))), #(create(TYPE,"TYPE",first,LT(1))),
-                               id);}
+        {#closableBlockParam = #(create(PARAMETER_DEF,"PARAMETER_DEF",first,LT(1)), #(create(MODIFIERS,"MODIFIERS",first,LT(1))), #(create(TYPE,"TYPE",first,LT(1))), id);}
     ;
 
 // Compound statement. This is used in many contexts:
@@ -1749,7 +1627,7 @@ openBlock  {Token first = LT(1);}
         // AST type of SLIST means "never gonna be a closure"
         bb:blockBody[EOF]!
         RCURLY!
-        {#openBlock = #(create(SLIST,"{",first,LT(1)),bb);}
+        {#openBlock = #(create(SLIST,"{",first,LT(1)), bb);}
 
     ;
 
@@ -1768,7 +1646,7 @@ closableBlock  {Token first = LT(1);}
         cbp:closableBlockParamsOpt[true]!
         bb:blockBody[EOF]!
         RCURLY!
-        {#closableBlock = #(create(CLOSABLE_BLOCK,"{",first,LT(1)),cbp,bb);}
+        {#closableBlock = #(create(CLOSABLE_BLOCK,"{",first,LT(1)), cbp, bb);}
     ;
 
 /** A block known to be a closure, but which omits its arguments, is given this placeholder.
@@ -1790,8 +1668,10 @@ openOrClosableBlock  {Token first = LT(1);}
         bb:blockBody[EOF]!
         RCURLY!
         {
-            if (#cp == null)    #openOrClosableBlock = #(create(SLIST,"{",first,LT(1)),bb);
-            else                #openOrClosableBlock = #(create(CLOSABLE_BLOCK,"{",first,LT(1)),cp,bb);
+            if (#cp == null)
+                #openOrClosableBlock = #(create(SLIST,"{",first,LT(1)), bb);
+            else
+                #openOrClosableBlock = #(create(CLOSABLE_BLOCK,"{",first,LT(1)), cp, bb);
         }
     ;
 
@@ -1800,7 +1680,7 @@ openOrClosableBlock  {Token first = LT(1);}
  *  and expressions.
  */
 statement[int prevToken]
-{boolean sce=false; Token first = LT(1); AST casesGroup_AST = null;}
+{boolean sce = false; Token first = LT(1); AST casesGroup_AST = null;}
     // prevToken is NLS if previous statement is separated only by a newline
 
     :  (genericMethodStart)=>
@@ -1831,7 +1711,7 @@ statement[int prevToken]
     // side-effects.
     // The prevToken is used to check for dumb expressions like +1.
     |    es:expressionStatement[prevToken]
-        //{#statement = #(create(EXPR,"EXPR",first,LT(1)),es);}
+        //{#statement = #(create(EXPR,"EXPR",first,LT(1)), es);}
 
     // If-else statement
     |   "if"! LPAREN! ale:assignmentLessExpression! RPAREN! nlsWarn! ifCbs:compatibleBodyStatement!
@@ -1847,7 +1727,7 @@ statement[int prevToken]
             (sep!)?  // allow SEMI here for compatibility with Java
             "else"! nlsWarn! elseCbs:compatibleBodyStatement!
         )?
-        {#statement = #(create(LITERAL_if,"if",first,LT(1)),ale,ifCbs,elseCbs);}
+        {#statement = #(create(LITERAL_if,"if",first,LT(1)), ale, ifCbs, elseCbs);}
 
     // For statement
     |   forStatement
@@ -1857,16 +1737,11 @@ statement[int prevToken]
         (s:SEMI! | while_cbs:compatibleBodyStatement!)
         {
             if (#s != null)
-                #statement = #(create(LITERAL_while,"Literal_while",first,LT(1)),while_sce,s);
+                #statement = #(create(LITERAL_while,"Literal_while",first,LT(1)), while_sce, s);
             else
-                #statement = #(create(LITERAL_while,"Literal_while",first,LT(1)),while_sce,while_cbs);
+                #statement = #(create(LITERAL_while,"Literal_while",first,LT(1)), while_sce, while_cbs);
         }
 
-    /*OBS* no do-while statement in Groovy (too ambiguous)
-    // do-while statement
-    |   "do"^ statement "while"! LPAREN! strictContextExpression RPAREN! SEMI!
-    *OBS*/
-
     // Import statement.  Can be used in any scope.  Has "import x as y" also.
     |   (annotationsOpt "import") => importStatement
 
@@ -1877,7 +1752,7 @@ statement[int prevToken]
     |   "switch"! LPAREN! sce=switchSce:strictContextExpression[false]! RPAREN! nlsWarn! LCURLY! nls!
         ( cg:casesGroup!
           //expand the list of nodes for each catch statement
-              {casesGroup_AST = #(null,casesGroup_AST,cg);})*
+              {casesGroup_AST = #(null, casesGroup_AST, cg);})*
         RCURLY!
         {#statement = #(create(LITERAL_switch,"switch",first,LT(1)),switchSce,casesGroup_AST);}
 
@@ -1886,12 +1761,7 @@ statement[int prevToken]
 
     // synchronize a statement
     |   "synchronized"! LPAREN! sce=synch_sce:strictContextExpression[false]! RPAREN! nlsWarn! synch_cs:compoundStatement!
-        {#statement = #(create(LITERAL_synchronized,"synchronized",first,LT(1)),synch_sce,synch_cs);}
-
-    /*OBS*
-    // empty statement
-    |   s:SEMI {#s.setType(EMPTY_STAT);}
-    *OBS*/
+        {#statement = #(create(LITERAL_synchronized,"synchronized",first,LT(1)), synch_sce, synch_cs);}
 
     |   branchStatement
     ;
@@ -1899,12 +1769,7 @@ statement[int prevToken]
 forStatement {Token first = LT(1);}
     :   "for"!
         LPAREN!
-        (   (SEMI |(strictContextExpression[true] SEMI))=>cl:closureList!
-            // *OBS*
-            // There's no need at all for squeezing in the new Java 5 "for"
-            // syntax, since Groovy's is a suitable alternative.
-            // |   (parameterDeclaration COLON)=> forEachClause
-            // *OBS*
+        (   (SEMI | (strictContextExpression[true] SEMI)) => cl:closureList!
         |   // the coast is clear; it's a modern Groovy for statement
             fic:forInClause!
         )
@@ -1913,14 +1778,14 @@ forStatement {Token first = LT(1);}
         {
             if (#cl != null) {
                 if (#s != null)
-                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)),cl,s);
+                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)), cl, s);
                 else
-                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)),cl,forCbs);
+                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)), cl, forCbs);
             } else {
                 if (#s != null)
-                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)),fic,s);
+                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)), fic, s);
                 else
-                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)),fic,forCbs);
+                    #forStatement = #(create(LITERAL_for,"for",first,LT(1)), fic, forCbs);
             }
         }
 
@@ -1937,17 +1802,9 @@ closureList
                 SEMI! sce=strictContextExpression[true]
            |    SEMI! {astFactory.addASTChild(currentAST,astFactory.create(EMPTY_STAT, "EMPTY_STAT"));}
         )+
-        {#closureList = #(create(CLOSURE_LIST,"CLOSURE_LIST",first,LT(1)),#closureList);}
+        {#closureList = #(create(CLOSURE_LIST,"CLOSURE_LIST",first,LT(1)), #closureList);}
     ;
 
-/*OBS*
-forEachClause  {Token first = LT(1);}
-    :
-        p:parameterDeclaration COLON! expression
-        {#forEachClause = #(create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE",first,LT(1)), #forEachClause);}
-    ;
-*OBS*/
-
 forInClause
     :   (   (declarationStart)=>
             decl:singleDeclarationNoInit
@@ -1981,7 +1838,7 @@ compatibleBodyStatement {Token first = LT(1);}
     // comma sep decl case converted to multiple statements so must be wrapped in SLIST when single statement occurs after if/while/for
     |  (declarationStart (varInitializer)? COMMA)=>
         de:declaration
-        {#compatibleBodyStatement = #(create(SLIST,"CBSLIST",first,LT(1)),de);}
+        {#compatibleBodyStatement = #(create(SLIST,"CBSLIST",first,LT(1)), de);}
     |
         statement[EOF]
     ;
@@ -1995,22 +1852,22 @@ branchStatement {Token first = LT(1);}
     // Return an expression
         "return"!
         ( returnE:expression[0]! )?
-        {#branchStatement = #(create(LITERAL_return,"return",first,LT(1)),returnE);}
+        {#branchStatement = #(create(LITERAL_return,"return",first,LT(1)), returnE);}
 
 
     // break:  get out of a loop, or switch, or method call
     // continue:  do next iteration of a loop, or leave a closure
     |   "break"!
         ( breakI:IDENT! )?
-        {#branchStatement = #(create(LITERAL_break,"break",first,LT(1)),breakI);}
+        {#branchStatement = #(create(LITERAL_break,"break",first,LT(1)), breakI);}
 
     | "continue"!
         ( contI:IDENT! )?
-        {#branchStatement = #(create(LITERAL_continue,"continue",first,LT(1)),contI);}
+        {#branchStatement = #(create(LITERAL_continue,"continue",first,LT(1)), contI);}
 
     // throw an exception
     |   "throw"! throwE:expression[0]!
-        {#branchStatement = #(create(LITERAL_throw,"throw",first,LT(1)),throwE);}
+        {#branchStatement = #(create(LITERAL_throw,"throw",first,LT(1)), throwE);}
 
 
     // groovy assertion...
@@ -2021,7 +1878,7 @@ branchStatement {Token first = LT(1);}
             )
             assertE:expression[0]!
         )?
-        {#branchStatement = #(create(LITERAL_assert,"assert",first,LT(1)),assertAle,assertE);}
+        {#branchStatement = #(create(LITERAL_assert,"assert",first,LT(1)), assertAle, assertE);}
     ;
 
 /** A labeled statement, consisting of a vanilla identifier followed by a colon. */
@@ -2046,7 +1903,7 @@ expressionStatement[int prevToken]
             checkSuspiciousExpressionStatement[prevToken]
         )?
         esn:expressionStatementNoCheck
-        { #expressionStatement = #(create(EXPR, "EXPR", first, LT(1)), #esn); }
+        { #expressionStatement = #(create(EXPR,"EXPR",first,LT(1)), #esn); }
     ;
 
 expressionStatementNoCheck
@@ -2057,7 +1914,7 @@ expressionStatementNoCheck
         { isPathExpr = (#head == lastPathExpression); }
         (
             // A path expression (e.g., System.out.print) can take arguments.
-            {LA(1)!=LITERAL_else && isPathExpr /*&& #head.getType()==METHOD_CALL*/}?
+            {LA(1)!=LITERAL_else && isPathExpr}?
             cmd:commandArgumentsGreedy[#head]!
             {
                 #expressionStatementNoCheck = #cmd;
@@ -2143,7 +2000,7 @@ casesGroup  {Token first = LT(1);}
             aCase
         )+
         caseSList
-        {#casesGroup = #(create(CASE_GROUP, "CASE_GROUP",first,LT(1)), #casesGroup);}
+        {#casesGroup = #(create(CASE_GROUP,"CASE_GROUP",first,LT(1)), #casesGroup);}
     ;
 
 aCase
@@ -2152,7 +2009,7 @@ aCase
 
 caseSList  {Token first = LT(1);}
     :   statement[COLON] (sep! (statement[sepToken])?)*
-        {#caseSList = #(create(SLIST,"SLIST",first,LT(1)),#caseSList);}
+        {#caseSList = #(create(SLIST,"SLIST",first,LT(1)), #caseSList);}
     ;
 
 // The initializer for a for loop
@@ -2161,17 +2018,17 @@ forInit  {Token first = LT(1);}
         (declarationStart)=> declaration
     |   // else it's a comma-separated list of expressions
         (controlExpressionList)?
-        {#forInit = #(create(FOR_INIT,"FOR_INIT",first,LT(1)),#forInit);}
+        {#forInit = #(create(FOR_INIT,"FOR_INIT",first,LT(1)), #forInit);}
     ;
 
 forCond  {Token first = LT(1); boolean sce=false;}
     :   (sce=strictContextExpression[false])?
-        {#forCond = #(create(FOR_CONDITION,"FOR_CONDITION",first,LT(1)),#forCond);}
+        {#forCond = #(create(FOR_CONDITION,"FOR_CONDITION",first,LT(1)), #forCond);}
     ;
 
 forIter  {Token first = LT(1);}
     :   (controlExpressionList)?
-        {#forIter = #(create(FOR_ITERATOR,"FOR_ITERATOR",first,LT(1)),#forIter);}
+        {#forIter = #(create(FOR_ITERATOR,"FOR_ITERATOR",first,LT(1)), #forIter);}
     ;
 
 // an exception handler try/catch block
@@ -2183,18 +2040,18 @@ tryBlock {Token first = LT(1);List catchNodes = new ArrayList();AST newHandler_A
               {newHandler_AST = #(null,newHandler_AST,h);}   )*
             ( options {greedy=true;} :  nls! fc:finallyClause!)?
 
-        {#tryBlock = #(create(LITERAL_try,"try",first,LT(1)),tryCs,newHandler_AST,fc);}
+        {#tryBlock = #(create(LITERAL_try,"try",first,LT(1)), tryCs, newHandler_AST, fc);}
     ;
 
 finallyClause {Token first = LT(1);}
     :   "finally"! nlsWarn! finallyCs:compoundStatement!
-        {#finallyClause = #(create(LITERAL_finally,"finally",first,LT(1)),finallyCs);}
+        {#finallyClause = #(create(LITERAL_finally,"finally",first,LT(1)), finallyCs);}
     ;
 
 // an exception handler
 handler {Token first = LT(1);}
     :   "catch"! LPAREN! pd:multicatch! RPAREN! nlsWarn! handlerCs:compoundStatement!
-        {#handler = #(create(LITERAL_catch,"catch",first,LT(1)),pd,handlerCs);}
+        {#handler = #(create(LITERAL_catch,"catch",first,LT(1)), pd, handlerCs);}
     ;
 
 /** A member name (x.y) or element name (x[y]) can serve as a command name,
@@ -2224,31 +2081,30 @@ commandArguments[AST head]
     ;
 
 commandArgumentsGreedy[AST head]
-{ 
+{
     AST prev = #head;
 }
     :
-       
         // argument to the already existing method name
-        (   ({#prev==null || #prev.getType()!=METHOD_CALL}? commandArgument)=> (   
+        (
+            ({#prev==null || #prev.getType()!=METHOD_CALL}? commandArgument) => (
                 first : commandArguments[head]!
                 { #prev = #first; }
             )
             |
         )
-        
         // we start a series of methods and arguments
         (   options { greedy = true; } :
             (   options { greedy = true; } :
                 // method name
                 pre:primaryExpression!
                 { #prev = #(create(DOT, ".", #prev), #prev, #pre); }
-                // what follows is either a normal argument, parens, 
+                // what follows is either a normal argument, parens,
                 // an appended block, an index operation, or nothing
-                // parens (a b already processed): 
+                // parens (a b already processed):
                 //      a b c() d e -> a(b).c().d(e)
                 //      a b c()() d e -> a(b).c().call().d(e)
-                // index (a b already processed): 
+                // index (a b already processed):
                 //      a b c[x] d e -> a(b).c[x].d(e)
                 //      a b c[x][y] d e -> a(b).c[x][y].d(e)
                 // block (a b already processed):
@@ -2256,22 +2112,23 @@ commandArgumentsGreedy[AST head]
                 //
                 // parens/block completes method call
                 // index makes method call to property get with index
-                // 
+                //
                 (options {greedy=true;}:
-                (pathElementStart)=>   
-                    (   
+                (pathElementStart) =>
+                    (
                         pc:pathChain[LC_STMT,#prev]!
                         { #prev = #pc; }
-                    )      
+                    )
                 |
                     (   ca:commandArguments[#prev]!
-                        { #prev = #ca; })
+                        { #prev = #ca; }
+                    )
                 )?
             )*
         )
-        { #commandArgumentsGreedy = prev; } 
+        { #commandArgumentsGreedy = prev; }
     ;
-    
+
 commandArgument
     :
         (argumentLabel COLON nls!) => (
@@ -2343,7 +2200,6 @@ multipleAssignment[int lc_stmt] {Token first = cloneToken(LT(1));}
         )
     ;
 
-
 // This is a list of expressions.
 // Used for backward compatibility, in a few places where
 // comma-separated lists of Java expression statements and declarations are required.
@@ -2443,7 +2299,7 @@ pathElement[AST prefix] {Token operator = LT(1);}
         ) nls!
         (ta:typeArguments!)?
         np:namePart!
-        { #pathElement = #(create(operator.getType(),operator.getText(),prefix,LT(1)),prefix,ta,np); }
+        { #pathElement = #(create(operator.getType(),operator.getText(),prefix,LT(1)), prefix, ta, np); }
 
     |
         mca:methodCallArgs[prefix]!
@@ -2588,10 +2444,10 @@ methodCallArgs[AST callee]
         RPAREN!
         { if (callee != null && callee.getFirstChild() != null) {
               //method call like obj.method()
-              #methodCallArgs = #(create(METHOD_CALL, "(",callee.getFirstChild(),LT(1)), callee, al);
+              #methodCallArgs = #(create(METHOD_CALL,"(",callee.getFirstChild(),LT(1)), callee, al);
           } else {
               //method call like method() or new Expr(), in the latter case "callee" is null
-              #methodCallArgs = #(create(METHOD_CALL, "(",callee, LT(1)), callee, al);
+              #methodCallArgs = #(create(METHOD_CALL,"(",callee, LT(1)), callee, al);
           }
         }
     ;
@@ -2655,7 +2511,6 @@ assignmentExpression[int lc_stmt]
             |   BXOR_ASSIGN^
             |   BOR_ASSIGN^
             |   STAR_STAR_ASSIGN^
-            //|   USEROP_13^  //DECIDE: This is how user-define ops would show up.
             )
             nls!
             expressionStatementNoCheck
@@ -2673,13 +2528,11 @@ conditionalExpression[int lc_stmt]
         )?
     ;
 
-
 // logical or (||)  (level 13)
 logicalOrExpression[int lc_stmt]
     :   logicalAndExpression[lc_stmt] (LOR^ nls! logicalAndExpression[0])*
     ;
 
-
 // logical and (&&)  (level 12)
 logicalAndExpression[int lc_stmt]
     :   inclusiveOrExpression[lc_stmt] (LAND^ nls! inclusiveOrExpression[0])*
@@ -2690,13 +2543,11 @@ inclusiveOrExpression[int lc_stmt]
     :   exclusiveOrExpression[lc_stmt] (BOR^ nls! exclusiveOrExpression[0])*
     ;
 
-
 // exclusive or (^)  (level 10)
 exclusiveOrExpression[int lc_stmt]
     :   andExpression[lc_stmt] (BXOR^ nls! andExpression[0])*
     ;
 
-
 // bitwise or non-short-circuiting and (&)  (level 9)
 andExpression[int lc_stmt]
     :   regexExpression[lc_stmt] (BAND^ nls! regexExpression[0])*
@@ -2733,8 +2584,6 @@ relationalExpression[int lc_stmt]
         )?
     ;
 
-
-
 // bit shift expressions (level 6)
 shiftExpression[int lc_stmt]
     :   additiveExpression[lc_stmt]
@@ -2748,7 +2597,6 @@ shiftExpression[int lc_stmt]
         )*
     ;
 
-
 // binary addition/subtraction (level 5)
 additiveExpression[int lc_stmt]
     :   multiplicativeExpression[lc_stmt]
@@ -2760,7 +2608,6 @@ additiveExpression[int lc_stmt]
         )*
     ;
 
-
 // multiplication/division/modulo (level 4)
 multiplicativeExpression[int lc_stmt]
     :    ( INC^ nls!  powerExpressionNotPlusMinus[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
@@ -2835,8 +2682,6 @@ postfixExpression[int lc_stmt]
         )?
     ;
 
-// TODO:  Move pathExpression to this point in the file.
-
 // the basic element of an expression
 primaryExpression {Token first = LT(1);}
     :   IDENT
@@ -2882,7 +2727,7 @@ parenthesizedExpression
         RPAREN!
         {
             if (hasClosureList) {
-                #parenthesizedExpression = #(create(CLOSURE_LIST,"CLOSURE_LIST",first,LT(1)),#parenthesizedExpression);
+                #parenthesizedExpression = #(create(CLOSURE_LIST,"CLOSURE_LIST",first,LT(1)), #parenthesizedExpression);
             }
         }
     ;
@@ -2894,14 +2739,14 @@ strictContextExpression[boolean allowDeclaration]
 returns [boolean hasDeclaration=false]
 {Token first = LT(1);}
     :
-        (   ({allowDeclaration}? declarationStart)=>
+        (   ({allowDeclaration}? declarationStart) =>
             {hasDeclaration=true;} singleDeclaration  // used for both binding and value, as: while (String xx = nextln()) { println xx }
         |   expression[0]
         |   branchStatement // useful to embed inside expressions (cf. C++ throw)
         |   annotation      // creates an annotation value
         )
         // For the sake of the AST walker, mark nodes like this very clearly.
-        {#strictContextExpression = #(create(EXPR,"EXPR",first,LT(1)),#strictContextExpression);}
+        {#strictContextExpression = #(create(EXPR,"EXPR",first,LT(1)), #strictContextExpression);}
     ;
 
 assignmentLessExpression  {Token first = LT(1);}
@@ -2909,10 +2754,9 @@ assignmentLessExpression  {Token first = LT(1);}
         (   conditionalExpression[0]
         )
         // For the sake of the AST walker, mark nodes like this very clearly.
-        {#assignmentLessExpression = #(create(EXPR,"EXPR",first,LT(1)),#assignmentLessExpression);}
+        {#assignmentLessExpression = #(create(EXPR,"EXPR",first,LT(1)), #assignmentLessExpression);}
     ;
 
-
 closableBlockConstructorExpression
     :   closableBlock
     ;
@@ -2931,8 +2775,7 @@ stringConstructorExpression  {Token first = LT(1);}
 
         ce:STRING_CTOR_END
         { #ce.setType(STRING_LITERAL);
-          #stringConstructorExpression =
-            #(create(STRING_CONSTRUCTOR,"STRING_CONSTRUCTOR",first,LT(1)), stringConstructorExpression);
+          #stringConstructorExpression = #(create(STRING_CONSTRUCTOR,"STRING_CONSTRUCTOR",first,LT(1)), stringConstructorExpression);
         }
     ;
 
@@ -2970,65 +2813,13 @@ listOrMapConstructorExpression
         args:argList                 { hasLabels |= argListHasLabels;  }  // any argument label implies a map
         RBRACK!
         {   int type = hasLabels ? MAP_CONSTRUCTOR : LIST_CONSTRUCTOR;
-            #listOrMapConstructorExpression = #(create(type,"[",lcon,LT(1)),args);
+            #listOrMapConstructorExpression = #(create(type,"[",lcon,LT(1)), args);
         }
     |
         /* Special case:  [:] is an empty map constructor. */
         emcon:LBRACK^ COLON! RBRACK!   {#emcon.setType(MAP_CONSTRUCTOR);}
     ;
 
-
-/*OBS*
-/** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class,
- *  and a.b.c.class refs. Also this(...) and super(...). Match
- *  this or super.
- */
-/*OBS*
-identPrimary
-    :   (ta1:typeArguments!)?
-        IDENT
-        // Syntax for method invocation with type arguments is
-        // <String>foo("blah")
-        (
-            options {
-                // .ident could match here or in postfixExpression.
-                // We do want to match here. Turn off warning.
-                greedy=true;
-                // This turns the ambiguity warning of the second alternative
-                // off. See below. (The "ANTLR_LOOP_EXIT" predicate makes it non-issue)
-                warnWhenFollowAmbig=false;
-            }
-            // we have a new nondeterminism because of
-            // typeArguments... only a syntactic predicate will help...
-            // The problem is that this loop here conflicts with
-            // DOT typeArguments "super" in postfixExpression (k=2)
-            // A proper solution would require a lot of refactoring...
-        :   (DOT (typeArguments)? IDENT) =>
-            DOT^ (ta2:typeArguments!)? IDENT
-        |   {ANTLR_LOOP_EXIT}?  //(see documentation above)
-        )*
-        (
-            options {
-                // ARRAY_DECLARATOR here conflicts with INDEX_OP in
-                // postfixExpression on LBRACK RBRACK.
-                // We want to match [] here, so greedy. This overcomes
-                // limitation of linear approximate lookahead.
-                greedy=true;
-            }
-        :   (   lp:LPAREN^ {#lp.setType(METHOD_CALL);}
-                // if the input is valid, only the last IDENT may
-                // have preceding typeArguments... rather hacky, this is...
-                {if (#ta2 != null) astFactory.addASTChild(currentAST, #ta2);}
-                {if (#ta2 == null) astFactory.addASTChild(currentAST, #ta1);}
-                argList RPAREN!
-            )
-        |   (    options {greedy=true;} :
-                lbc:LBRACK^ {#lbc.setType(ARRAY_DECLARATOR);} RBRACK!
-            )+
-        )?
-    ;
-*OBS*/
-
 /** object instantiation.
  *  Trees are built as illustrated by the following input/tree pairs:
  *
@@ -3089,7 +2880,7 @@ newExpression {Token first = LT(1);}
             )?
 
             {#mca = #mca.getFirstChild();
-            #newExpression = #(create(LITERAL_new,"new",first,LT(1)),#ta,#t,#mca,#cb);}
+            #newExpression = #(create(LITERAL_new,"new",first,LT(1)), #ta, #t, #mca, #cb);}
 
             //java 1.1
             // Note: This will allow bad constructs like
@@ -3101,8 +2892,7 @@ newExpression {Token first = LT(1);}
         |   ad:newArrayDeclarator! //(arrayInitializer)?
             // Groovy does not support Java syntax for initialized new arrays.
             // Use sequence constructors instead.
-            {#newExpression = #(create(LITERAL_new,"new",first,LT(1)),#ta,#t,#ad);}
-
+            {#newExpression = #(create(LITERAL_new,"new",first,LT(1)), #ta, #t, #ad);}
         )
     ;
 
@@ -3127,7 +2917,7 @@ argList
                     | { astFactory.addASTChild(currentAST,astFactory.create(EMPTY_STAT, "EMPTY_STAT")); }
                 )
             )+
-            {#argList = #(create(CLOSURE_LIST,"CLOSURE_LIST",first,LT(1)),#argList);}
+            {#argList = #(create(CLOSURE_LIST,"CLOSURE_LIST",first,LT(1)), #argList);}
         ) | (
                 (   {lastComma = LT(1);}
                     COMMA!
@@ -3304,7 +3094,6 @@ nlsWarn!
         nls!
     ;
 
-
 //----------------------------------------------------------------------------
 // The Groovy scanner
 //----------------------------------------------------------------------------
@@ -3560,7 +3349,7 @@ options {
         };
     }
 
-        // stuff to adjust ANTLR's tracing machinery
+    // stuff to adjust ANTLR's tracing machinery
     public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceLexer
     public void traceIn(String rname) throws CharStreamException {
         if (!GroovyLexer.tracing)  return;
@@ -3597,14 +3386,11 @@ options {
         if (!z && parser!=null)  parser.requireFailed(problem, solution);
         if (!z) {
             int lineNum = inputState.getLine(), colNum = inputState.getColumn();
-            throw new SemanticException(problem + ";\n   solution: " + solution,
-                                        getFilename(), lineNum, colNum);
+            throw new SemanticException(problem + ";\n   solution: " + solution, getFilename(), lineNum, colNum);
         }
     }
 }
 
-// TODO:  Borneo-style ops.
-
 // OPERATORS
 QUESTION          options {paraphrase="'?'";}           :   '?'             ;
 LPAREN            options {paraphrase="'('";}           :   '('             {++parenLevel;};
@@ -3742,7 +3528,9 @@ options {
             // This will fix the issue GROOVY-766 (infinite loop).
             ~('\n'|'\r'|'\uffff')
         )*
-        { if (!whitespaceIncluded)  $setType(Token.SKIP); }
+        {
+            if (!whitespaceIncluded) $setType(Token.SKIP);
+        }
         //This might be significant, so don't swallow it inside the comment:
         //ONE_NL
     ;
@@ -3785,10 +3573,11 @@ options {
         |   ~('*'|'\n'|'\r'|'\uffff')
         )*
         "*/"
-        { if (!whitespaceIncluded)  $setType(Token.SKIP); }
+        {
+            if (!whitespaceIncluded) $setType(Token.SKIP);
+        }
     ;
 
-
 // string literals
 STRING_LITERAL
 options {
@@ -4074,7 +3863,6 @@ options {
        ONE_NL[false] { $setText('\n'); }
     ;
 
-
 // hexadecimal digit (again, note it's protected!)
 protected
 HEX_DIGIT
@@ -4084,7 +3872,6 @@ options {
     :   ('0'..'9'|'A'..'F'|'a'..'f')
     ;
 
-
 // a dummy rule to force vocabulary to be all characters (except special
 // ones that ANTLR uses internally (0 to 2)
 protected
@@ -4095,7 +3882,6 @@ options {
     :   '\3'..'\377'
     ;
 
-
 // an identifier. Note that testLiterals is set to true! This means
 // that after we match the rule, we look in the literals table to see
 // if it's a literal or really an identifier
@@ -4256,7 +4042,6 @@ options {
     :   ('e'|'E') ('+'|'-')? ('0'..'9'|'_')* ('0'..'9')
     ;
 
-
 protected
 FLOAT_SUFFIX
 options {


Mime
View raw message