Improve position information.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
@@ skipping 559 matching lines @@
       var node = arguments[i];
       if (node is NamedExpression) {
         firstNamedArgumentIndex =
             i < firstNamedArgumentIndex ? i : firstNamedArgumentIndex;
       } else {
         arguments[i] = toValue(node);
         if (i > firstNamedArgumentIndex) {
           arguments[i] = new NamedExpression(
               "#$i",
               buildCompileTimeError(
-                  "Expected named argument.", arguments[i].fileOffset));
+                  "Expected named argument.", arguments[i].fileOffset))
+            ..fileOffset = beginToken.charOffset;
         }
       }
     }
     if (firstNamedArgumentIndex < arguments.length) {
       List<Expression> positional = new List<Expression>.from(
           arguments.getRange(0, firstNamedArgumentIndex));
       List<NamedExpression> named = new List<NamedExpression>.from(
           arguments.getRange(firstNamedArgumentIndex, arguments.length));
-      push(new KernelArguments(positional, named: named));
+      push(new KernelArguments(positional, named: named)
+        ..fileOffset = beginToken.charOffset);
     } else {
-      push(new KernelArguments(arguments));
+      push(new KernelArguments(arguments)..fileOffset = beginToken.charOffset);
     }
   }
 
   @override
   void handleParenthesizedExpression(BeginToken token) {
     debugEvent("ParenthesizedExpression");
     push(new ParenthesizedExpression(this, popForValue(), token.endGroup));
   }
 
   @override
@@ skipping 129 matching lines @@
     VariableDeclaration variable = new VariableDeclaration.forValue(a);
     push(makeLet(
         variable,
         new ConditionalExpression(buildIsNull(new VariableGet(variable)), b,
             new VariableGet(variable), const DynamicType())));
   }
 
   /// Handle `a?.b(...)`.
   void doIfNotNull(Token token) {
     IncompleteSend send = pop();
-    push(send.withReceiver(pop(), isNullAware: true));
+    push(send.withReceiver(pop(), token.charOffset, isNullAware: true));
   }
 
   void doDotOrCascadeExpression(Token token) {
     // TODO(ahe): Handle null-aware.
     IncompleteSend send = pop();
     Object receiver = optional(".", token) ? pop() : popForValue();
-    push(send.withReceiver(receiver));
+    push(send.withReceiver(receiver, token.charOffset));
   }
 
   @override
   Expression toSuperMethodInvocation(MethodInvocation node) {
     Member target = lookupSuperMember(node.name);
     bool isNoSuchMethod = target == null;
     if (target is Procedure) {
       if (!target.isAccessor) {
         if (areArgumentsCompatible(target.function, node.arguments)) {
-          // TODO(ahe): Use [DirectMethodInvocation] when possible.
           Expression result = new KernelDirectMethodInvocation(
-              new ThisExpression(), target, node.arguments);
+              new ThisExpression()..fileOffset = node.fileOffset,
+              target,
+              node.arguments);
+          // TODO(ahe): Use [DirectMethodInvocation] when possible, that is,
+          // remove the next line:
           result =
               new KernelSuperMethodInvocation(node.name, node.arguments, null);
           return result;
         } else {
           isNoSuchMethod = true;
         }
       }
     }
     if (isNoSuchMethod) {
       return throwNoSuchMethodError(
           node.name.name, node.arguments, node.fileOffset,
           isSuper: true);
     }
-    // TODO(ahe): Use [DirectPropertyGet] when possible.
-    Expression receiver =
-        new KernelDirectPropertyGet(new ThisExpression(), target);
+    Expression receiver = new KernelDirectPropertyGet(
+        new ThisExpression()..fileOffset = node.fileOffset, target);
+    // TODO(ahe): Use [DirectPropertyGet] when possible, that is, remove the
+    // next line:
     receiver = new KernelSuperPropertyGet(node.name, target);
     return buildMethodInvocation(
         receiver, callName, node.arguments, node.fileOffset);
   }
 
   bool areArgumentsCompatible(FunctionNode function, Arguments arguments) {
     // TODO(ahe): Implement this.
     return true;
   }
 
@@ skipping 1307 matching lines @@
       push(new IncompleteError(
           this, token, "Expected identifier, but got 'super'."));
     }
   }
 
   @override
   void handleNamedArgument(Token colon) {
     debugEvent("NamedArgument");
     Expression value = popForValue();
     Identifier identifier = pop();
-    push(new NamedExpression(identifier.name, value));
+    push(new NamedExpression(identifier.name, value)
+      ..fileOffset = offsetForToken(identifier.token));
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
     VariableDeclaration variable = new KernelVariableDeclaration(
         name.name, functionNestingLevel,
         isFinal: true, isLocalFunction: true)
       ..fileOffset = offsetForToken(name.token);
@@ skipping 1151 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }