Change accessors and AstFactory to use tokens rather than file 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 '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
@@ skipping 19 matching lines @@
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import 'frontend_accessors.dart' show buildIsNull, makeBinary, makeLet;
 
 import '../parser/dart_vm_native.dart' show skipNativeClause;
 
 import '../scanner/token.dart'
-    show BeginGroupToken, Token, isBinaryOperator, isMinusOperator;
+    show
+        BeginGroupToken,
+        Token,
+        isBinaryOperator,
+        isMinusOperator,
+        offsetForToken;
 
 import '../errors.dart' show formatUnexpected, internalError;
 
 import '../source/scope_listener.dart'
     show JumpTargetKind, NullValue, ScopeListener;
 
 import '../scope.dart' show ProblemBuilder;
 
 import '../source/outline_builder.dart' show asyncMarkerFromTokens;
 
@@ skipping 178 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, int charOffset) {
+  Block popBlock(int count, Token beginToken) {
     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 astFactory.block(copy ?? statements, charOffset);
+    return astFactory.block(copy ?? statements, beginToken);
   }
 
   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 97 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, beginToken.charOffset);
+      Block block = popBlock(count, beginToken);
       exitLocalScope();
       push(block);
     }
   }
 
   @override
   void prepareInitializers() {
     scope = formalParameterScope;
     assert(fieldInitializers.isEmpty);
     final member = this.member;
@@ skipping 176 matching lines @@
           arguments.getRange(firstNamedArgumentIndex, arguments.length));
       push(new Arguments(positional, named: named));
     } else {
       push(new Arguments(arguments));
     }
   }
 
   @override
   void handleParenthesizedExpression(BeginGroupToken token) {
     debugEvent("ParenthesizedExpression");
-    push(new ParenthesizedExpression(
-        this, popForValue(), token.endGroup.charOffset));
+    push(new ParenthesizedExpression(this, popForValue(), token.endGroup));
   }
 
   @override
   void endSend(Token beginToken, Token endToken) {
     debugEvent("Send");
     Arguments arguments = pop();
     List<DartType> typeArguments = pop();
     Object receiver = pop();
     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));
