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;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:front_end/src/fasta/builder/ast_factory.dart' show AstFactory;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelField;
 
+import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
+
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
     show FieldNode;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
     show TypePromoter;
 
 import 'package:kernel/ast.dart';
@@ skipping 208 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 177 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));
+      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));
+      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
-  /// problems. [isQualified] should be true if [name] is a qualified access
+  /// Look up [name] in [scope] using [token] as location information (both to
+  /// report problems and as the file offset in the generated kernel code).
+  /// [isQualified] should be true if [name] is a qualified access
   /// (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 34 matching lines @@
     Statement thenPart = popStatement();
     Expression condition = popForValue();
     typePromoter.exitConditional();
     push(astFactory.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, functionNestingLevel,
+        identifier.name, identifier.token, functionNestingLevel,
         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 220 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 44 matching lines @@
     push(new AsExpression(expression, type)..fileOffset = operator.charOffset);
   }
 
   @override
   void handleIsOperator(Token operator, Token not, Token endToken) {
     debugEvent("IsOperator");
     DartType type = pop();
     Expression operand = popForValue();
     bool isInverted = not != null;
     Expression isExpression =
-        astFactory.isExpression(operand, type, operator.charOffset, isInverted);
+        astFactory.isExpression(operand, type, operator, isInverted);
     if (operand is VariableGet) {
       typePromoter.handleIsCheck(isExpression, isInverted, operand.variable,
           type, functionNestingLevel);
     }
     push(isExpression);
   }
 
   @override
   void handleConditionalExpression(Token question, Token colon) {
     debugEvent("ConditionalExpression");
@@ skipping 53 matching lines @@
         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, functionNestingLevel,
+            name.name, name.token, functionNestingLevel,
             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, functionNestingLevel,
+        name.name, name.token, functionNestingLevel,
         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, functionNestingLevel,
+        name.name, name.token, functionNestingLevel,
         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() {
@@ skipping 60 matching lines @@
     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)
       ..fileOffset = beginToken.charOffset
       ..fileEndOffset = token.charOffset);
-    push(astFactory.functionExpression(function, beginToken.charOffset));
+    push(astFactory.functionExpression(function, beginToken));
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
     debugEvent("DoWhileStatement");
     Expression condition = popForValue();
     Statement body = popStatement();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
@@ skipping 209 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 123 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);
   }
 }
 
 class Identifier {
-  final String name;
-  final int fileOffset;
+  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}");
   }
 }