Remove Fasta's copy of accessors.dart.

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;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
 import 'package:kernel/transformations/flags.dart' show TransformerFlag;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
+import 'package:kernel/frontend/accessors.dart'
+    show buildIsNull, makeBinary, makeLet;
+
 import '../parser/dart_vm_native.dart' show skipNativeClause;
 
 import '../scanner/token.dart'
     show BeginGroupToken, Token, isBinaryOperator, isMinusOperator;
 
 import '../errors.dart' show formatUnexpected, internalError;
 
 import '../source/scope_listener.dart'
     show JumpTargetKind, NullValue, ScopeListener;
 
 import '../builder/scope.dart' show ProblemBuilder, Scope;
 
 import '../source/outline_builder.dart' show asyncMarkerFromTokens;
 
 import 'builder_accessors.dart';
 
-import 'frontend_accessors.dart' show buildIsNull, makeBinary, makeLet;
-
 import '../quote.dart'
     show
         Quote,
         analyzeQuote,
         unescape,
         unescapeFirstStringPart,
         unescapeLastStringPart,
         unescapeString;
 
 import '../modifier.dart' show Modifier, constMask, finalMask;
@@ skipping 539 matching lines @@
     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, token.charOffset);
+          makeBinary(a, new Name(operator), null, b, offset: token.charOffset);
       if (isSuper) {
         result = toSuperMethodInvocation(result);
       }
       return negate ? new Not(result) : result;
     }
   }
 
   void doLogicalExpression(Token token) {
     Expression argument = popForValue();
     Expression receiver = popForValue();
@@ skipping 939 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.charOffset, index,
+      push(new SuperIndexAccessor(this, receiver.offset, index,
           lookupSuperMember(indexGetName), lookupSuperMember(indexSetName)));
     } else {
       push(IndexAccessor.make(this, openCurlyBracket.charOffset,
           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.charOffset,
+            new ThisExpression()..fileOffset = receiver.offset,
             new Name(operator),
             new Arguments.empty(),
             token.charOffset)));
       } else {
         push(buildMethodInvocation(toValue(receiver), new Name(operator),
             new Arguments.empty(), token.charOffset));
       }
     }
   }
 
   Name incrementOperator(Token token) {
     if (optional("++", token)) return plusName;
     if (optional("--", token)) return minusName;
     return internalError("Unknown increment operator: ${token.lexeme}");
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
     if (accessor is BuilderAccessor) {
-      push(accessor.buildPrefixIncrement(
-          incrementOperator(token), token.charOffset));
+      push(accessor.buildPrefixIncrement(incrementOperator(token),
+          offset: token.charOffset));
     } else {
       push(wrapInvalid(toValue(accessor)));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
     if (accessor is BuilderAccessor) {
@@ skipping 866 matching lines @@
   void finalize(Expression expression) {
     assert(nextCascade.variable.initializer is InvalidExpression);
     nextCascade.variable.initializer = expression;
     expression.parent = nextCascade.variable;
   }
 }
 
 abstract class ContextAccessor extends BuilderAccessor {
   final BuilderHelper helper;
 
-  final int charOffset;
-
   final BuilderAccessor accessor;
 
-  ContextAccessor(this.helper, this.charOffset, this.accessor);
+  final int offset;
+
+  ContextAccessor(this.helper, this.offset, this.accessor);
+
+  @override
+  Expression get builtBinary => internalError("Unsupported operation.");
+
+  @override
+  void set builtBinary(Expression expression) {
+    internalError("Unsupported operation.");
+  }
+
+  @override
+  Expression get builtGetter => internalError("Unsupported operation.");
+
+  @override
+  void set builtGetter(Expression expression) {
+    internalError("Unsupported operation.");
+  }
 
   String get plainNameForRead => internalError("Unsupported operation.");
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     return internalError("Unhandled: ${runtimeType}", uri, charOffset);
   }
 
   Expression buildSimpleRead();
 
   Expression buildForEffect();
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return makeInvalidWrite(value);
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return makeInvalidWrite(value);
   }
 
-  Expression buildCompoundAssignment(
-      Name binaryOperator, Expression value, int charOffset,
-      {bool voidContext: false, Procedure interfaceTarget}) {
+  Expression buildCompoundAssignment(Name binaryOperator, Expression value,
+      {int offset: TreeNode.noOffset,
+      bool voidContext: false,
+      Procedure interfaceTarget}) {
     return makeInvalidWrite(value);
   }
 
-  Expression buildPrefixIncrement(Name binaryOperator, int charOffset,
-      {bool voidContext: false, Procedure interfaceTarget}) {
+  Expression buildPrefixIncrement(Name binaryOperator,
+      {int offset: TreeNode.noOffset,
+      bool voidContext: false,
+      Procedure interfaceTarget}) {
     return makeInvalidWrite(null);
   }
 
-  Expression buildPostfixIncrement(Name binaryOperator, int charOffset,
-      {bool voidContext: false, Procedure interfaceTarget}) {
+  Expression buildPostfixIncrement(Name binaryOperator,
+      {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.", charOffset);
+        "Can't be used as left-hand side of assignment.", offset);
   }
 }
 
 class DelayedAssignment extends ContextAccessor {
   final Expression value;
 
   final String assignmentOperator;
 
   DelayedAssignment(BuilderHelper helper, int charOffset,
       BuilderAccessor accessor, this.value, this.assignmentOperator)
       : super(helper, charOffset, 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, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(plusName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("-=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(minusName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(minusName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("*=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(multiplyName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(multiplyName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("%=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(percentName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(percentName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("&=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(ampersandName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(ampersandName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("/=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(divisionName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(divisionName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("<<=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(leftShiftName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(leftShiftName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical(">>=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(rightShiftName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(rightShiftName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("??=", assignmentOperator)) {
       return accessor.buildNullAwareAssignment(value, const DynamicType(),
           voidContext: voidContext);
     } else if (identical("^=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(caretName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(caretName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("|=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(barName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(barName, value,
+          offset: offset, voidContext: voidContext);
     } else if (identical("~/=", assignmentOperator)) {
-      return accessor.buildCompoundAssignment(mustacheName, value, charOffset,
-          voidContext: voidContext);
+      return accessor.buildCompoundAssignment(mustacheName, value,
+          offset: offset, 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 charOffset,
+  DelayedPostfixIncrement(BuilderHelper helper, int offset,
       BuilderAccessor accessor, this.binaryOperator, this.interfaceTarget)
-      : super(helper, charOffset, accessor);
+      : super(helper, offset, accessor);
 
   Expression buildSimpleRead() {
-    return accessor.buildPostfixIncrement(binaryOperator, charOffset,
-        voidContext: false, interfaceTarget: interfaceTarget);
+    return accessor.buildPostfixIncrement(binaryOperator,
+        offset: offset, voidContext: false, interfaceTarget: interfaceTarget);
   }
 
   Expression buildForEffect() {
-    return accessor.buildPostfixIncrement(binaryOperator, charOffset,
-        voidContext: true, interfaceTarget: interfaceTarget);
+    return accessor.buildPostfixIncrement(binaryOperator,
+        offset: offset, voidContext: true, interfaceTarget: interfaceTarget);
   }
 }
 
 class JumpTarget extends Builder {
   final List<Statement> users = <Statement>[];
 
   final JumpTargetKind kind;
 
   final int functionNestingLevel;
 
@@ skipping 212 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}");
   }
 }