Index: groovy.g
===================================================================
RCS file: /home/projects/groovy/scm/groovy/groovy-core/src/main/org/codehaus/groovy/antlr/groovy.g,v
retrieving revision 1.24
diff -c -r1.24 groovy.g
*** groovy.g	13 Apr 2005 21:45:54 -0000	1.24
--- groovy.g	19 Apr 2005 21:32:05 -0000
***************
*** 387,393 ****
  // Package statement: optional annotations followed by "package" then the package identifier.
  packageDefinition
          //TODO? options {defaultErrorHandler = true;} // let ANTLR handle errors
!     :   annotationsOpt p:"package"^ {#p.setType(PACKAGE_DEF);} identifier
      ;
  
  
--- 387,393 ----
  // Package statement: optional annotations followed by "package" then the package identifier.
  packageDefinition
          //TODO? options {defaultErrorHandler = true;} // let ANTLR handle errors
!     :   annotationsOpt "package"! ^[PACKAGE_DEF,"package"]^ identifier 
      ;
  
  
***************
*** 602,608 ****
  
  // Wildcard type indicating all types (with possible constraint)
  wildcardType
!     :   q:QUESTION^ {#q.setType(WILDCARD_TYPE);}
          (("extends" | "super")=> typeArgumentBounds)?
      ;
  
--- 602,608 ----
  
  // Wildcard type indicating all types (with possible constraint)
  wildcardType
!     :   QUESTION! ^[WILDCARD_TYPE,"?"]^
          (("extends" | "super")=> typeArgumentBounds)?
      ;
  
***************
*** 808,814 ****
  /*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
--- 808,814 ----
  /*OBS*
  // This is an initializer used to set up an annotation member array.
  annotationMemberArrayInitializer
!     :   LCURLY! ^[ANNOTATION_ARRAY_INIT,"{"]^
          (   annotationMemberArrayValueInitializer
              (
                  // CONFLICT: does a COMMA after an initializer start a new
***************
*** 1143,1149 ****
      ;
  
  constructorBody
!     :   lc:LCURLY^ nls!         {#lc.setType(SLIST);}
          (   (explicitConstructorInvocation) =>   // Java compatibility hack
                  explicitConstructorInvocation (sep! blockBody[sepToken])?
              |   blockBody[EOF]
--- 1143,1149 ----
      ;
  
  constructorBody
!     :   LCURLY! ^[SLIST,"{"]^ nls!         
          (   (explicitConstructorInvocation) =>   // Java compatibility hack
                  explicitConstructorInvocation (sep! blockBody[sepToken])?
              |   blockBody[EOF]
***************
*** 1155,1164 ****
  /** Catch obvious constructor calls, but not the expr.super(...) calls */
  explicitConstructorInvocation
      :   (typeArguments)?
!         (   "this"! lp1:LPAREN^ argList RPAREN!
!             {#lp1.setType(CTOR_CALL);}
!         |   "super"! lp2:LPAREN^ argList RPAREN!
!             {#lp2.setType(SUPER_CTOR_CALL);}
          )
      ;
  
--- 1155,1162 ----
  /** Catch obvious constructor calls, but not the expr.super(...) calls */
  explicitConstructorInvocation
      :   (typeArguments)?
!         (   "this"! LPAREN! ^[CTOR_CALL,"("]^ argList RPAREN!
!         |   "super"! LPAREN! ^[SUPER_CTOR_CALL,"("]^ argList RPAREN!
          )
      ;
  
***************
*** 1182,1187 ****
--- 1180,1186 ----
  
          (   id:IDENT
          |   qid:STRING_LITERAL          {#qid.setType(IDENT);}  // use for operator defintions, etc.
+             //todo Add ^[IDENT,????] tree construction syntax
          )
  
          // parse the formal parameter declarations.
***************
*** 1267,1273 ****
          (
              // A following list constructor might conflict with index brackets; prefer the declarator.
              options {greedy=true;} :
!             lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!
          )*
      ;
  
--- 1266,1272 ----
          (
              // A following list constructor might conflict with index brackets; prefer the declarator.
              options {greedy=true;} :
!             LBRACK! ^[ARRAY_DECLARATOR,"("]^ RBRACK!
          )*
      ;
  
***************
*** 1280,1286 ****
  /*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
--- 1279,1285 ----
  /*OBS*
  // This is an initializer used to set up an array.
  arrayInitializer
!     :   LCURLY! ^[ARRAY_INIT,"{"]^
          (   initializer
              (
                  // CONFLICT: does a COMMA after an initializer start a new
***************
*** 1494,1500 ****
  
  /** An open block is not allowed to have closure arguments. */
  openBlock
!     :   lc:LCURLY^ nls!     {#lc.setType(SLIST);}
          // AST type of SLIST means "never gonna be a closure"
          blockBody[EOF]
          RCURLY!
--- 1493,1499 ----
  
  /** An open block is not allowed to have closure arguments. */
  openBlock
!     :   LCURLY! ^[SLIST,"{"]^ nls!     
          // AST type of SLIST means "never gonna be a closure"
          blockBody[EOF]
          RCURLY!
***************
*** 1511,1517 ****
   *  Only labeled, unparameterized blocks which occur directly as substatements are kept open.
   */
  closedBlock
!     :   lc:LCURLY^ nls!     {#lc.setType(CLOSED_BLOCK);}
          closureParametersOpt[true]
          blockBody[EOF]
          RCURLY!
--- 1510,1516 ----
   *  Only labeled, unparameterized blocks which occur directly as substatements are kept open.
   */
  closedBlock
!     :   LCURLY! ^[CLOSED_BLOCK,"{"]^ nls!     
          closureParametersOpt[true]
          blockBody[EOF]
          RCURLY!
***************
*** 1533,1538 ****
--- 1532,1538 ----
  openOrClosedBlock
      :   lc:LCURLY^ nls!
          cp:closureParametersOpt[false]
+         // todo use ^[SLIST,???] or ^[CLOSED_BLOCK,???] tree construction syntax
          {   if (#cp == null)    #lc.setType(SLIST);
              else                #lc.setType(CLOSED_BLOCK);
          }
***************
*** 1604,1610 ****
  
      // Splice statement, meaningful only inside a "with" expression.
      // PROPOSED, DECIDE.  Prevents the namespace pollution of a "text" method or some such.
!     |   sp:STAR^ nls!                       {#sp.setType(SPREAD_ARG);}
          expressionStatement[EOF]
      // Example:  with(htmlbuilder) { head{} body{ *"some text" } }
      // Equivalent to:  { htmlbuilder.head{} htmlbuilder.body{ (htmlbuilder as Collection).add("some text") } }
--- 1604,1610 ----
  
      // Splice statement, meaningful only inside a "with" expression.
      // PROPOSED, DECIDE.  Prevents the namespace pollution of a "text" method or some such.
!     |   STAR! ^[SPREAD_ARG,"*"]^ nls!                       
          expressionStatement[EOF]
      // Example:  with(htmlbuilder) { head{} body{ *"some text" } }
      // Equivalent to:  { htmlbuilder.head{} htmlbuilder.body{ (htmlbuilder as Collection).add("some text") } }
***************
*** 1626,1632 ****
  
      /*OBS*
      // empty statement
!     |   s:SEMI {#s.setType(EMPTY_STAT);}
      *OBS*/
  
      |   branchStatement
--- 1626,1632 ----
  
      /*OBS*
      // empty statement
!     |   SEMI ^[EMPTY_STAT,";"]
      *OBS*/
  
      |   branchStatement
***************
*** 1738,1744 ****
  /** A labeled statement, consisting of a vanilla identifier followed by a colon. */
  // Note:  Always use this lookahead, to keep antlr from panicking: (IDENT COLON)=>
  statementLabelPrefix
!     :   IDENT c:COLON^ {#c.setType(LABELED_STAT);}
      ;
  
  /** An expression statement can be any general expression.
--- 1738,1744 ----
  /** A labeled statement, consisting of a vanilla identifier followed by a colon. */
  // Note:  Always use this lookahead, to keep antlr from panicking: (IDENT COLON)=>
  statementLabelPrefix
!     :   IDENT COLON! ^[LABELED_STAT,":"]^
      ;
  
  /** An expression statement can be any general expression.
***************
*** 1910,1915 ****
--- 1910,1916 ----
          {
              AST elist = #(#[ELIST,"ELIST"], #commandArguments);
              AST headid = getASTFactory().dup(#head);
+             //todo possibly use ^[METHOD_CALL,???] tree construction here
              headid.setType(METHOD_CALL);
              headid.setText("<command>");
              #commandArguments = #(headid, head, elist);
***************
*** 2048,2057 ****
  
      |   DOT^ nls! "super"
          (   // (new Outer()).super()  (create enclosing instance)
!             lp3:LPAREN^ argList RPAREN!
!             {#lp3.setType(SUPER_CTOR_CALL);}
          |   DOT^ IDENT
!             (   lps:LPAREN^ {#lps.setType(METHOD_CALL);}
                  argList
                  RPAREN!
              )?
--- 2049,2057 ----
  
      |   DOT^ nls! "super"
          (   // (new Outer()).super()  (create enclosing instance)
!             LPAREN! ^[SUPER_CTOR_CALL,"("]^ argList RPAREN!
          |   DOT^ IDENT
!             (   LPAREN! ^[METHOD_CALL,"("]^
                  argList
                  RPAREN!
              )?
***************
*** 2160,2166 ****
  methodCallArgs[AST callee]
      :
          {#methodCallArgs = callee;}
!         lp:LPAREN^ {#lp.setType(METHOD_CALL);}
          argList
          RPAREN!
      ;
--- 2160,2166 ----
  methodCallArgs[AST callee]
      :
          {#methodCallArgs = callee;}
!         LPAREN! ^[METHOD_CALL,"("]^
          argList
          RPAREN!
      ;
***************
*** 2197,2203 ****
  indexPropertyArgs[AST indexee]
      :
          {#indexPropertyArgs = indexee;}
!         lb:LBRACK^ {#lb.setType(INDEX_OP);}
          argList
          RBRACK!
      ;
--- 2197,2203 ----
  indexPropertyArgs[AST indexee]
      :
          {#indexPropertyArgs = indexee;}
!         LBRACK! ^[INDEX_OP,"("]^
          argList
          RBRACK!
      ;
***************
*** 2301,2307 ****
              ((SL^ | SR^ | BSR^)
              |   RANGE_INCLUSIVE^
              |   RANGE_EXCLUSIVE^
!             |   td:TRIPLE_DOT^ {#td.setType(RANGE_EXCLUSIVE);} /* backward compat: FIXME REMOVE */
              )
              nls!
              additiveExpression[0]
--- 2301,2307 ----
              ((SL^ | SR^ | BSR^)
              |   RANGE_INCLUSIVE^
              |   RANGE_EXCLUSIVE^
!             |   TRIPLE_DOT! ^[RANGE_EXCLUSIVE,"..."]^ /* backward compat: FIXME REMOVE */
              )
              nls!
              additiveExpression[0]
***************
*** 2325,2332 ****
  multiplicativeExpression[int lc_stmt]
      :    ( INC^ nls!  powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
      |    ( DEC^ nls!  powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
!     |    ( MINUS^ {#MINUS.setType(UNARY_MINUS);} nls!   powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
!     |    ( PLUS^ {#PLUS.setType(UNARY_PLUS);} nls!   powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
      |    (  powerExpression[lc_stmt] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
      ;
  
--- 2325,2332 ----
  multiplicativeExpression[int lc_stmt]
      :    ( INC^ nls!  powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
      |    ( DEC^ nls!  powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
!     |    ( MINUS! ^[UNARY_MINUS,"-"]^ nls!   powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
!     |    ( PLUS! ^[UNARY_PLUS,"+"]^ nls!   powerExpression[0] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
      |    (  powerExpression[lc_stmt] ((STAR^ | DIV^ | MOD^ )  nls!  powerExpression[0])* )
      ;
  
***************
*** 2339,2346 ****
  unaryExpression[int lc_stmt]
      :   INC^ nls! unaryExpression[0]
      |   DEC^ nls! unaryExpression[0]
!     |   MINUS^   {#MINUS.setType(UNARY_MINUS);}   nls! unaryExpression[0]
!     |   PLUS^    {#PLUS.setType(UNARY_PLUS);}     nls! unaryExpression[0]
      |   unaryExpressionNotPlusMinus[lc_stmt]
      ;
  
--- 2339,2346 ----
  unaryExpression[int lc_stmt]
      :   INC^ nls! unaryExpression[0]
      |   DEC^ nls! unaryExpression[0]
!     |   MINUS!   ^[UNARY_MINUS,"-"]^   nls! unaryExpression[0]
!     |   PLUS!    ^[UNARY_PLUS,"+"]^     nls! unaryExpression[0]
      |   unaryExpressionNotPlusMinus[lc_stmt]
      ;
  
***************
*** 2382,2389 ****
              options {greedy=true;} :
              // possibly add on a post-increment or post-decrement.
              // allows INC/DEC on too much, but semantics can check
!             in:INC^ {#in.setType(POST_INC);}
!         |   de:DEC^ {#de.setType(POST_DEC);}
          )?
      ;
      
--- 2382,2389 ----
              options {greedy=true;} :
              // possibly add on a post-increment or post-decrement.
              // allows INC/DEC on too much, but semantics can check
!             INC! ^[POST_INC,"++"]^
!         |   DEC! ^[POST_DEC,"--"]^
          )?
      ;
      
***************
*** 2421,2427 ****
      ;
  
  scopeEscapeExpression
!     :   DOLLAR^  {#DOLLAR.setType(SCOPE_ESCAPE);} (IDENT | scopeEscapeExpression)
          // PROPOSE: The SCOPE_ESCAPE operator pops its operand out of the scope of a "with" block.
          // If not within a "with" block, it pops the operand out of the static global scope,
          // into whatever dynamic (unchecked) global scope is available when the script is run,
--- 2421,2427 ----
      ;
  
  scopeEscapeExpression
!     :   DOLLAR!  ^[SCOPE_ESCAPE,"$"]^ (IDENT | scopeEscapeExpression)
          // PROPOSE: The SCOPE_ESCAPE operator pops its operand out of the scope of a "with" block.
          // If not within a "with" block, it pops the operand out of the static global scope,
          // into whatever dynamic (unchecked) global scope is available when the script is run,
***************
*** 2471,2477 ****
      :
      (
          // PROPOSE: allow spread markers on string constructor arguments
!         sp:STAR^                        {#sp.setType(SPREAD_ARG);}
      )?
      (   identifier
      |   openOrClosedBlock
--- 2471,2477 ----
      :
      (
          // PROPOSE: allow spread markers on string constructor arguments
!         STAR!                        ^[SPREAD_ARG,"*"]^
      )?
      (   identifier
      |   openOrClosedBlock
***************
*** 2546,2552 ****
                  // 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);}
--- 2546,2552 ----
                  // limitation of linear approximate lookahead.
                  greedy=true;
              }
!         :   (   LPAREN! ^[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);}
***************
*** 2554,2560 ****
                  argList RPAREN!
              )
          |   (    options {greedy=true;} :
!                 lbc:LBRACK^ {#lbc.setType(ARRAY_DECLARATOR);} RBRACK!
              )+
          )?
      ;
--- 2554,2560 ----
                  argList RPAREN!
              )
          |   (    options {greedy=true;} :
!                 LBRACK! ^[ARRAY_DECLARATOR,"["]^ RBRACK!
              )+
          )?
      ;
***************
*** 2680,2691 ****
          // Optional argument label.
          // Usage:  Specifies a map key, or a keyworded argument.
          (   (argumentLabelStart) =>
!             argumentLabel c:COLON^          {#c.setType(LABELED_ARG);}
  
              {   hasLabel = true;  }  // signal to caller the presence of a label
  
          |   // Spread operator:  f(*[a,b,c])  ===  f(a,b,c);  f(1,*null,2)  ===  f(1,2).
!             sp:STAR^                        {#sp.setType(SPREAD_ARG);}
              // spread maps are marked, as f(*:m) for f(a:x, b:y) if m==[a:x, b:y]
              (
                  COLON!                      {#sp.setType(SPREAD_MAP_ARG);}
--- 2680,2691 ----
          // Optional argument label.
          // Usage:  Specifies a map key, or a keyworded argument.
          (   (argumentLabelStart) =>
!             argumentLabel COLON!          ^[LABELED_ARG,":"]^
  
              {   hasLabel = true;  }  // signal to caller the presence of a label
  
          |   // Spread operator:  f(*[a,b,c])  ===  f(a,b,c);  f(1,*null,2)  ===  f(1,2).
!             STAR!                        ^[SPREAD_ARG,"*"]^
              // spread maps are marked, as f(*:m) for f(a:x, b:y) if m==[a:x, b:y]
              (
                  COLON!                      {#sp.setType(SPREAD_MAP_ARG);}
***************
*** 2733,2739 ****
                  warnWhenFollowAmbig = false;
              }
          :
!             lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);}
                  (expression[0])?
              RBRACK!
          )+
--- 2733,2739 ----
                  warnWhenFollowAmbig = false;
              }
          :
!             LBRACK! ^[ARRAY_DECLARATOR,"("]^
                  (expression[0])?
              RBRACK!
          )+