[fasta] Add and correct even more offsets

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 '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 207 matching lines @@
 
   List<Expression> popListForEffect(int n) {
     List<Expression> list =
         new List<Expression>.filled(n, null, growable: true);
     for (int i = n - 1; i >= 0; i--) {
       list[i] = popForEffect();
     }
     return list;
   }
 
-  Block popBlock(int count) {
+  Block popBlock(int count, Token beginToken) {

[ahe, 2017/03/13 14:33:52]

Should take an int, not a token.

[jensj, 2017/03/14 12:37:11]

Fixed.

     List<dynamic /*Statement | List<Statement>*/ > statements =
         popList(count) ?? <Statement>[];
     List<Statement> copy;
     for (int i = 0; i < statements.length; i++) {
       var statement = statements[i];
       if (statement is List) {
         copy ??= new List<Statement>.from(statements.getRange(0, i));
         // TODO(sigmund): remove this assignment (issue #28651)
         Iterable subStatements = statement;
         copy.addAll(subStatements);
       } else if (copy != null) {
         copy.add(statement);
       }
     }
-    return new Block(copy ?? statements);
+    return new Block(copy ?? statements)..fileOffset = beginToken.charOffset;
   }
 
   Statement popStatementIfNotNull(Object value) {
     return value == null ? null : popStatement();
   }
 
   Statement popStatement() {
     var statement = pop();
     if (statement is List) {
       return new Block(new List<Statement>.from(statement));
@@ skipping 95 matching lines @@
     checkEmpty(-1);
   }
 
   @override
   void endFunctionBody(int count, Token beginToken, Token endToken) {
     debugEvent("FunctionBody");
     if (beginToken == null) {
       assert(count == 0);
       push(NullValue.Block);
     } else {
-      Block block = popBlock(count);
+      Block block = popBlock(count, beginToken);
       exitLocalScope();
       push(block);
     }
   }
 
   @override
   void prepareInitializers() {
     scope = formalParameterScope;
     assert(fieldInitializers.isEmpty);
     final member = this.member;
@@ skipping 148 matching lines @@
     if (arguments != null && typeArguments != null) {
       arguments.types.addAll(typeArguments);
     } else {
       assert(typeArguments == null);
     }
     if (receiver is Identifier) {
       Name name = new Name(receiver.name, library.library);
       if (arguments == null) {
         push(new IncompletePropertyAccessor(this, beginToken.charOffset, name));
       } else {
-        push(new SendAccessor(this, endToken.charOffset, name, arguments));
+        push(new SendAccessor(this, beginToken.charOffset, name, arguments));
       }
     } else if (arguments == null) {
       push(receiver);
     } else {
       push(finishSend(receiver, arguments, beginToken.charOffset));
     }
   }
 
   @override
   finishSend(Object receiver, Arguments arguments, int charOffset) {
@@ skipping 325 matching lines @@
 
   @override
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
     push(new IntLiteral(int.parse(token.lexeme)));
   }
 
   @override
   void endExpressionFunctionBody(Token arrowToken, Token endToken) {
     debugEvent("ExpressionFunctionBody");
-    endReturnStatement(true, arrowToken, endToken);
+    endReturnStatement(true, arrowToken.next, endToken);
   }
 
   @override
   void endReturnStatement(
       bool hasExpression, Token beginToken, Token endToken) {
     debugEvent("ReturnStatement");
     Expression expression = hasExpression ? popForValue() : null;
     if (expression != null && inConstructor) {
       push(buildCompileTimeErrorStatement(
           "Can't return from a constructor.", beginToken.charOffset));
@@ skipping 77 matching lines @@
     if (variables.length != 1) {
       push(variables);
     } else {
       push(variables.single);
     }
   }
 
   @override
   void endBlock(int count, Token beginToken, Token endToken) {
     debugEvent("Block");
-    Block block = popBlock(count);
+    Block block = popBlock(count, beginToken);
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
@@ skipping 74 matching lines @@
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void endAwaitExpression(Token beginToken, Token endToken) {
     debugEvent("AwaitExpression");
-    push(new AwaitExpression(popForValue()));
+    push(
+        new AwaitExpression(popForValue())..fileOffset = beginToken.charOffset);
   }
 
   @override
   void handleAsyncModifier(Token asyncToken, Token starToken) {
     debugEvent("AsyncModifier");
     push(asyncMarkerFromTokens(asyncToken, starToken));
   }
 
   @override
   void handleLiteralList(
@@ skipping 214 matching lines @@
   }
 
   @override
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     Expression expression = popForValue();
     push(new Throw(expression)..fileOffset = throwToken.charOffset);
   }
 
   @override
-  void endFormalParameter(
-      Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
+  void endFormalParameter(Token covariantKeyword, Token thisKeyword,
+      Token nameToken, FormalParameterType kind) {
     debugEvent("FormalParameter");
     // TODO(ahe): Need beginToken here.
     int charOffset = thisKeyword?.charOffset;
     if (thisKeyword != null) {
       if (!inConstructor) {
         addCompileTimeError(thisKeyword.charOffset,
             "'this' parameters can only be used on constructors.");
         thisKeyword = null;
       }
     }
@@ skipping 291 matching lines @@
   Expression buildStaticInvocation(Member target, Arguments arguments,
       {bool isConst: false, int charOffset: -1}) {
     List<TypeParameter> typeParameters = target.function.typeParameters;
     if (target is Constructor) {
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!addDefaultArguments(target.function, arguments, typeParameters)) {
       return throwNoSuchMethodError(target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
-      return new ConstructorInvocation(target, arguments)..isConst = isConst;
+      return new ConstructorInvocation(target, arguments)
+        ..isConst = isConst
+        ..fileOffset = charOffset;
     } else {
-      return new StaticInvocation(target, arguments)..isConst = isConst;
+      return new StaticInvocation(target, arguments)
+        ..isConst = isConst
+        ..fileOffset = charOffset;
     }
   }
 
   bool addDefaultArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters) {
     bool missingInitializers = false;
 
     Expression defaultArgumentFrom(Expression expression) {
       if (expression == null) {
         missingInitializers = true;
@@ skipping 48 matching lines @@
 
     if (missingInitializers) {
       library.addArgumentsWithMissingDefaultValues(arguments, function);
     }
     return true;
   }
 
   @override
   void handleNewExpression(Token token) {
     debugEvent("NewExpression");
+    Token nameToken = token.next ?? token;

[ahe, 2017/03/13 14:33:52]

token.next can't be null.

[jensj, 2017/03/14 12:37:11]

Acknowledged.

     Arguments arguments = pop();
     String name = pop();
     List<DartType> typeArguments = pop();
     var type = pop();
 
     if (arguments == null) {
-      push(buildCompileTimeError("No arguments.", token.charOffset));
+      push(buildCompileTimeError("No arguments.", nameToken.charOffset));
       return;
     }
 
     if (typeArguments != null) {
       assert(arguments.types.isEmpty);
       arguments.types.addAll(typeArguments);
     }
 
     String errorName;
     if (type is ClassBuilder) {
       Builder b = type.findConstructorOrFactory(name);
       Member target;
       if (b == null) {
         // Not found. Reported below.
       } else if (b.isConstructor) {
         if (type.isAbstract) {
           // TODO(ahe): Generate abstract instantiation error.
         } else {
           target = b.target;
         }
       } else if (b.isFactory) {
         target = getRedirectionTarget(b.target);
         if (target == null) {
           push(buildCompileTimeError(
-              "Cyclic definition of factory '${name}'.", token.charOffset));
+              "Cyclic definition of factory '${name}'.", nameToken.charOffset));
           return;
         }
       }
       if (target is Constructor ||
           (target is Procedure && target.kind == ProcedureKind.Factory)) {
         push(buildStaticInvocation(target, arguments,
-            isConst: optional("const", token), charOffset: token.charOffset));
+            isConst: optional("const", token),
+            charOffset: nameToken.charOffset));
         return;
       } else {
         errorName = debugName(type.name, name);
       }
     } else {
       errorName = debugName(getNodeName(type), name);
     }
     errorName ??= name;
-    push(throwNoSuchMethodError(errorName, arguments, token.charOffset));
+    push(throwNoSuchMethodError(errorName, arguments, nameToken.charOffset));
   }
 
   @override
   void handleConstExpression(Token token) {
     debugEvent("ConstExpression");
     handleNewExpression(token);
   }
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
@@ skipping 28 matching lines @@
 
   @override
   void handleNamedArgument(Token colon) {
     debugEvent("NamedArgument");
     Expression value = popForValue();
     Identifier identifier = pop();
     push(new NamedExpression(identifier.name, value));
   }
 
   @override
-  void endFunctionName(Token token) {
+  void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
     VariableDeclaration variable =
         new VariableDeclaration(name.name, isFinal: true);
     push(new FunctionDeclaration(
-        variable, new FunctionNode(new InvalidStatement())));
+        variable, new FunctionNode(new InvalidStatement()))
+      ..fileOffset = beginToken.charOffset);
     scope[variable.name] = new KernelVariableBuilder(
         variable, member ?? classBuilder ?? library, uri);
     enterLocalScope();
   }
 
   void enterFunction() {
     debugEvent("enterFunction");
     functionNestingLevel++;
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = null;
@@ skipping 11 matching lines @@
     enterFunction();
   }
 
   @override
   void beginUnnamedFunction(Token token) {
     debugEvent("beginUnnamedFunction");
     enterFunction();
   }
 
   @override
-  void endFunction(Token getOrSet, Token endToken) {
+  void endFunction(
+      Token getOrSet, Token formalParametersToken, Token endToken) {
     debugEvent("Function");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     if (functionNestingLevel != 0) {
       exitLocalScope();
     }
     FormalParameters formals = pop();
     List<TypeParameter> typeParameters = pop();
     push(formals.addToFunction(new FunctionNode(body,
-        typeParameters: typeParameters, asyncMarker: asyncModifier)));
+        typeParameters: typeParameters, asyncMarker: asyncModifier)
+      ..fileOffset = formalParametersToken.charOffset
+      ..fileEndOffset = endToken.charOffset));
   }
 
   @override
   void endFunctionDeclaration(Token token) {
     debugEvent("FunctionDeclaration");
     FunctionNode function = pop();
     exitLocalScope();
     FunctionDeclaration declaration = pop();
     function.returnType = pop() ?? const DynamicType();
     pop(); // Modifiers.
     exitFunction();
     declaration.function = function;
     function.parent = declaration;
     push(declaration);
   }
 
   @override
