[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, int charOffset) {
     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 = 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 endBlockFunctionBody(int count, Token beginToken, Token endToken) {
     debugEvent("BlockFunctionBody");
     if (beginToken == null) {
       assert(count == 0);
       push(NullValue.Block);
     } else {
-      Block block = popBlock(count);
+      Block block = popBlock(count, beginToken.charOffset);
       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 274 matching lines @@
       Token token = pop();
       push(new StringLiteral(unescapeString(token.lexeme)));
     } else {
       List parts = popList(1 + interpolationCount * 2);
       Token first = parts.first;
       Token last = parts.last;
       Quote quote = analyzeQuote(first.lexeme);
       List<Expression> expressions = <Expression>[];
       // Contains more than just \' or \".
       if (first.lexeme.length > 1) {
-        expressions
-          .add(new StringLiteral(unescapeFirstStringPart(first.lexeme, quote)));
+        expressions.add(
+            new StringLiteral(unescapeFirstStringPart(first.lexeme, quote)));
       }
       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
           if (part.lexeme.length != 0) {
             expressions.add(new StringLiteral(unescape(part.lexeme, quote)));
           }
         } else {
           expressions.add(toValue(part));
         }
       }
       // Contains more than just \' or \".
       if (last.lexeme.length > 1) {
         expressions
-          .add(new StringLiteral(unescapeLastStringPart(last.lexeme, quote)));
+            .add(new StringLiteral(unescapeLastStringPart(last.lexeme, quote)));
       }
       push(new StringConcatenation(expressions)
         ..fileOffset = endToken.charOffset);
     }
   }
 
   @override
   void handleScript(Token token) {
     debugEvent("Script");
   }
@@ skipping 28 matching lines @@
 
   @override
   void handleEmptyFunctionBody(Token semicolon) {
     debugEvent("ExpressionFunctionBody");
     endBlockFunctionBody(0, null, semicolon);
   }
 
   @override
   void handleExpressionFunctionBody(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.charOffset);
     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 82 matching lines @@
 
   @override
   void endFormalParameters(int count, Token beginToken, Token endToken) {
     debugEvent("FormalParameters");
     OptionalFormals optional;
     if (count > 0 && peek() is OptionalFormals) {
       optional = pop();
       count--;
     }
     FormalParameters formals = new FormalParameters(
-        popList(count) ?? <VariableDeclaration>[], optional);
+        popList(count) ?? <VariableDeclaration>[],
+        optional,
+        beginToken.charOffset);
     push(formals);
     if (inCatchClause || functionNestingLevel != 0) {
       enterLocalScope(formals.computeFormalParameterScope(
           scope, member ?? classBuilder ?? library));
     }
   }
 
   @override
   void beginCatchClause(Token token) {
     debugEvent("beginCatchClause");
@@ skipping 188 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 (!checkArguments(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 checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters) {
-
     if (arguments.positional.length < function.requiredParameterCount ||
         arguments.positional.length > function.positionalParameters.length) {
       return false;
     }
     Map<String, VariableDeclaration> names;
     if (function.namedParameters.isNotEmpty) {
       names = <String, VariableDeclaration>{};
       for (VariableDeclaration parameter in function.namedParameters) {
         names[parameter.name] = parameter;
       }
@@ skipping 13 matching lines @@
         arguments.types.add(const DynamicType());
       }
     }
 
     return true;
   }
 
   @override
   void handleNewExpression(Token token) {
     debugEvent("NewExpression");
+    Token nameToken = token.next;
     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 21 matching lines @@
   void endFunction(Token getOrSet, 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 = formals.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 commaToken, Token rightParenthesis, 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.charOffset);
     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 573 matching lines @@
   final FormalParameterType kind;
 
   final List<VariableDeclaration> formals;
 
   OptionalFormals(this.kind, this.formals);
 }
 
 class FormalParameters {
   final List<VariableDeclaration> required;
   final OptionalFormals optional;
+  final int charOffset;
 
-  FormalParameters(this.required, this.optional);
+  FormalParameters(this.required, this.optional, this.charOffset);
 
   FunctionNode addToFunction(FunctionNode function) {
     function.requiredParameterCount = required.length;
     function.positionalParameters.addAll(required);
     if (optional != null) {
       if (optional.kind.isPositional) {
         function.positionalParameters.addAll(optional.formals);
       } else {
         function.namedParameters.addAll(optional.formals);
         setParents(function.namedParameters, function);
@@ skipping 79 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}");
   }
 }