anchor.diff:          // foo.bar baz{bat}, bang{boz} //OK
           {
               AST elist = #(create(ELIST,"ELIST",first,LT(1)), #commandArguments);
  -            AST headid = getASTFactory().dup(#head);
  -            headid.setType(METHOD_CALL);
  -            headid.setText("<command>");
  -            #commandArguments = #(headid, head, elist);
  +            AST headid = #(create(METHOD_CALL,"<command>",first,LT(1)), head, elist);
  +            #commandArguments = headid;
           }
       ;
   
   commandArgumentsGreedy[AST head]
  -{ AST prev = null; }
  -    :
  -        commandArguments[head]
  -        {
  -            prev = astFactory.dupTree((AST)returnAST);
  -            //prev = #(create(LPAREN,"(",prev),prev);
  -        }
  -        (
  -            options { greedy = true; } :
  -            (COMMA! nls!|)
  -
  -            current : expression[LC_STMT]
  -            {
  -                 AST chain = #(create(DOT, ".", #prev), #prev, #current);
  -                 commandArguments(chain);
  -                 AST chained = astFactory.dupTree( (AST)returnAST );
  -                 prev = chained;
  -            }
  +{ 
  +	AST prev = null; 
  +}
  +    :
  +        { #prev = #head; }
  +    
  +        (   {#prev.getType()!=METHOD_CALL}?
  +            first : commandArguments[head]!
  +            { #prev = #first; }
  +        )?
  +        
  +        (   options { greedy = true; } :
  +            pre:primaryExpression!
  +            { #prev = #(create(DOT, ".", #prev), #prev, #pre); }
  +
  +            (
  +                (LPAREN|LCURLY|LBRACK)=> 
  +                (   options { greedy = true; } :
  +                    //nls!
  +                    pe:pathElement[prev]!
  +                    { #prev = #pe; }
  +                )+            
  +            |
  +                (
  +                    (commandArgument)=> (
  +                        ca:commandArguments[prev]!
  +                        { #prev = #ca; }
  +                    )
  +                    |
  +                )
  +            )
           )*
  -        { #commandArgumentsGreedy = prev; } ;
  -
  +        { #commandArgumentsGreedy = prev; } 
  +    ;
  +    
   commandArgument
       :
           (argumentLabel COLON nls!) => (
  
positive.code:         if (x == null || x.getType() != IDENT)  return false;  // cannot happen?
          return cname.equals(x.getText());
      }
  
      // Scratch variable for last 'sep' token.
      // Written by the 'sep' rule, read only by immediate callers of 'sep'.
  
negative.code:  *  without labels or spread operators.
   */
  commandArguments[AST head]
  {
  	Token first = LT(1);
  }
      :
          commandArgument ( options {greedy=true;}: COMMA! nls! commandArgument )*
          // println 2+2 //OK
  