-  void endUnnamedFunction(Token token) {
+  void endUnnamedFunction(Token beginToken, Token token) {
     debugEvent("UnnamedFunction");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
     exitFunction();
     List<TypeParameter> typeParameters = pop();
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
-        typeParameters: typeParameters, asyncMarker: asyncModifier));
-    push(new FunctionExpression(function));
+        typeParameters: typeParameters, asyncMarker: asyncModifier)
+      ..fileOffset = beginToken.charOffset
+      ..fileEndOffset = token.charOffset);
+    push(new FunctionExpression(function)..fileOffset = beginToken.charOffset);
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
     debugEvent("DoWhileStatement");
     Expression condition = popForValue();
     Statement body = popStatement();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
@@ skipping 105 matching lines @@
         statement = new LabeledStatement(statement);
       }
       target.continueTarget.resolveContinues(statement);
     }
     push(statement);
   }
 
   @override
   void endRethrowStatement(Token throwToken, Token endToken) {
     debugEvent("RethrowStatement");
-    push(new ExpressionStatement(new Rethrow()));
+    push(new ExpressionStatement(
+        new Rethrow()..fileOffset = throwToken.charOffset));
   }
 
   @override
   void handleFinallyBlock(Token finallyKeyword) {
     debugEvent("FinallyBlock");
     // Do nothing, handled by [endTryStatement].
   }
 
   @override
   void endWhileStatement(Token whileKeyword, Token endToken) {
@@ skipping 25 matching lines @@
       Token assertKeyword, Token commaToken, Token semicolonToken) {
     debugEvent("AssertStatement");
     Expression message = popForValueIfNotNull(commaToken);
     Expression condition = popForValue();
     push(new AssertStatement(condition, message));
   }
 
   @override
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
     debugEvent("YieldStatement");
-    push(new YieldStatement(popForValue(), isYieldStar: starToken != null));
+    push(new YieldStatement(popForValue(), isYieldStar: starToken != null)
+      ..fileOffset = yieldToken.charOffset);
   }
 
   @override
   void beginSwitchBlock(Token token) {
     debugEvent("beginSwitchBlock");
     enterLocalScope();
     enterSwitchScope();
     enterBreakTarget(token.charOffset);
   }
 
@@ skipping 28 matching lines @@
 
   @override
   void handleSwitchCase(
       int labelCount,
       int expressionCount,
       Token defaultKeyword,
       int statementCount,
       Token firstToken,
       Token endToken) {
     debugEvent("SwitchCase");
-    Block block = popBlock(statementCount);
+    Block block = popBlock(statementCount, firstToken);
     exitLocalScope();
     List<Label> labels = pop();
     List<Expression> expressions = pop();
     push(new SwitchCase(expressions, block, isDefault: defaultKeyword != null)
       ..fileOffset = firstToken.charOffset);
     push(labels);
   }
 
   @override
   void endSwitchStatement(Token switchKeyword, Token endToken) {
@@ skipping 673 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }