Index: src/main/org/codehaus/groovy/control/ResolveVisitor.java
===================================================================
--- src/main/org/codehaus/groovy/control/ResolveVisitor.java	(Revision 870)
+++ src/main/org/codehaus/groovy/control/ResolveVisitor.java	(Revision 952)
@@ -670,7 +670,9 @@
         }
         Expression right = transform(de.getRightExpression());
         if (right == de.getRightExpression()) return de;
-        return new DeclarationExpression((VariableExpression) left, de.getOperation(), right);
+        DeclarationExpression newDeclExpr = new DeclarationExpression((VariableExpression) left, de.getOperation(), right);
+        newDeclExpr.setSourcePosition(de);
+        return newDeclExpr;
     }
 
     protected Expression transformAnnotationConstantExpression(AnnotationConstantExpression ace) {
Index: src/main/org/codehaus/groovy/control/StaticImportVisitor.java
===================================================================
--- src/main/org/codehaus/groovy/control/StaticImportVisitor.java	(Revision 870)
+++ src/main/org/codehaus/groovy/control/StaticImportVisitor.java	(Revision 952)
@@ -116,6 +116,7 @@
         if (mce.isImplicitThis() || isExplicitThisOrSuper) {
             Expression ret = findStaticMethodImportFromModule(method, args);
             if (ret != null) {
+            	ret.setSourcePosition(mce);
                 return ret;
             }
             if (method instanceof ConstantExpression) {
@@ -123,8 +124,11 @@
                 Object value = ce.getValue();
                 if (value instanceof String) {
                     String methodName = (String) value;
-                    if (inSpecialConstructorCall || currentClass.hasPossibleStaticMethod(methodName, args))
-                    return new StaticMethodCallExpression(currentClass, methodName, args);
+                    if (inSpecialConstructorCall || currentClass.hasPossibleStaticMethod(methodName, args)) {
+                    	StaticMethodCallExpression smce = new StaticMethodCallExpression(currentClass, methodName, args);
+                    	smce.setSourcePosition(mce);
+                    	return smce;
+                    }
                 }
             }
         }
Index: src/main/org/codehaus/groovy/antlr/groovy.g
===================================================================
--- src/main/org/codehaus/groovy/antlr/groovy.g	(Revision 870)
+++ src/main/org/codehaus/groovy/antlr/groovy.g	(Revision 952)
@@ -266,6 +266,10 @@
      * todo - change antlr.ASTFactory to do this instead...
      */
     public AST create(int type, String txt, Token first, Token last) {
+        return create(type, txt, astFactory.create(first), last);
+    }
+    
+    public AST create(int type, String txt, AST first, Token last) {
         AST t = astFactory.create(type,txt);
         if ( t != null && first != null) {
             // first copy details from first token
@@ -1400,7 +1404,10 @@
         (
             // A following list constructor might conflict with index brackets; prefer the declarator.
             options {greedy=true;} :
-            lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!
+            LBRACK!
+            RBRACK!
+            {#declaratorBrackets = #(create(ARRAY_DECLARATOR,"[",typ,LT(1)),
+                               #declaratorBrackets);}
         )*
     ;
 
@@ -2306,12 +2313,20 @@
 // AST is [METHOD_CALL, callee, ELIST? CLOSABLE_BLOCK?].
 // Note that callee is often of the form x.y but not always.
 // If the callee is not of the form x.y, then an implicit .call is needed.
+// Parameter callee is only "null" when called from newExpression
 methodCallArgs[AST callee]
     :
-        {#methodCallArgs = callee;}
-        lp:LPAREN^ {#lp.setType(METHOD_CALL);}
-        argList
+        LPAREN!
+        al:argList!
         RPAREN!
+        { if (callee != null && callee.getFirstChild() != null) {
+              //method call like obj.method()
+              #methodCallArgs = #(create(METHOD_CALL, "(",callee.getFirstChild(),LT(1)), callee, al); 
+          } else {
+              //method call like method() or new Expr(), in the latter case "callee" is null
+              #methodCallArgs = #(create(METHOD_CALL, "(",callee, LT(1)), callee, al);
+          }
+        }
     ;
 
 /** An appended block follows any expression.
@@ -2319,22 +2334,20 @@
  */
 appendedBlock[AST callee]
     :
+        /*  FIXME DECIDE: should appended blocks accept labels?
+        (   (IDENT COLON nls LCURLY)=>
+            IDENT c:COLON^ {#c.setType(LABELED_ARG);} nls!
+        )? */
+        cb:closableBlock!
         {
             // If the callee is itself a call, flatten the AST.
             if (callee != null && callee.getType() == METHOD_CALL) {
-                #appendedBlock = callee;
+                #appendedBlock = #(create(METHOD_CALL, "(",callee,LT(1)),
+                                   callee.getFirstChild(), cb);
             } else {
-                AST lbrace = getASTFactory().create(LT(1));
-                lbrace.setType(METHOD_CALL);
-                if (callee != null)  lbrace.addChild(callee);
-                #appendedBlock = lbrace;
+                #appendedBlock = #(create(METHOD_CALL, "{",callee,LT(1)), callee, cb);
             }
         }
-        /*  FIXME DECIDE: should appended blocks accept labels?
-        (   (IDENT COLON nls LCURLY)=>
-            IDENT c:COLON^ {#c.setType(LABELED_ARG);} nls!
-        )? */
-        closableBlock
     ;
 
 /** An expression may be followed by [...].
@@ -2345,10 +2358,17 @@
  */
 indexPropertyArgs[AST indexee]
     :
-        {#indexPropertyArgs = indexee;}
-        lb:LBRACK^ {#lb.setType(INDEX_OP);}
-        argList
+        LBRACK!
+        al:argList!
         RBRACK!
+        { if (indexee != null && indexee.getFirstChild() != null) {
+              //expression like obj.index[]
+              #indexPropertyArgs = #(create(INDEX_OP, "INDEX_OP",indexee.getFirstChild(),LT(1)), indexee, al); 
+          } else {
+              //expression like obj[]
+              #indexPropertyArgs = #(create(INDEX_OP, "INDEX_OP",indexee,LT(1)), indexee, al);
+          }
+        }
     ;
 
 // assignment expression (level 15)
@@ -2799,8 +2819,8 @@
  *                         2
  *
  */
-newExpression
-    :   "new"^ nls! (typeArguments)? type
+newExpression {Token first = LT(1);}
+    :   "new"! nls! (ta:typeArguments!)? t:type!
         (   nls!
             mca:methodCallArgs[null]!
 
@@ -2810,7 +2830,8 @@
                 { #mca = #apb1; }
             )?
 
-            {#newExpression.addChild(#mca.getFirstChild());}
+            {#mca = #mca.getFirstChild();
+            #newExpression = #(create(LITERAL_new,"new",first,LT(1)),#ta,#t,#mca);}
 
         //|
         //from blackrag: new Object.f{} matches this part here
@@ -2830,9 +2851,10 @@
             // to make sure:
             //   a) [ expr ] and [ ] are not mixed
             //   b) [ expr ] and an init are not used together
-        |   newArrayDeclarator //(arrayInitializer)?
+        |   ad:newArrayDeclarator! //(arrayInitializer)?
             // Groovy does not support Java syntax for initialized new arrays.
             // Use sequence constructors instead.
+            {#newExpression = #(create(LITERAL_new,"new",first,LT(1)),#ta,#t,#ad);}
 
         )
         // DECIDE:  Keep 'new x()' syntax?