+        push(new IncompletePropertyAccessor(this, beginToken, name));
       } else {
-        push(new SendAccessor(this, beginToken.charOffset, name, arguments));
+        push(new SendAccessor(this, beginToken, name, arguments));
       }
     } else if (arguments == null) {
       push(receiver);
     } else {
       push(finishSend(receiver, arguments, beginToken.charOffset));
     }
   }
 
   @override
   finishSend(Object receiver, Arguments arguments, int charOffset) {
@@ skipping 15 matching lines @@
           toValue(receiver), callName, arguments, charOffset);
     }
   }
 
   @override
   void beginCascade(Token token) {
     debugEvent("beginCascade");
     Expression expression = popForValue();
     if (expression is CascadeReceiver) {
       push(expression);
-      push(new VariableAccessor(
-          this, expression.fileOffset, expression.variable));
+      // TODO(paulberry): Previously we used expression.fileOffset; now we are
+      // using token.  Is that a problem?

[ahe, 2017/04/25 17:39:59]

I think so. Try running the service tests:

nice ./tools/test.py -cdartk -rvm -mrelease --time -pcolor --report
--failure-summary service

[Paul Berry, 2017/04/25 22:00:55]

Thanks!  I've verified that these tests pass and I've removed the TODO comments.

+      push(new VariableAccessor(this, token, expression.variable));
       expression.extend();
     } else {
       VariableDeclaration variable =
           new VariableDeclaration.forValue(expression);
       push(new CascadeReceiver(variable));
-      push(new VariableAccessor(this, expression.fileOffset, variable));
+      // TODO(paulberry): Previously we used expression.fileOffset; now we are
+      // using token.  Is that a problem?
+      push(new VariableAccessor(this, token, variable));
     }
   }
 
   @override
   void endCascade() {
     debugEvent("endCascade");
     Expression expression = popForEffect();
     CascadeReceiver cascadeReceiver = pop();
     cascadeReceiver.finalize(expression);
     push(cascadeReceiver);
@@ skipping 165 matching lines @@
   @override
   void handleIdentifier(Token token, IdentifierContext context) {
     debugEvent("handleIdentifier");
     String name = token.lexeme;
     if (context.isScopeReference) {
       assert(!inInitializer ||
           this.scope == enclosingScope ||
           this.scope.parent == enclosingScope);
       // This deals with this kind of initializer: `C(a) : a = a;`
       Scope scope = inInitializer ? enclosingScope : this.scope;
-      push(scopeLookup(scope, name, token.charOffset));
+      push(scopeLookup(scope, name, token));
       return;
     } else if (context.inDeclaration) {
       if (context == IdentifierContext.topLevelVariableDeclaration ||
           context == IdentifierContext.fieldDeclaration) {
         constantExpressionRequired = member.isConst;
       }
     } else if (constantExpressionRequired &&
         !context.allowedInConstantExpression) {
       addCompileTimeError(
           token.charOffset, "Not a constant expression: $context");
     }
-    push(new Identifier(name, token.charOffset));
+    push(new Identifier(token));
   }
 
-  /// Look up [name] in [scope] using [charOffset] to report any
+  /// Look up [name] in [scope] using [token] to report any
   /// problems. [isQualified] should be true if [name] is a qualified access

[ahe, 2017/04/25 17:39:59]

Perhaps this documentation of charOffset/token isn't completely correct.

[Paul Berry, 2017/04/25 22:00:55]

Good point.  Fixed.

   /// (which implies that it shouldn't be turned into a [ThisPropertyAccessor]
   /// if the name doesn't resolve in the scope).
   @override
-  scopeLookup(Scope scope, String name, int charOffset,
+  scopeLookup(Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder prefix}) {
-    Builder builder = scope.lookup(name, charOffset, uri);
+    Builder builder = scope.lookup(name, offsetForToken(token), uri);
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       Name n = new Name(name, library.library);
       if (prefix != null &&
           prefix.deferred &&
           builder == null &&
           "loadLibrary" == name) {
         return buildCompileTimeError(
-            "Deferred loading isn't implemented yet.", charOffset);
+            "Deferred loading isn't implemented yet.", offsetForToken(token));
       } else if (!isQualified && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired) {
-          return new UnresolvedAccessor(this, n, charOffset);
+          return new UnresolvedAccessor(this, n, token);
         }
-        return new ThisPropertyAccessor(this, charOffset, n, null, null);
+        return new ThisPropertyAccessor(this, token, n, null, null);
       } else if (isDartLibrary &&
           name == "main" &&
           library.uri.path == "_builtin" &&
           member?.name == "_getMainClosure") {
         // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
-        return new NullLiteral()..fileOffset = charOffset;
+        return new NullLiteral()..fileOffset = offsetForToken(token);
       } else {
-        return new UnresolvedAccessor(this, n, charOffset);
+        return new UnresolvedAccessor(this, n, token);
       }
     } else if (builder.isTypeDeclaration) {
       if (constantExpressionRequired &&
           builder.isTypeVariable &&
           !member.isConstructor) {
-        addCompileTimeError(charOffset, "Not a constant expression.");
+        addCompileTimeError(
+            offsetForToken(token), "Not a constant expression.");
       }
       return builder;
     } else if (builder.isLocal) {
       if (constantExpressionRequired &&
           !builder.isConst &&
           !member.isConstructor) {
-        addCompileTimeError(charOffset, "Not a constant expression.");
+        addCompileTimeError(
+            offsetForToken(token), "Not a constant expression.");
       }
-      return new VariableAccessor(this, charOffset, builder.target);
+      return new VariableAccessor(this, token, builder.target);
     } else if (builder.isInstanceMember) {
       if (constantExpressionRequired &&
           !inInitializer &&
           // TODO(ahe): This is a hack because Fasta sets up the scope
           // "this.field" parameters according to old semantics. Under the new
           // semantics, such parameters introduces a new parameter with that
           // name that should be resolved here.
           !member.isConstructor) {
-        addCompileTimeError(charOffset, "Not a constant expression.");
+        addCompileTimeError(
+            offsetForToken(token), "Not a constant expression.");
       }
       return new ThisPropertyAccessor(
-          this, charOffset, new Name(name, library.library), null, null);
+          this, token, new Name(name, library.library), null, null);
     } else if (builder.isRegularMethod) {
       assert(builder.isStatic || builder.isTopLevel);
-      return new StaticAccessor(this, charOffset, builder.target, null);
+      return new StaticAccessor(this, token, builder.target, null);
     } else if (builder is PrefixBuilder) {
       if (constantExpressionRequired && builder.deferred) {
         addCompileTimeError(
-            charOffset,
+            offsetForToken(token),
             "'$name' can't be used in a constant expression because it's "
             "marked as 'deferred' which means it isn't available until "
             "loaded.\n"
             "You might try moving the constant to the deferred library, "
             "or removing 'deferred' from the import.");
       }
       return builder;
     } else {
       if (builder.hasProblem && builder is! AccessErrorBuilder) return builder;
       Builder setter;
       if (builder.isSetter) {
         setter = builder;
       } else if (builder.isGetter) {
-        setter = scope.lookupSetter(name, charOffset, uri);
+        setter = scope.lookupSetter(name, offsetForToken(token), uri);
       } else if (builder.isField && !builder.isFinal) {
         setter = builder;
       }
       StaticAccessor accessor =
-          new StaticAccessor.fromBuilder(this, builder, charOffset, setter);
+          new StaticAccessor.fromBuilder(this, builder, token, setter);
       if (constantExpressionRequired) {
         Member readTarget = accessor.readTarget;
         if (!(readTarget is Field && readTarget.isConst ||
             // Static tear-offs are also compile time constants.
             readTarget is Procedure)) {
-          addCompileTimeError(charOffset, "Not a constant expression.");
+          addCompileTimeError(
+              offsetForToken(token), "Not a constant expression.");
         }
       }
       return accessor;
     }
   }
 
   @override
   void handleQualified(Token period) {
     debugEvent("Qualified");
     Identifier name = pop();
@@ skipping 74 matching lines @@
           expressions.add(part);
         }
       }
     }
     push(new StringConcatenation(expressions ?? parts));
   }
 
   @override
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
-    push(astFactory.intLiteral(int.parse(token.lexeme), token.charOffset));
+    push(astFactory.intLiteral(int.parse(token.lexeme), token));
   }
 
   @override
   void handleEmptyFunctionBody(Token semicolon) {
     debugEvent("ExpressionFunctionBody");
     endBlockFunctionBody(0, null, semicolon);
   }
 
   @override
   void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
@@ skipping 19 matching lines @@
     Statement elsePart = popStatementIfNotNull(elseToken);
     Statement thenPart = popStatement();
     Expression condition = popForValue();
     push(new IfStatement(condition, thenPart, elsePart));
   }
 
   @override
   void endVariableInitializer(Token assignmentOperator) {
     debugEvent("VariableInitializer");
     assert(assignmentOperator.stringValue == "=");
-    pushNewLocalVariable(popForValue(),
-        equalsCharOffset: assignmentOperator.charOffset);
+    pushNewLocalVariable(popForValue(), equalsToken: assignmentOperator);
   }
 
   @override
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");
     pushNewLocalVariable(null);
   }
 
-  void pushNewLocalVariable(Expression initializer,
-      {int equalsCharOffset: TreeNode.noOffset}) {
+  void pushNewLocalVariable(Expression initializer, {Token equalsToken}) {
     Identifier identifier = pop();
     assert(currentLocalVariableModifiers != -1);
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
     bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
     assert(isConst == constantExpressionRequired);
-    push(astFactory.variableDeclaration(identifier.name, identifier.fileOffset,
+    push(astFactory.variableDeclaration(identifier.name, identifier.token,
         initializer: initializer,
         type: currentLocalVariableType,
         isFinal: isFinal,
         isConst: isConst,
-        equalsCharOffset: equalsCharOffset));
+        equalsToken: equalsToken));
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator, Token token) {
     debugEvent("FieldInitializer");
     assert(assignmentOperator.stringValue == "=");
     push(popForValue());
   }
 
   @override
@@ skipping 44 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, beginToken.charOffset);
+    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) {
       push(wrapInvalid(new TypeLiteral(
           accessor.buildTypesWithBuiltArguments(library, null))));
     } else if (accessor is! FastaAccessor) {
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
-          this, token.charOffset, accessor, value, token.stringValue));
+          this, token, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
     if (peek() is LabelTarget) {
       LabelTarget target = peek();
       enterBreakTarget(charOffset, target.breakTarget);
       enterContinueTarget(charOffset, target.continueTarget);
     } else {
@@ skipping 155 matching lines @@
     } else {
       return internalError("Unhandled: ${name.runtimeType}");
     }
   }
 
   @override
   void endLiteralSymbol(Token hashToken, int identifierCount) {
     debugEvent("LiteralSymbol");
     String value;
     if (identifierCount == 1) {
-      value = symbolPartToString(popForValue());
+      value = symbolPartToString(pop());

[ahe, 2017/04/25 17:39:59]

Why this change?

[Paul Berry, 2017/04/25 22:00:55]

This is necessary in order to decouple Identifier from Expression.  If we don't
change this, but we decouple Identifier from Expression, then popForValue() will
try to pop an Identifier and won't know what to do with it.

     } else {
       List parts = popList(identifierCount);
       value = symbolPartToString(parts.first);
       for (int i = 1; i < parts.length; i++) {
         value += ".${symbolPartToString(parts[i])}";
       }
     }
     push(new SymbolLiteral(value));
   }
 
@@ skipping 44 matching lines @@
       if (suffix is Identifier) {
         suffix = suffix.name;
       }
       Builder builder;
       if (prefix is Builder) {
         builder = prefix;
       } else {
         builder = scope.lookup(prefix, beginToken.charOffset, uri);
       }
       if (builder is PrefixBuilder) {
-        name = scopeLookup(builder.exports, suffix, beginToken.charOffset,
+        name = scopeLookup(builder.exports, suffix, beginToken,
             isQualified: true, prefix: builder);
       } else {
         push(const DynamicType());
         addCompileTimeError(beginToken.charOffset,
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
@@ skipping 115 matching lines @@
       } else if (thisKeyword == null) {
         variable = builder.build(library);
         variable.initializer = name.initializer;
       } else if (builder.isField && builder.parent == classBuilder) {
         FieldBuilder field = builder;
         if (type != null) {
           nit("Ignoring type on 'this' parameter '${name.name}'.",
               thisKeyword.charOffset);
         }
         type = field.target.type ?? const DynamicType();
-        variable = astFactory.variableDeclaration(name.name, name.fileOffset,
+        variable = astFactory.variableDeclaration(name.name, name.token,
             type: type,
             initializer: name.initializer,
             isFinal: isFinal,
             isConst: isConst);
       } else {
-        addCompileTimeError(
-            name.fileOffset, "'${name.name}' isn't a field in this class.");
+        addCompileTimeError(offsetForToken(name.token),
+            "'${name.name}' isn't a field in this class.");
       }
     }
-    variable ??= astFactory.variableDeclaration(name.name, name.fileOffset,
+    variable ??= astFactory.variableDeclaration(name.name, name.token,
         type: type ?? const DynamicType(),
         initializer: name.initializer,
         isFinal: isFinal,
         isConst: isConst);
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
@@ skipping 24 matching lines @@
     push(formals.toFunctionType(returnType));
     push(name);
     functionNestingLevel--;
   }
 
   @override
   void handleValuedFormalParameter(Token equals, Token token) {
     debugEvent("ValuedFormalParameter");
     Expression initializer = popForValue();
     Identifier name = pop();
-    push(new InitializedIdentifier(name.name, initializer, name.fileOffset));
+    push(new InitializedIdentifier(name.token, initializer));
   }
 
   @override
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
   }
 
   @override
   void endFormalParameters(int count, Token beginToken, Token endToken) {
     debugEvent("FormalParameters");
@@ skipping 81 matching lines @@
     push(NullValue.Expression);
   }
 
   @override
   void handleIndexedExpression(
       Token openCurlyBracket, Token closeCurlyBracket) {
     debugEvent("IndexedExpression");
     Expression index = popForValue();
     var receiver = pop();
     if (receiver is ThisAccessor && receiver.isSuper) {
-      push(new SuperIndexAccessor(this, receiver.offset, index,
+      push(new SuperIndexAccessor(this, receiver.token, index,
           lookupSuperMember(indexGetName), lookupSuperMember(indexSetName)));
     } else {
-      push(IndexAccessor.make(this, openCurlyBracket.charOffset,
-          toValue(receiver), index, null, null));
+      push(IndexAccessor.make(
+          this, openCurlyBracket, toValue(receiver), index, null, null));
     }
   }
 
   @override
   void handleUnaryPrefixExpression(Token token) {
     debugEvent("UnaryPrefixExpression");
     var receiver = pop();
     if (optional("!", token)) {
       push(new Not(toValue(receiver)));
     } else {
       String operator = token.stringValue;
       if (optional("-", token)) {
         operator = "unary-";
       }
       if (receiver is ThisAccessor && receiver.isSuper) {
         push(toSuperMethodInvocation(buildMethodInvocation(
-            new ThisExpression()..fileOffset = receiver.offset,
+            new ThisExpression()..fileOffset = offsetForToken(receiver.token),
             new Name(operator),
             new Arguments.empty(),
             token.charOffset)));
       } else {
         push(buildMethodInvocation(toValue(receiver), new Name(operator),
             new Arguments.empty(), token.charOffset));
       }
     }
   }
 
@@ skipping 14 matching lines @@
       push(wrapInvalid(toValue(accessor)));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(new DelayedPostfixIncrement(
-          this, token.charOffset, accessor, incrementOperator(token), null));
+          this, token, accessor, incrementOperator(token), null));
     } else {
       push(wrapInvalid(toValue(accessor)));
     }
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference");
     // A constructor reference can contain up to three identifiers:
