Implement ResolvedVisitor using SemanticSendVisitor.

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 '../tree/tree.dart';
@@ skipping 13 matching lines @@
 /// The structure for a [Send] of the form `assert(e)`.
 class AssertStructure<R, A> implements SendStructure<R, A> {
   const AssertStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitAssert(
         node,
         node.arguments.single,
         arg);
   }
+
+  String toString() => 'assert';
 }
 
 /// The structure for a [Send] of the form an `assert` with less or more than
 /// one argument.
 class InvalidAssertStructure<R, A> implements SendStructure<R, A> {
   const InvalidAssertStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.errorInvalidAssert(
         node,
         node.argumentsNode,
         arg);
   }
+
+  String toString() => 'invalid assert';
 }
 
 /// The structure for a [Send] of the form `a && b`.
 class LogicalAndStructure<R, A> implements SendStructure<R, A> {
   const LogicalAndStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitLogicalAnd(
         node,
         node.receiver,
         node.arguments.single,
         arg);
   }
+
+  String toString() => '&&';
 }
 
 /// The structure for a [Send] of the form `a || b`.
 class LogicalOrStructure<R, A> implements SendStructure<R, A> {
   const LogicalOrStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitLogicalOr(
         node,
         node.receiver,
         node.arguments.single,
         arg);
   }
+
+  String toString() => '||';
 }
 
 /// The structure for a [Send] of the form `a is T`.
 class IsStructure<R, A> implements SendStructure<R, A> {
   /// The type that the expression is tested against.
   final DartType type;
 
   IsStructure(this.type);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitIs(
         node,
         node.receiver,
         type,
         arg);
   }
+
+  String toString() => 'is $type';
 }
 
 /// The structure for a [Send] of the form `a is! T`.
 class IsNotStructure<R, A> implements SendStructure<R, A> {
   /// The type that the expression is tested against.
   final DartType type;
 
   IsNotStructure(this.type);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitIsNot(
         node,
         node.receiver,
         type,
         arg);
   }
+
+  String toString() => 'is! $type';
 }
 
 /// The structure for a [Send] of the form `a as T`.
 class AsStructure<R, A> implements SendStructure<R, A> {
   /// The type that the expression is cast to.
   final DartType type;
 
   AsStructure(this.type);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitAs(
         node,
         node.receiver,
         type,
         arg);
   }
+
+  String toString() => 'as $type';
 }
 
 /// The structure for a [Send] that is an invocation.
 class InvokeStructure<R, A> implements SendStructure<R, A> {
   /// The target of the invocation.
   final AccessSemantics semantics;
 
   /// The [Selector] for the invocation.
   final Selector selector;
 
@@ skipping 179 matching lines @@
             semantics.element,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid invoke: ${semantics}");
   }
+
+  String toString() => 'invoke($selector,$semantics)';
 }
 
 /// The structure for a [Send] that is a read access.
 class GetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the read access.
   final AccessSemantics semantics;
 
   /// The [Selector] for the getter invocation.
   final Selector selector;
 
@@ skipping 122 matching lines @@
         return visitor.errorUnresolvedGet(
             node,
             semantics.element,
             arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid getter: ${semantics}");
   }
+
+  String toString() => 'get($selector,$semantics)';
 }
 
 /// The structure for a [Send] that is an assignment.
 class SetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the assignment.
   final AccessSemantics semantics;
 
   /// The [Selector] for the setter invocation.
   final Selector selector;
 
@@ skipping 142 matching lines @@
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
+
+  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);
 
   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)';
 }
 
 /// 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;
@@ skipping 23 matching lines @@
             node,
             operator,
             semantics.element,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
   }
+
+  String toString() => 'unary($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is an invocation of a undefined unary
 /// operator.
 class InvalidUnaryStructure<R, A> implements SendStructure<R, A> {
   const InvalidUnaryStructure();
 
   @override
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.errorUndefinedUnaryExpression(
         node,
         node.selector,
         node.receiver,
         arg);
   }
+
+  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.
@@ skipping 54 matching lines @@
             node,
             semantics.element,
             node.arguments.single,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid equals: ${semantics}");
   }
+
+  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.
@@ skipping 15 matching lines @@
             semantics.element,
             node.arguments.single,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid not equals: ${semantics}");
   }
+
+  String toString() => '!=($semantics)';
 }
 
 /// 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;
@@ skipping 27 matching lines @@
             operator,
             node.arguments.single,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid binary: ${semantics}");
   }
+
+  String toString() => 'binary($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is an invocation of a undefined binary
 /// operator.
 class InvalidBinaryStructure<R, A> implements SendStructure<R, A> {
   const InvalidBinaryStructure();
 
   @override
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.errorUndefinedBinaryExpression(
         node,
         node.receiver,
         node.selector,
         node.arguments.single,
         arg);
   }
+
+  String toString() => 'invalid binary';
 }
 
 /// The structure for a [Send] that is of the form `a[b] = c`.
 class IndexSetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the index set operation.
   final AccessSemantics semantics;
 
   // TODO(johnniwinther): Should we store this?
   /// The [Selector] for the `[]=` operator invocation.
   final Selector selector;
@@ skipping 23 matching lines @@
             node.arguments.first,
             node.arguments.tail.head,
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid index set: ${semantics}");
   }
+
+  String toString() => '[]=($semantics)';
 }
 
 /// The structure for a [Send] that is an prefix operation on an index
 /// expression, i.e. of the form `--a[b]`.
 class IndexPrefixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
   /// The `++` or `--` operator used in the operation.
   final IncDecOperator operator;
@@ skipping 336 matching lines @@
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
         }
         break;
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
+
+  String toString() => 'compound($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is a compound assignment on the index
 /// operator. For instance `a[b] += c`.
 class CompoundIndexSetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the index operations.
   final AccessSemantics semantics;
 
   /// The assignment operator used in the compound assignment.
   final AssignmentOperator operator;
@@ skipping 43 matching lines @@
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid compound index set: ${semantics}");
   }
+
+  String toString() => 'compound []=($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is a prefix operations. For instance
 /// `++a`.
 class PrefixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the prefix operation.
   final AccessSemantics semantics;
 
   /// The `++` or `--` operator used in the operation.
   final IncDecOperator operator;
@@ skipping 192 matching lines @@
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
+
+  String toString() => 'prefix($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is a postfix operations. For instance
 /// `a++`.
 class PostfixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the postfix operation.
   final AccessSemantics semantics;
 
   /// The `++` or `--` operator used in the operation.
   final IncDecOperator operator;
@@ skipping 192 matching lines @@
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
+
+  String toString() => 'postfix($operator,$semantics)';
 }