Remove accessor properties not used by Fasta.

pkg/front_end/lib/src/fasta/kernel/frontend_accessors.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.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show
         KernelArguments,
@@ skipping 25 matching lines @@
 ///
 /// For example, when building a kernel representation for `a[x] = b`, after
 /// parsing `a[x]` but before parsing `= b`, we don't yet know whether to
 /// generate an invocation of `operator[]` or `operator[]=`, so we generate an
 /// [Accessor] object.  Later, after `= b` is parsed, [buildAssignment] will be
 /// called.
 abstract class Accessor {
   final BuilderHelper helper;
   final Token token;
 
-  // [builtBinary] and [builtGetter] capture the inner nodes. Used by
-  // dart2js+rasta for determining how subexpressions map to legacy dart2js Ast
-  // nodes. This will be removed once dart2js type analysis (aka inference) is
-  // reimplemented on kernel.
-  Expression builtBinary;
-  Expression builtGetter;
-
   Accessor(this.helper, this.token);
 
   /// Builds an [Expression] representing a read from the accessor.
   Expression buildSimpleRead() {
     return _finish(_makeSimpleRead());
   }
 
   /// Builds an [Expression] representing an assignment with the accessor on
   /// the LHS and [value] on the RHS.
   ///
@@ skipping 23 matching lines @@
             _makeWrite(value, false), new VariableGet(tmp), type)));
   }
 
   /// Returns an [Expression] representing a compound assignment (e.g. `+=`)
   /// with the accessor on the LHS and [value] on the RHS.
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     return _finish(_makeWrite(
-        builtBinary = makeBinary(
-            _makeRead(), binaryOperator, interfaceTarget, value,
+        makeBinary(_makeRead(), binaryOperator, interfaceTarget, value,
             offset: offset),
         voidContext));
   }
 
   /// Returns an [Expression] representing a pre-increment or pre-decrement
   /// of the accessor.
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     return buildCompoundAssignment(binaryOperator, new IntLiteral(1),
         offset: offset,
         voidContext: voidContext,
         interfaceTarget: interfaceTarget);
   }
 
   /// Returns an [Expression] representing a post-increment or post-decrement
   /// of the accessor.
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     if (voidContext) {
       return buildPrefixIncrement(binaryOperator,
           offset: offset, voidContext: true, interfaceTarget: interfaceTarget);
     }
     var value = new VariableDeclaration.forValue(_makeRead());
     valueAccess() => new VariableGet(value);
     var dummy = new VariableDeclaration.forValue(_makeWrite(
-        builtBinary = makeBinary(
+        makeBinary(
             valueAccess(), binaryOperator, interfaceTarget, new IntLiteral(1),
             offset: offset),
         true));
     return _finish(makeLet(value, makeLet(dummy, valueAccess())));
   }
 
   Expression _makeSimpleRead() => _makeRead();
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     return _makeWrite(value, voidContext);
@@ skipping 71 matching lines @@
       ..fileOffset = offsetForToken(token);
   }
 
   receiverAccess() {
     _receiverVariable ??= new VariableDeclaration.forValue(receiver);
     return new VariableGet(_receiverVariable)
       ..fileOffset = offsetForToken(token);
   }
 
   Expression _makeRead() =>
-      builtGetter = new KernelPropertyGet(receiverAccess(), name, getter)
+      new KernelPropertyGet(receiverAccess(), name, getter)
         ..fileOffset = offsetForToken(token);
 
   Expression _makeWrite(Expression value, bool voidContext) {
     return new KernelPropertySet(receiverAccess(), name, value, setter)
       ..fileOffset = offsetForToken(token);
   }
 
   Expression _finish(Expression body) => makeLet(_receiverVariable, body);
 }
 
 /// Special case of [PropertyAccessor] to avoid creating an indirect access to
 /// 'this'.
 class ThisPropertyAccessor extends Accessor {
   Name name;
   Member getter, setter;
 
   ThisPropertyAccessor(
       BuilderHelper helper, this.name, this.getter, this.setter, Token token)
       : super(helper, token);
 
   Expression _makeRead() =>
-      builtGetter = new KernelPropertyGet(new ThisExpression(), name, getter)
+      new KernelPropertyGet(new ThisExpression(), name, getter)
         ..fileOffset = offsetForToken(token);
 
   Expression _makeWrite(Expression value, bool voidContext) {
     return new KernelPropertySet(new ThisExpression(), name, value, setter)
       ..fileOffset = offsetForToken(token);
   }
 }
 
 class NullAwarePropertyAccessor extends Accessor {
   VariableDeclaration receiver;
   Name name;
   Member getter, setter;
   DartType type;
 
   NullAwarePropertyAccessor(BuilderHelper helper, Expression receiver,
       this.name, this.getter, this.setter, this.type, Token token)
       : this.receiver = makeOrReuseVariable(receiver),
         super(helper, token);
 
   receiverAccess() => new VariableGet(receiver);
 
   Expression _makeRead() =>
-      builtGetter = new KernelPropertyGet(receiverAccess(), name, getter);
+      new KernelPropertyGet(receiverAccess(), name, getter);
 
   Expression _makeWrite(Expression value, bool voidContext) {
     return new KernelPropertySet(receiverAccess(), name, value, setter);
   }
 
   Expression _finish(Expression body) => makeLet(
       receiver,
       new ConditionalExpression(
           buildIsNull(receiverAccess()), new NullLiteral(), body, type));
 }
 
 class SuperPropertyAccessor extends Accessor {
   Name name;
   Member getter, setter;
 
   SuperPropertyAccessor(
       BuilderHelper helper, this.name, this.getter, this.setter, Token token)
       : super(helper, token);
 
   Expression _makeRead() {
     if (getter == null) return makeInvalidRead();
     // TODO(ahe): Use [DirectPropertyGet] when possible.
-    return builtGetter = new SuperPropertyGet(name, getter)
+    return new SuperPropertyGet(name, getter)
       ..fileOffset = offsetForToken(token);
   }
 
   Expression _makeWrite(Expression value, bool voidContext) {
     if (setter == null) return makeInvalidWrite(value);
     // TODO(ahe): Use [DirectPropertySet] when possible.
     return new SuperPropertySet(name, value, setter)
       ..fileOffset = offsetForToken(token);
   }
 }
@@ skipping 38 matching lines @@
     return new VariableGet(receiverVariable)
       ..fileOffset = offsetForToken(token);
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable)..fileOffset = offsetForToken(token);
   }
 
   Expression _makeRead() {
-    return builtGetter = new KernelMethodInvocation(receiverAccess(),
-        indexGetName, new KernelArguments(<Expression>[indexAccess()]), getter)
+    return new KernelMethodInvocation(receiverAccess(), indexGetName,
+        new KernelArguments(<Expression>[indexAccess()]), getter)
       ..fileOffset = offsetForToken(token);
   }
 
   Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new KernelMethodInvocation(receiverAccess(), indexSetName,
         new KernelArguments(<Expression>[indexAccess(), value]), setter)
       ..fileOffset = offsetForToken(token);
   }
 
@@ skipping 39 matching lines @@
     if (!voidContext) return _makeWriteAndReturn(value);
     return new KernelMethodInvocation(new ThisExpression(), indexSetName,
         new KernelArguments(<Expression>[index, value]), setter);
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable);
   }
 
-  Expression _makeRead() => builtGetter = new KernelMethodInvocation(
-      new ThisExpression(),
-      indexGetName,
-      new KernelArguments(<Expression>[indexAccess()]),
-      getter);
+  Expression _makeRead() => new KernelMethodInvocation(new ThisExpression(),
+      indexGetName, new KernelArguments(<Expression>[indexAccess()]), getter);
 
   Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new KernelMethodInvocation(new ThisExpression(), indexSetName,
         new KernelArguments(<Expression>[indexAccess(), value]), setter);
   }
 
   _makeWriteAndReturn(Expression value) {
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new KernelMethodInvocation(
@@ skipping 26 matching lines @@
   Expression _makeSimpleRead() => new SuperMethodInvocation(
       indexGetName, new KernelArguments(<Expression>[index]), getter);
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new SuperMethodInvocation(
         indexSetName, new KernelArguments(<Expression>[index, value]), setter);
   }
 
   Expression _makeRead() {
-    return builtGetter = new SuperMethodInvocation(
+    return new SuperMethodInvocation(
         indexGetName, new KernelArguments(<Expression>[indexAccess()]), getter);
   }
 
   Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new SuperMethodInvocation(indexSetName,
         new KernelArguments(<Expression>[indexAccess(), value]), setter);
   }
 
   _makeWriteAndReturn(Expression value) {
@@ skipping 13 matching lines @@
 }
 
 class StaticAccessor extends Accessor {
   Member readTarget;
   Member writeTarget;
 
   StaticAccessor(
       BuilderHelper helper, this.readTarget, this.writeTarget, Token token)
       : super(helper, token);
 
-  Expression _makeRead() => builtGetter = readTarget == null
+  Expression _makeRead() => readTarget == null
       ? makeInvalidRead()
       : helper.makeStaticGet(readTarget, token);
 
   Expression _makeWrite(Expression value, bool voidContext) {
     return writeTarget == null
         ? makeInvalidWrite(value)
         : new StaticSet(writeTarget, value)
       ..fileOffset = offsetForToken(token);
   }
 }
@@ skipping 40 matching lines @@
 
 VariableDeclaration makeOrReuseVariable(Expression value) {
   // TODO: Devise a way to remember if a variable declaration was reused
   // or is fresh (hence needs a let binding).
   return new VariableDeclaration.forValue(value);
 }
 
 Expression wrapInvalid(Expression e) {
   return new Let(new VariableDeclaration.forValue(e), new InvalidExpression());
 }