@@ skipping 16 matching lines @@
     // ClassBuilder, or a ThisPropertyAccessor. Otherwise, it's an error that
     // should be handled later.
     Identifier suffix = popIfNotNull(periodBeforeName);
     Identifier identifier;
     List<DartType> typeArguments = pop();
     dynamic type = pop();
     if (type is List) {
       var prefix = type[0];
       identifier = type[1];
       if (prefix is PrefixBuilder) {
-        type = scopeLookup(prefix.exports, identifier.name, start.charOffset,
+        type = scopeLookup(prefix.exports, identifier.name, start,
             isQualified: true, prefix: prefix);
         identifier = null;
       } else if (prefix is ClassBuilder) {
         type = prefix;
       } else {
-        type = new Identifier(start.lexeme, start.charOffset);
+        type = new Identifier(start);
       }
     }
     String name;
     if (identifier != null && suffix != null) {
       name = "${identifier.name}.${suffix.name}";
     } else if (identifier != null) {
       name = identifier.name;
     } else if (suffix != null) {
       name = suffix.name;
     } else {
@@ skipping 163 matching lines @@
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
     push(popList(count));
   }
 
   @override
   void handleThisExpression(Token token, IdentifierContext context) {
     debugEvent("ThisExpression");
     if (context.isScopeReference && isInstanceContext) {
-      push(new ThisAccessor(this, token.charOffset, inInitializer));
+      push(new ThisAccessor(this, token, inInitializer));
     } else {
       push(new IncompleteError(
-          this, token.charOffset, "Expected identifier, but got 'this'."));
+          this, token, "Expected identifier, but got 'this'."));
     }
   }
 
   @override
   void handleSuperExpression(Token token, IdentifierContext context) {
     debugEvent("SuperExpression");
     if (context.isScopeReference && isInstanceContext) {
       Member member = this.member.target;
       member.transformerFlags |= TransformerFlag.superCalls;
-      push(new ThisAccessor(this, token.charOffset, inInitializer,
-          isSuper: true));
+      push(new ThisAccessor(this, token, inInitializer, isSuper: true));
     } else {
       push(new IncompleteError(
-          this, token.charOffset, "Expected identifier, but got 'super'."));
+          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));
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
-    VariableDeclaration variable = astFactory
-        .variableDeclaration(name.name, name.fileOffset, isFinal: true);
+    VariableDeclaration variable =
+        astFactory.variableDeclaration(name.name, name.token, isFinal: true);
     push(new FunctionDeclaration(
         variable, new FunctionNode(new InvalidStatement()))
       ..fileOffset = beginToken.charOffset);
     scope[variable.name] = new KernelVariableBuilder(
         variable, member ?? classBuilder ?? library, uri);
     enterLocalScope();
   }
 
   void enterFunction() {
     debugEvent("enterFunction");
@@ skipping 289 matching lines @@
 
   @override
   void handleSwitchCase(
       int labelCount,
       int expressionCount,
       Token defaultKeyword,
       int statementCount,
       Token firstToken,
       Token endToken) {
     debugEvent("SwitchCase");
-    Block block = popBlock(statementCount, firstToken.charOffset);
+    Block block = popBlock(statementCount, firstToken);
     exitLocalScope();
     List<Label> labels = pop();
     List<Expression> expressions = pop();
     List<int> expressionOffsets = <int>[];
     for (Expression expression in expressions) {
       expressionOffsets.add(expression.fileOffset);
     }
     push(new SwitchCase(expressions, expressionOffsets, block,
         isDefault: defaultKeyword != null)
       ..fileOffset = firstToken.charOffset);
@@ skipping 85 matching lines @@
         push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
             "Target of continue must be a label.", continueKeyword.charOffset));
         return;
       }
       if (target == null) {
         if (switchScope == null) {
           push(buildCompileTimeErrorStatement(
               "Can't find label '$name'.", continueKeyword.next.charOffset));
           return;
         }
-        switchScope.forwardDeclareLabel(
-            identifier.name, target = createGotoTarget(identifier.fileOffset));
+        switchScope.forwardDeclareLabel(identifier.name,
+            target = createGotoTarget(offsetForToken(identifier.token)));
       }
       if (target.isGotoTarget &&
           target.functionNestingLevel == functionNestingLevel) {
         ContinueSwitchStatement statement = new ContinueSwitchStatement(null);
         target.addGoto(statement);
         push(statement);
         return;
       }
     }
     if (target == null) {
@@ skipping 122 matching lines @@
 
   @override
   void handleOperator(Token token) {
     debugEvent("Operator");
     push(new Operator(token.stringValue)..fileOffset = token.charOffset);
   }
 
   @override
   void handleSymbolVoid(Token token) {
     debugEvent("SymbolVoid");
-    push(new Identifier(token.stringValue, token.charOffset));
+    push(new Identifier(token));
   }
 
   dynamic addCompileTimeError(int charOffset, String message,
       {bool silent: false}) {
     // TODO(ahe): If constantExpressionRequired is set, set it to false to
     // avoid a long list of errors.
     return library.addCompileTimeError(charOffset, message, fileUri: uri);
   }
 
   @override
@@ skipping 33 matching lines @@
     }
     return expression;
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 
   @override
-  StaticGet makeStaticGet(Member readTarget, int offset) {
+  StaticGet makeStaticGet(Member readTarget, Token token) {
     // TODO(paulberry): only record the dependencies mandated by the top level
     // type inference spec.
     if (fieldDependencies != null && readTarget is KernelField) {
       var fieldNode = _typeInferrer.getFieldNodeForReadTarget(readTarget);
       if (fieldNode != null) {
         fieldDependencies.add(fieldNode);
       }
     }
-    return astFactory.staticGet(readTarget, offset);
+    return astFactory.staticGet(readTarget, token);
   }
 }
 
-// TODO(ahe): Shouldn't need to be an expression.
-class Identifier extends InvalidExpression {
-  final String name;
+class Identifier {

[ahe, 2017/04/25 17:39:59]

Could remove the superclass in a separate CL?

[Paul Berry, 2017/04/25 22:00:55]

Ok, I will do so before landing this CL.

+  final Token token;
+  String get name => token.lexeme;
 
-  Identifier(this.name, int charOffset) {
-    fileOffset = charOffset;
-  }
+  Identifier(this.token);
 
   Expression get initializer => null;
 
   String toString() => "identifier($name)";
 }
 
 // TODO(ahe): Shouldn't need to be an expression.
 class Operator extends InvalidExpression {
   final String name;
 
   Operator(this.name);
 
   String toString() => "operator($name)";
 }
 
 class InitializedIdentifier extends Identifier {
   final Expression initializer;
 
-  InitializedIdentifier(String name, this.initializer, int charOffset)
-      : super(name, charOffset);
+  InitializedIdentifier(Token token, this.initializer) : super(token);
 
   String toString() => "initialized-identifier($name, $initializer)";
 }
 
 // TODO(ahe): Shouldn't need to be an expression.
 class Label extends InvalidExpression {
   String name;
 
   Label(this.name);
 
@@ skipping 26 matching lines @@
     nextCascade.variable.initializer = expression;
     expression.parent = nextCascade.variable;
   }
 }
 
 abstract class ContextAccessor extends FastaAccessor {
   final BuilderHelper helper;
 
   final FastaAccessor accessor;
 
-  final int offset;
+  final Token token;
 
-  ContextAccessor(this.helper, this.offset, this.accessor);
+  ContextAccessor(this.helper, this.token, this.accessor);
 
   @override
   Expression get builtBinary => internalError("Unsupported operation.");
 
   @override
   void set builtBinary(Expression expression) {
     internalError("Unsupported operation.");
   }
 
   @override
@@ skipping 41 matching lines @@
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     return makeInvalidWrite(null);
   }
 
   makeInvalidRead() => internalError("not supported");
 
   Expression makeInvalidWrite(Expression value) {
     return helper.buildCompileTimeError(
-        "Can't be used as left-hand side of assignment.", offset);
+        "Can't be used as left-hand side of assignment.",
+        offsetForToken(token));
   }
 }
 
 class DelayedAssignment extends ContextAccessor {
   final Expression value;
 
   final String assignmentOperator;
 
-  DelayedAssignment(BuilderHelper helper, int charOffset,
-      FastaAccessor accessor, this.value, this.assignmentOperator)
-      : super(helper, charOffset, accessor);
+  DelayedAssignment(BuilderHelper helper, Token token, FastaAccessor accessor,
+      this.value, this.assignmentOperator)
+      : super(helper, token, accessor);
 
   Expression buildSimpleRead() {
     return handleAssignment(false);
   }
 
   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,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("-=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(minusName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("*=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(multiplyName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("%=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(percentName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("&=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(ampersandName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("/=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(divisionName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("<<=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(leftShiftName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical(">>=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(rightShiftName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("??=", assignmentOperator)) {
       return accessor.buildNullAwareAssignment(value, const DynamicType(),
           voidContext: voidContext);
     } else if (identical("^=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(caretName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("|=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(barName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("~/=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(mustacheName, value,
-          offset: offset, voidContext: voidContext);
+          offset: offsetForToken(token), voidContext: voidContext);
     } else {
       return internalError("Unhandled: $assignmentOperator");
     }
   }
 
   Initializer buildFieldInitializer(
       Map<String, FieldInitializer> initializers) {
     if (!identical("=", assignmentOperator) ||
         !accessor.isThisPropertyAccessor) {
       return accessor.buildFieldInitializer(initializers);
     }
     String name = accessor.plainNameForRead;
     FieldInitializer initializer = initializers[name];
     if (initializer != null && initializer.value == null) {
       initializers.remove(name);
       initializer.value = value..parent = initializer;
       return initializer;
     }
     return accessor.buildFieldInitializer(initializers);
   }
 }
 
 class DelayedPostfixIncrement extends ContextAccessor {
   final Name binaryOperator;
 
   final Procedure interfaceTarget;
 
-  DelayedPostfixIncrement(BuilderHelper helper, int offset,
+  DelayedPostfixIncrement(BuilderHelper helper, Token token,
       FastaAccessor accessor, this.binaryOperator, this.interfaceTarget)
-      : super(helper, offset, accessor);
+      : super(helper, token, accessor);
 
   Expression buildSimpleRead() {
     return accessor.buildPostfixIncrement(binaryOperator,
-        offset: offset, voidContext: false, interfaceTarget: interfaceTarget);
+        offset: offsetForToken(token),
+        voidContext: false,
+        interfaceTarget: interfaceTarget);
   }
 
   Expression buildForEffect() {
     return accessor.buildPostfixIncrement(binaryOperator,
-        offset: offset, voidContext: true, interfaceTarget: interfaceTarget);
+        offset: offsetForToken(token),
+        voidContext: true,
+        interfaceTarget: interfaceTarget);
   }
 }
 
 class JumpTarget extends Builder {
   final List<Statement> users = <Statement>[];
 
   final JumpTargetKind kind;
 
   final int functionNestingLevel;
 
@@ skipping 210 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }