anchor.diff:  //or a named argument list until after we
   //finish parsing it
   memberBody[StaticType type] returns [Block block]
  -      options { memoize=true; }
  -    : {$type instanceof BaseType}?
  -    (
  -      (namedArguments)
  -      => namedArguments //first try to match with no directives or control structures
  +      //options { memoize=true; }
  +    : {$type instanceof BaseType && parseAsNamedArguments()}?
  +      namedArguments //first try to match with no directives or control structures
         { $block = new Block(null);
           SimpleType t = (SimpleType) $type;
           Return r = new Return(null);
  
positive.code:         InvocationExpression ie = new InvocationExpression(null);
          BaseTypeExpression bme = new BaseTypeExpression(null);
          bme.setIdentifier(t.getIdentifier());
          bme.setTypeArguments(t.getTypeArgumentList());
          ie.setPrimary(bme);
          ie.setNamedArgumentList($namedArguments.namedArgumentList);
          e.setTerm(ie);
          r.setExpression(e);
          $block.addStatement(r); }
      //-> ^(BLOCK ^(RETURN ^(EXPRESSION ^(INVOCATION_EXPRESSION ^(BASE_TYPE_EXPRESSION { ((CommonTree)$mt).getChild(0) } { ((CommonTree)$mt).getChild(1) } ) namedArguments))))
      | (block)
        => b1=block //if there is a "return" directive or control structure, it must be a block
        { $block=$b1.block; }
        
      //if it doesn't match as a block or as a named argument
      //list, then there must be an error somewhere, so parse
      //it again looking for the error
      | LBRACE brokenMemberBody? RBRACE
        { $block = new BrokenMemberBody($LBRACE); }
        //TODO: add all the statements in!
      //-> ^(BROKEN_MEMBER_BODY brokenMemberBody?)
      )
      | b2=block
        { $block=$b2.block; }
      ;
  
  brokenMemberBody
      : (annotatedDeclarationStart) => declaration brokenMemberBody?
      | ( 
          specificationStatement brokenMemberBody?
        | controlStatement brokenMemberBody?
        | directiveStatement brokenMemberBody?
        | expressionStatementOrList
        )
      ;
      
  expressionStatementOrList
      : expression 
        (
          ';' brokenMemberBody?
        //-> ^(EXPRESSION_STATEMENT expression) brokenMemberBody?
        | (',' expression)* 
        //-> ^(EXPRESSION_LIST expression+)
        )
      ;
  
  extendedType returns [ExtendedType extendedType]
  
negative.code:     public CompilationUnit getCompilationUnit() {
          return compilationUnit;
      }
      
          private boolean parseAsNamedArguments() {
              //state.backtracking++;
              int start = input.mark();
              blockOrNamedArguments_return r=null;
              try {
              	r=blockOrNamedArguments(); // can never throw exception
              } catch (RecognitionException re) {
                  System.err.println("impossible: "+re);
              }
              boolean success = !state.failed;
              input.rewind(start);
              //state.backtracking--;
              state.failed=false;
              return (success&&!r.foundStatement)
              		|| (!success&&!r.foundStatement&&r.foundExpressionList);
          }
  }
  
  @lexer::members {
  