Remove Fasta's copy of accessors.dart.

pkg/analyzer/lib/src/kernel/ast_from_analyzer.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 kernel.analyzer.ast_from_analyzer;
 
 import 'package:kernel/ast.dart' as ast;
 import 'package:kernel/frontend/accessors.dart';
 import 'package:kernel/frontend/super_initializers.dart';
 import 'package:kernel/log.dart';
 import 'package:kernel/type_algebra.dart';
@@ skipping 1399 matching lines @@
       return node.leftBracket.offset;
     }
     return node.offset;
   }
 
   Accessor buildLeftHandValue(Expression node) {
     var result = node.accept(this);
     if (result is Accessor) {
       return result;
     } else {
-      return new ReadOnlyAccessor(result);
+      return new ReadOnlyAccessor(result, ast.TreeNode.noOffset);
     }
   }
 
   ast.Expression visitAsExpression(AsExpression node) {
     return new ast.AsExpression(
         build(node.expression), scope.buildTypeAnnotation(node.type));
   }
 
   ast.Expression visitAssignmentExpression(AssignmentExpression node) {
     bool voidContext = isInVoidContext(node);
@@ skipping 289 matching lines @@
             scope.resolveInterfaceSet(element, auxiliary));
 
       case ElementKind.FUNCTION:
         FunctionElement function = element;
         if (isTopLevelFunction(function)) {
           return scope.staticAccess(node.name, function);
         }
         if (function == function.library.loadLibraryFunction) {
           return scope.unsupportedFeature('Deferred loading');
         }
-        return new VariableAccessor(scope.getVariableReference(function));
+        return new VariableAccessor(
+            scope.getVariableReference(function), null, ast.TreeNode.noOffset);
 
       case ElementKind.LOCAL_VARIABLE:
       case ElementKind.PARAMETER:
         VariableElement variable = element;
         var type = identical(node.staticType, variable.type)
             ? null
             : scope.buildType(node.staticType);
-        return new VariableAccessor(scope.getVariableReference(element), type);
+        return new VariableAccessor(
+            scope.getVariableReference(element), type, ast.TreeNode.noOffset);
 
       case ElementKind.IMPORT:
       case ElementKind.LIBRARY:
       case ElementKind.PREFIX:
         return scope.emitCompileTimeError(
             CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
             [node.name]);
 
       case ElementKind.COMPILATION_UNIT:
       case ElementKind.CONSTRUCTOR:
@@ skipping 13 matching lines @@
       return IndexAccessor.make(
           makeCascadeReceiver(),
           build(node.index),
           scope.resolveInterfaceIndexGet(element, auxiliary),
           scope.resolveInterfaceIndexSet(element, auxiliary));
     } else if (node.target is SuperExpression) {
       scope.addTransformerFlag(TransformerFlag.superCalls);
       return new SuperIndexAccessor(
           build(node.index),
           scope.resolveConcreteIndexGet(element, auxiliary),
-          scope.resolveConcreteIndexSet(element, auxiliary));
+          scope.resolveConcreteIndexSet(element, auxiliary),
+          ast.TreeNode.noOffset);
     } else {
       return IndexAccessor.make(
           build(node.target),
           build(node.index),
           scope.resolveInterfaceIndexGet(element, auxiliary),
           scope.resolveInterfaceIndexSet(element, auxiliary));
     }
   }
 
   /// Follows any number of redirecting factories, returning the effective
@@ skipping 299 matching lines @@
     var setter = scope.resolveInterfaceSet(element, auxiliary);
     Expression target = node.target;
     if (node.isCascaded) {
       return PropertyAccessor.make(makeCascadeReceiver(),
           scope.buildName(node.propertyName), getter, setter);
     } else if (node.target is SuperExpression) {
       scope.addTransformerFlag(TransformerFlag.superCalls);
       return new SuperPropertyAccessor(
           scope.buildName(node.propertyName),
           scope.resolveConcreteGet(element, auxiliary),
-          scope.resolveConcreteSet(element, auxiliary));
+          scope.resolveConcreteSet(element, auxiliary),
+          ast.TreeNode.noOffset);
     } else if (target is Identifier && target.staticElement is ClassElement) {
       // Note that this case also covers null-aware static access on a class,
       // which is equivalent to a regular static access.
       return scope.staticAccess(node.propertyName.name, element, auxiliary);
     } else if (node.operator.value() == '?.') {
       return new NullAwarePropertyAccessor(
           build(target),
           scope.buildName(node.propertyName),
           getter,
           setter,
-          scope.buildType(node.staticType));
+          scope.buildType(node.staticType),
+          ast.TreeNode.noOffset);
     } else {
       return PropertyAccessor.make(
           build(target), scope.buildName(node.propertyName), getter, setter);
     }
   }
 
   ast.Expression visitRethrowExpression(RethrowExpression node) {
     return new ast.Rethrow();
   }
 
@@ skipping 883 matching lines @@
 }
 
 /// A [StaticAccessor] that throws a NoSuchMethodError when a suitable target
 /// could not be resolved.
 class _StaticAccessor extends StaticAccessor {
   final ExpressionScope scope;
   final String name;
 
   _StaticAccessor(
       this.scope, this.name, ast.Member readTarget, ast.Member writeTarget)
-      : super(readTarget, writeTarget);
+      : super(readTarget, writeTarget, ast.TreeNode.noOffset);
 
   @override
   makeInvalidRead() {
     return scope.buildThrowNoSuchMethodError(
         new ast.NullLiteral(), name, new ast.Arguments([]));
   }
 
   @override
   makeInvalidWrite(ast.Expression value) {
     return scope.buildThrowNoSuchMethodError(
@@ skipping 55 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }