[fasta] Add and correct 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 566 matching lines @@
     bool negate = false;
     String operator = token.stringValue;
     if (identical("!=", operator)) {
       operator = "==";
       negate = true;
     }
     if (!isBinaryOperator(operator) && !isMinusOperator(operator)) {
       return buildCompileTimeError(
           "Not an operator: '$operator'.", token.charOffset);
     } else {
-      Expression result = makeBinary(a, new Name(operator), null, b);
+      Expression result =
+          makeBinary(a, new Name(operator), null, b, token.charOffset);
       if (isSuper) {
         result = toSuperMethodInvocation(result);
       }
       return negate ? new Not(result) : result;
     }
   }
 
   void doLogicalExpression(Token token) {
     Expression argument = popForValue();
     Expression receiver = popForValue();
@@ skipping 179 matching lines @@
     push(token);
   }
 
   @override
   void handleStringPart(Token token) {
     debugEvent("StringPart");
     push(token);
   }
 
   @override
-  void endLiteralString(int interpolationCount) {
+  void endLiteralString(int interpolationCount, Token endToken) {
     debugEvent("endLiteralString");
     if (interpolationCount == 0) {
       Token token = pop();
       push(new StringLiteral(unescapeString(token.value)));
     } else {
       List parts = popList(1 + interpolationCount * 2);
       Token first = parts.first;
       Token last = parts.last;
       Quote quote = analyzeQuote(first.value);
       List<Expression> expressions = <Expression>[];
       expressions
           .add(new StringLiteral(unescapeFirstStringPart(first.value, quote)));
       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
           expressions.add(new StringLiteral(unescape(part.value, quote)));
         } else {
           expressions.add(toValue(part));
         }
       }
       expressions
           .add(new StringLiteral(unescapeLastStringPart(last.value, quote)));
-      push(new StringConcatenation(expressions));
+      push(new StringConcatenation(expressions)
+        ..fileOffset = endToken.charOffset);
     }
   }
 
   @override
   void handleScript(Token token) {
     debugEvent("Script");
   }
 
   @override
   void handleStringJuxtaposition(int literalCount) {
@@ skipping 237 matching lines @@
     DartType typeArgument = const DynamicType();
     if (typeArguments != null) {
       typeArgument = typeArguments.first;
       if (typeArguments.length > 1) {
         typeArgument = const DynamicType();
         warning(
             "Too many type arguments on List literal.", beginToken.charOffset);
       }
     }
     push(new ListLiteral(expressions,
-        typeArgument: typeArgument, isConst: constKeyword != null));
+        typeArgument: typeArgument, isConst: constKeyword != null)
+      ..fileOffset = constKeyword?.charOffset ?? beginToken.charOffset);
   }
 
   @override
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
     bool value = optional("true", token);
     assert(value || optional("false", token));
     push(new BoolLiteral(value));
   }
 
@@ skipping 22 matching lines @@
         keyType = const DynamicType();
         valueType = const DynamicType();
         warning(
             "Map literal requires two type arguments.", beginToken.charOffset);
       } else {
         keyType = typeArguments[0];
         valueType = typeArguments[1];
       }
     }
     push(new MapLiteral(entries,
-        keyType: keyType, valueType: valueType, isConst: constKeyword != null));
+        keyType: keyType, valueType: valueType, isConst: constKeyword != null)
+      ..fileOffset = constKeyword?.charOffset ?? beginToken.charOffset);
   }
 
   @override
   void endLiteralMapEntry(Token colon, Token endToken) {
     debugEvent("LiteralMapEntry");
     Expression value = popForValue();
     Expression key = popForValue();
     push(new MapEntry(key, value));
   }
 
@@ skipping 140 matching lines @@
     Expression thenExpression = popForValue();
     Expression condition = popForValue();
     push(new ConditionalExpression(
         condition, thenExpression, elseExpression, const DynamicType()));
   }
 
   @override
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     Expression expression = popForValue();
-    push(new Throw(expression));
+    push(new Throw(expression)..fileOffset = throwToken.charOffset);
   }
 
   @override
   void endFormalParameter(
       Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
     debugEvent("FormalParameter");
     // TODO(ahe): Need beginToken here.
     int charOffset = thisKeyword?.charOffset;
     if (thisKeyword != null) {
       if (!inConstructor) {
@@ skipping 28 matching lines @@
         }
         type = field.target.type ?? const DynamicType();
         variable = new VariableDeclaration(name.name,
             type: type, initializer: name.initializer);
       } else {
         addCompileTimeError(
             name.fileOffset, "'${name.name}' isn't a field in this class.");
       }
     }
     variable ??= new VariableDeclaration(name.name,
-        type: type ?? const DynamicType(), initializer: name.initializer);
+        type: type ?? const DynamicType(),
+        initializer: name.initializer)..fileOffset = name.fileOffset;
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
         ? FormalParameterType.NAMED
         : FormalParameterType.POSITIONAL;
@@ skipping 160 matching lines @@
     if (optional("++", token)) return plusName;
     if (optional("--", token)) return minusName;
     return internalError("Unknown increment operator: ${token.value}");
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
     if (accessor is BuilderAccessor) {
-      push(accessor.buildPrefixIncrement(incrementOperator(token)));
+      push(accessor.buildPrefixIncrement(
+          incrementOperator(token), token.charOffset));
     } else {
       push(wrapInvalid(toValue(accessor)));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
     if (accessor is BuilderAccessor) {
@@ skipping 583 matching lines @@
     }
     if (target == null && name == null) {
       push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
           "No target of break.", breakKeyword.charOffset));
     } else if (target == null ||
         target is! JumpTarget ||
         !target.isBreakTarget) {
       push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
           "Can't break to '$name'.", breakKeyword.next.charOffset));
     } else {
-      BreakStatement statement = new BreakStatement(null);
+      BreakStatement statement = new BreakStatement(null)
+        ..fileOffset = breakKeyword.charOffset;
       target.addBreak(statement);
       push(statement);
     }
   }
 
   @override
   void handleContinueStatement(
       bool hasTarget, Token continueKeyword, Token endToken) {
     debugEvent("ContinueStatement");
     var target = continueTarget;
@@ skipping 24 matching lines @@
         return;
       }
     }
     if (target == null) {
       push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
           "No target of continue.", continueKeyword.charOffset));
     } else if (!target.isContinueTarget) {
       push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
           "Can't continue at '$name'.", continueKeyword.next.charOffset));
     } else {
-      BreakStatement statement = new BreakStatement(null);
+      BreakStatement statement = new BreakStatement(null)
+        ..fileOffset = continueKeyword.charOffset;
       target.addContinue(statement);
       push(statement);
     }
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
     logEvent("TypeVariable");
     // TODO(ahe): Implement this when enabling generic method syntax.
   }
@@ skipping 201 matching lines @@
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return internalError("not supported");
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return internalError("not supported");
   }
 
-  Expression buildCompoundAssignment(Name binaryOperator, Expression value,
+  Expression buildCompoundAssignment(
+      Name binaryOperator, Expression value, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return internalError("not supported");
   }
 
-  Expression buildPrefixIncrement(Name binaryOperator,
+  Expression buildPrefixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return internalError("not supported");
   }
 
-  Expression buildPostfixIncrement(Name binaryOperator,
+  Expression buildPostfixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return internalError("not supported");
   }
 
   makeInvalidRead() => internalError("not supported");
 
   makeInvalidWrite(Expression value) => internalError("not supported");
 }
 
 class DelayedAssignment extends ContextAccessor {
@@ skipping 10 matching lines @@
   }
 
   Expression buildForEffect() {
     return handleAssignment(true);
   }
 
   Expression handleAssignment(bool voidContext) {
     if (identical("=", assignmentOperator)) {
       return accessor.buildAssignment(value, voidContext: voidContext);
     } else if (identical("+=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(plusName, value,
+      return accessor.buildCompoundAssignment(plusName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("-=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(minusName, value,
+      return accessor.buildCompoundAssignment(minusName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("*=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(multiplyName, value,
+      return accessor.buildCompoundAssignment(multiplyName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("%=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(percentName, value,
+      return accessor.buildCompoundAssignment(percentName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("&=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(ampersandName, value,
+      return accessor.buildCompoundAssignment(ampersandName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("/=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(divisionName, value,
+      return accessor.buildCompoundAssignment(divisionName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("<<=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(leftShiftName, value,
+      return accessor.buildCompoundAssignment(leftShiftName, value, charOffset,
           voidContext: voidContext);
     } else if (identical(">>=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(rightShiftName, value,
+      return accessor.buildCompoundAssignment(rightShiftName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("??=", assignmentOperator)) {
       return accessor.buildNullAwareAssignment(value, const DynamicType(),
           voidContext: voidContext);
     } else if (identical("^=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(caretName, value,
+      return accessor.buildCompoundAssignment(caretName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("|=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(barName, value,
+      return accessor.buildCompoundAssignment(barName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("~/=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(mustacheName, value,
+      return accessor.buildCompoundAssignment(mustacheName, value, charOffset,
           voidContext: voidContext);
     } else {
       return internalError("Unhandled: $assignmentOperator");
     }
   }
 
   Initializer buildFieldInitializer(
       Map<String, FieldInitializer> initializers) {
     if (!identical("=", assignmentOperator) ||
         !accessor.isThisPropertyAccessor) {
@@ skipping 13 matching lines @@
 class DelayedPostfixIncrement extends ContextAccessor {
   final Name binaryOperator;
 
   final Procedure interfaceTarget;
 
   DelayedPostfixIncrement(BuilderHelper helper, int charOffset,
       BuilderAccessor accessor, this.binaryOperator, this.interfaceTarget)
       : super(helper, charOffset, accessor);
 
   Expression buildSimpleRead() {
-    return accessor.buildPostfixIncrement(binaryOperator,
+    return accessor.buildPostfixIncrement(binaryOperator, charOffset,
         voidContext: false, interfaceTarget: interfaceTarget);
   }
 
   Expression buildForEffect() {
-    return accessor.buildPostfixIncrement(binaryOperator,
+    return accessor.buildPostfixIncrement(binaryOperator, charOffset,
         voidContext: true, interfaceTarget: interfaceTarget);
   }
 }
 
 class JumpTarget extends Builder {
   final List<Statement> users = <Statement>[];
 
   final JumpTargetKind kind;
 
   JumpTarget(this.kind, MemberBuilder member, int charOffset)
@@ skipping 198 matching lines @@
   } else if (node is TypeDeclarationBuilder) {
     return node.name;
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisPropertyAccessor) {
     return node.name.name;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }