Create SendStructure for unary and binary in resolution.

pkg/compiler/lib/src/resolution/send_structure.dart

 // Copyright (c) 2015, 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 dart2js.send_structure;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 import '../dart_types.dart';
@@ skipping 748 matching lines @@
   }
 
   String toString() => 'set($selector,$semantics)';
 }
 
 /// The structure for a [Send] that is a negation, i.e. of the form `!e`.
 class NotStructure<R, A> implements SendStructure<R, A> {
   /// The target of the negation.
   final AccessSemantics semantics;
 
-  // TODO(johnniwinther): Should we store this?
-  final Selector selector;
-
-  NotStructure(this.semantics, this.selector);
+  NotStructure(this.semantics);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitNot(
             node,
             node.receiver,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
 
-  String toString() => 'not($selector,$semantics)';
+  String toString() => 'not($semantics)';
 }
 
 /// The structure for a [Send] that is an invocation of a user definable unary
 /// operator.
 class UnaryStructure<R, A> implements SendStructure<R, A> {
   /// The target of the unary operation.
   final AccessSemantics semantics;
 
   /// The user definable unary operator.
   final UnaryOperator operator;
 
-  // TODO(johnniwinther): Should we store this?
-  /// The [Selector] for the unary operator invocation.
-  final Selector selector;
-
-  UnaryStructure(this.semantics, this.operator, this.selector);
+  UnaryStructure(this.semantics, this.operator);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitUnary(
             node,
             operator,
             node.receiver,
             arg);
       case AccessKind.SUPER_METHOD:
@@ skipping 34 matching lines @@
 
   String toString() => 'invalid unary';
 }
 
 /// The structure for a [Send] that is an index expression, i.e. of the form
 /// `a[b]`.
 class IndexStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
-  // TODO(johnniwinther): Should we store this?
-  /// The [Selector] for the `[]` invocation.
-  final Selector selector;
-
-  IndexStructure(this.semantics, this.selector);
+  IndexStructure(this.semantics);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitIndex(
             node,
             node.receiver,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
@@ skipping 15 matching lines @@
     throw new SpannableAssertionFailure(node, "Invalid index: ${semantics}");
   }
 }
 
 /// The structure for a [Send] that is an equals test, i.e. of the form
 /// `a == b`.
 class EqualsStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
-  // TODO(johnniwinther): Should we store this?
-  /// The [Selector] for the `==` invocation.
-  final Selector selector;
-
-  EqualsStructure(this.semantics, this.selector);
+  EqualsStructure(this.semantics);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitEquals(
             node,
             node.receiver,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
@@ skipping 11 matching lines @@
 
   String toString() => '==($semantics)';
 }
 
 /// The structure for a [Send] that is a not-equals test, i.e. of the form
 /// `a != b`.
 class NotEqualsStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
-  // TODO(johnniwinther): Should we store this?
-  /// The [Selector] for the underlying `==` invocation.
-  final Selector selector;
-
-  NotEqualsStructure(this.semantics, this.selector);
+  NotEqualsStructure(this.semantics);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitNotEquals(
             node,
             node.receiver,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
@@ skipping 15 matching lines @@
 
 /// The structure for a [Send] that is an invocation of a user-definable binary
 /// operator.
 class BinaryStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
   /// The user definable binary operator.
   final BinaryOperator operator;
 
-  // TODO(johnniwinther): Should we store this?
-  /// The [Selector] for the binary operator invocation.
-  final Selector selector;
-
-  BinaryStructure(this.semantics, this.operator, this.selector);
+  BinaryStructure(this.semantics, this.operator);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitBinary(
             node,
             node.receiver,
             operator,
             node.arguments.single,
             arg);
@@ skipping 1540 matching lines @@
   final ConstructorElement constructor;
   final Selector selector;
 
   ThisConstructorInvokeStructure(this.constructor, this.selector);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, selector, arg);
   }
 }