anchor.diff:   *  new
    *   |
    *   T --  ELIST
  - *		   |
  - *		  arg1 -- arg2 -- .. -- argn
  + *                 |
  + *                arg1 -- arg2 -- .. -- argn
    *
    *  new int[]
    *
  
positive.code:         // type declaration
          (typeDeclarationStart)=>
          ( mods:modifiers )?
  		(	td:typeDefinitionInternal[#mods]
  			{#classField = #td;}
  		)
  
  	// "static { ... }" class initializer
  	|	"static" s3:compoundStatement
  		{#classField = #(#[STATIC_INIT,"STATIC_INIT"], s3);}
  
  	// "{ ... }" instance initializer
  	|	s4:compoundStatement
  		{#classField = #(#[INSTANCE_INIT,"INSTANCE_INIT"], s4);}
  	;
  
  // Now the various things that can be defined inside a interface
  interfaceField!
  	:	// method, constructor, or variable declaration
          (declarationStart)=>
          d:declaration
          {#interfaceField = #d;}
  
negative.code:  *  Must be guarded, as in (declarationStart) => declaration.
   */
  declaration!
      :
          // method/variable using def
          (m:modifiers)?
  
          (
              DEF! nls! v:variableDefinitions[#m, null]
              {#declaration = #v;}
  
          |
  
              // method/variable using a type
              t2:typeSpec[false] v2:variableDefinitions[#m,#t2]
              {#declaration = #v2;}
          )
      ;
  
  /** A declaration with one declarator and no initialization, like a parameterDeclaration.
  
      *TODO* We must also audit the various occurrences of warning
      supp ressions like "options { greedy = true; }".
  */
  
  singleDeclarationNoInit!
      :   // method/variable using def
          (m:modifiers)?
  
          (
              DEF! nls! v:singleVariable[#m, null]
              {#singleDeclarationNoInit = #v;}
  
          |
  
              // method/variable using a type
              t2:typeSpec[false] v2:singleVariable[#m,#t2]
              {#singleDeclarationNoInit = #v2;}
          )
      ;
  
  singleDeclaration
      :   sd:singleDeclarationNoInit!
          { #singleDeclaration = #sd; }
          varInitializer
      ;
  
  /** Used only as a lookahead predicate, before diving in and parsing a declaration.
  