anchor.diff:  // due to possible ambiguities with other kinds of statements.  This nonterminal is used only
   // in contexts where we know we have an expression.  It allows general Java-type expressions.
   expression
  -        :   (declarationStart)=> singleDeclaration
  -        |   branchExpression
  -        |       assignmentExpression
  -                {#expression = #(#[EXPR,"EXPR"],#expression);}
  -        ;
  +    :   (declarationStart)=> singleDeclaration
  +    |   branchExpression
  +    |   assignmentExpression
  +        {#expression = #(#[EXPR,"EXPR"],#expression);}
  +    ;
   // This is a list of expressions.
   controlExpressionList
  -        :       controlExpression (COMMA! nls! controlExpression)*
  -                {#controlExpressionList = #(#[ELIST,"ELIST"], controlExpressionList);}
  -        ;
  +    :   controlExpression (COMMA! nls! controlExpression)*
  +        {#controlExpressionList = #(#[ELIST,"ELIST"], controlExpressionList);}
  +    ;
   
   /** Used for backward compatibility, in a few places where
    *  Java expresion statements and declarations are required.
    */
   controlExpression
  -                {boolean zz; /*ignore*/ }
  -        :       // if it looks like a declaration, it is
  -                (declarationStart)=> singleDeclaration
  -        |   // otherwise it's a plain statement expression
  -                zz=head:pathExpression!
  -                (       assignmentTail[#head]
  -                |   {#controlExpression = #head;}  // no command syntax in this context
  -                )
  -        |
  -                // Prefix increment; a special case of assignment statement.
  -                (INC^ | DEC^) zz=pathExpression
  -        ;
  +        {boolean zz; /*ignore*/ }
  +    :   // if it looks like a declaration, it is
  +        (declarationStart)=> singleDeclaration
  +    |   // otherwise it's a plain statement expression
  +        zz=head:pathExpression!
  +        (   assignmentTail[#head]
  +        |   {#controlExpression = #head;}  // no command syntax in this context
  +        )
  +    |
  +        // Prefix increment; a special case of assignment statement.
  +        (INC^ | DEC^) zz=pathExpression
  +    ;
   
   /** A "path expression" is a name which can be used for value, assigned to, or called.
    *  Uses include assignment targets, commands, and types in declarations.
  
positive.code:  *  later on if we maybe simplified 'def' to be a type declaration?
   */
  constructorDefinition[AST mods]
    :     
    														id:IDENT
  
                  // 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
          (       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); }
  
          cb:constructorBody!
  
negative.code: class GroovyLexer extends Lexer;
  
  options {
      exportVocab=Groovy;             // call the vocabulary "Groovy"
      testLiterals=false;             // don't automatically test for literals
      k=4;                                    // four characters of lookahead
      charVocabulary='\u0003'..'\uFFFF';
      // without inlining some bitset tests, couldn't do unicode;
      // I need to make ANTLR generate smaller bitsets; see
      // bottom of GroovyLexer.java
      codeGenBitsetTestThreshold=20;
  }
  
  {
      /** flag for enabling the "assert" keyword */
      private boolean assertEnabled = true;
      /** flag for enabling the "enum" keyword */
      private boolean enumEnabled = true;
  
      /** Enable the "assert" keyword */
      public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
      /** Query the "assert" keyword state */
      public boolean isAssertEnabled() { return assertEnabled; }
      /** Enable the "enum" keyword */
      public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
      /** Query the "enum" keyword state */
      public boolean isEnumEnabled() { return enumEnabled; }
  
  
  /** Bumped when inside '[x]' or '(x)', reset inside '{x}'.  See ONE_NL.  */
      protected int parenLevel = 0;
      protected int suppressNewline = 0;  // be really mean to newlines inside strings
      protected static final int SCS_TRIPLE = 1, SCS_VAL = 2, SCS_LIT = 4, SCS_LIMIT = 8;
      protected int stringCtorState = 0;  // hack string constructor boundaries
      /** Push parenLevel here and reset whenever inside '{x}'. */
      protected ArrayList parenLevelStack = new ArrayList();
      protected Token lastToken = Token.badToken;
  
      protected void pushParenLevel() {
          parenLevelStack.add(new Integer(parenLevel*8 + stringCtorState));
          parenLevel = 0;
          stringCtorState = 0;
      }
      protected void popParenLevel() {
          int npl = parenLevelStack.size();
          if (npl == 0)  return;
          int i = ((Integer) parenLevelStack.remove(--npl)).intValue();
          parenLevel      = i / SCS_LIMIT;
          stringCtorState = i % SCS_LIMIT;
      }
  
      protected void restartStringCtor(boolean expectLiteral) {
          if (stringCtorState != 0) {
              stringCtorState = (expectLiteral? SCS_LIT: SCS_VAL) + (stringCtorState & SCS_TRIPLE);
          }
      }
  
      void newlineCheck() throws RecognitionException {
          if (suppressNewline > 0) {
              suppressNewline = 0;
              require(suppressNewline == 0,
                  "end of line reached within a simple string 'x' or \"x\"",
                  "for multi-line literals, use triple quotes '''x''' or \"\"\"x\"\"\"");
          }
          newline();
      }
  
      /** This is a bit of plumbing which resumes collection of string constructor bodies,
       *  after an embedded expression has been parsed.
       *  Usage:  new GroovyRecognizer(new GroovyLexer(in).plumb()).
       */
      public TokenStream plumb() {
          return new TokenStream() {
              public Token nextToken() throws TokenStreamException {
                  if (stringCtorState >= SCS_LIT) {
                      // This goo is modeled upon the ANTLR code for nextToken:
                      boolean tripleQuote = (stringCtorState & SCS_TRIPLE) != 0;
                      stringCtorState = 0;  // get out of this mode, now
                      resetText();
                      try {
                          mSTRING_CTOR_END(true, /*fromStart:*/false, tripleQuote);
                          return lastToken = _returnToken;
                      } catch (RecognitionException e) {
                          throw new TokenStreamRecognitionException(e);
                      } catch (CharStreamException cse) {
                          if ( cse instanceof CharStreamIOException ) {
                              throw new TokenStreamIOException(((CharStreamIOException)cse).io);
                          }
                          else {
                              throw new TokenStreamException(cse.getMessage());
                          }
                      }
                  }
                  return lastToken = GroovyLexer.this.nextToken();
              }
          };
      }
  
          // 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;
  