Add kinds for serialization.

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.resolution.send_structure;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 
 /// Interface for the structure of the semantics of a [Send] or [NewExpression]
 /// node.
 abstract class SemanticSendStructure<R, A> {
   /// Calls the matching visit method on [visitor] with [node] and [arg].
   R dispatch(SemanticSendVisitor<R, A> visitor, Node node, A arg);
 }
 
+enum SendStructureKind {
+  IF_NULL,
+  LOGICAL_AND,
+  LOGICAL_OR,
+  IS,
+  IS_NOT,
+  AS,
+  INVOKE,
+  INCOMPATIBLE_INVOKE,
+  GET,
+  SET,
+  NOT,
+  UNARY,
+  INVALID_UNARY,
+  INDEX,
+  EQUALS,
+  NOT_EQUALS,
+  BINARY,
+  INVALID_BINARY,
+  INDEX_SET,
+  INDEX_PREFIX,
+  INDEX_POSTFIX,
+  COMPOUND,
+  SET_IF_NULL,
+  COMPOUND_INDEX_SET,
+  INDEX_SET_IF_NULL,
+  PREFIX,
+  POSTFIX,
+  DEFERRED_PREFIX,
+}
+
 /// Interface for the structure of the semantics of a [Send] node.
 ///
 /// Subclasses handle each of the [Send] variations; `assert(e)`, `a && b`,
 /// `a.b`, `a.b(c)`, etc.
 abstract class SendStructure<R, A> extends SemanticSendStructure<R, A> {
   /// Calls the matching visit method on [visitor] with [send] and [arg].
   R dispatch(SemanticSendVisitor<R, A> visitor, Send send, A arg);
+
+  SendStructureKind get kind;
 }
 
 /// The structure for a [Send] of the form `a ?? b`.
 class IfNullStructure<R, A> implements SendStructure<R, A> {
   const IfNullStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitIfNull(node, node.receiver, node.arguments.single, arg);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.IF_NULL;
+
   String toString() => '??';
 }
 
 /// 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);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.LOGICAL_AND;
+
   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);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.LOGICAL_OR;
+
   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);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.IS;
+
   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);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.IS_NOT;
+
   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);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.AS;
+
   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.
   // TODO(johnniwinther): Store this only for dynamic invocations.
   final Selector selector;
 
   /// The [CallStructure] of the invocation.
   // TODO(johnniwinther): Store this directly for static invocations.
   CallStructure get callStructure => selector.callStructure;
 
   InvokeStructure(this.semantics, this.selector);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INVOKE;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY:
         return visitor.visitIfNotNullDynamicPropertyInvoke(
             node, node.receiver, node.argumentsNode, selector, arg);
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyInvoke(
             node, node.receiver, node.argumentsNode, selector, arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionInvoke(
@@ skipping 115 matching lines @@
   /// The [Selector] for the invocation.
   // TODO(johnniwinther): Store this only for dynamic invocations.
   final Selector selector;
 
   /// The [CallStructure] of the invocation.
   // TODO(johnniwinther): Store this directly for static invocations.
   CallStructure get callStructure => selector.callStructure;
 
   IncompatibleInvokeStructure(this.semantics, this.selector);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INCOMPATIBLE_INVOKE;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.STATIC_METHOD:
         return visitor.visitStaticFunctionIncompatibleInvoke(
             node, semantics.element, node.argumentsNode, callStructure, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperMethodIncompatibleInvoke(
             node, semantics.element, node.argumentsNode, callStructure, arg);
       case AccessKind.TOPLEVEL_METHOD:
         return visitor.visitTopLevelFunctionIncompatibleInvoke(
@@ skipping 12 matching lines @@
   String toString() => 'incompatible-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;
 
   GetStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.GET;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY:
         return visitor.visitIfNotNullDynamicPropertyGet(
             node, node.receiver, semantics.name, arg);
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyGet(
             node, node.receiver, semantics.name, arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionGet(node, semantics.element, arg);
@@ skipping 67 matching lines @@
   String toString() => 'get($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;
 
   SetStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.SET;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY:
         return visitor.visitIfNotNullDynamicPropertySet(
             node, node.receiver, semantics.name, node.arguments.single, arg);
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertySet(
             node, node.receiver, semantics.name, node.arguments.single, arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionSet(
@@ skipping 99 matching lines @@
 }
 
 /// The structure for a [Send] that is a negation, i.e. of the form `!e`.
 class NotStructure<R, A> implements SendStructure<R, A> {
   const NotStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitNot(node, node.receiver, arg);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.NOT;
+
   String toString() => 'not()';
 }
 
 /// 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;
 
   UnaryStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.UNARY;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitUnary(node, operator, node.receiver, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperUnary(node, operator, semantics.element, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperUnary(
             node, operator, semantics.element, arg);
       case AccessKind.INVALID:
@@ skipping 13 matching lines @@
 /// 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);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INVALID_UNARY;
+
   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;
 
   IndexStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INDEX;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitIndex(
             node, node.receiver, node.arguments.single, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperIndex(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndex(
@@ skipping 10 matching lines @@
 }
 
 /// 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;
 
   EqualsStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.EQUALS;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitEquals(
             node, node.receiver, node.arguments.single, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperEquals(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidEquals(
             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;
 
   NotEqualsStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.NOT_EQUALS;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitNotEquals(
             node, node.receiver, node.arguments.single, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperNotEquals(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidNotEquals(
@@ skipping 13 matching lines @@
 /// 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;
 
   BinaryStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.BINARY;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitBinary(
             node, node.receiver, operator, node.arguments.single, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperBinary(
             node, semantics.element, operator, node.arguments.single, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperBinary(
@@ skipping 15 matching lines @@
 /// 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);
   }
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INVALID_BINARY;
+
   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;
 
   IndexSetStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INDEX_SET;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitIndexSet(node, node.receiver, node.arguments.first,
             node.arguments.tail.head, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperIndexSet(node, semantics.element,
             node.arguments.first, node.arguments.tail.head, arg);
       case AccessKind.UNRESOLVED_SUPER:
       case AccessKind.UNRESOLVED:
@@ skipping 17 matching lines @@
 /// 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;
 
   IndexPrefixStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INDEX_PREFIX;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitIndexPrefix(
             node, node.receiver, node.arguments.single, operator, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndexPrefix(
             node, semantics.element, node.arguments.single, operator, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidIndexPrefix(
@@ skipping 38 matching lines @@
 /// expression, i.e. of the form `a[b]++`.
 class IndexPostfixStructure<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;
 
   IndexPostfixStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INDEX_POSTFIX;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitIndexPostfix(
             node, node.receiver, node.arguments.single, operator, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndexPostfix(
             node, semantics.element, node.arguments.single, operator, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidIndexPostfix(
@@ skipping 43 matching lines @@
 /// `a += b`.
 class CompoundStructure<R, A> implements SendStructure<R, A> {
   /// The target of the compound assignment, i.e. the left-hand side.
   final AccessSemantics semantics;
 
   /// The assignment operator used in the compound assignment.
   final AssignmentOperator operator;
 
   CompoundStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.COMPOUND;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY:
         return visitor.visitIfNotNullDynamicPropertyCompound(
             node,
             node.receiver,
             semantics.name,
             operator,
             node.arguments.single,
             arg);
@@ skipping 227 matching lines @@
 }
 
 /// The structure for a [Send] that is an if-null assignment. For instance
 /// `a ??= b`.
 class SetIfNullStructure<R, A> implements SendStructure<R, A> {
   /// The target of the if-null assignment, i.e. the left-hand side.
   final AccessSemantics semantics;
 
   SetIfNullStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.SET_IF_NULL;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY:
         return visitor.visitIfNotNullDynamicPropertySetIfNull(
             node, node.receiver, semantics.name, node.arguments.single, arg);
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertySetIfNull(
             node, node.receiver, semantics.name, node.arguments.single, arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionSetIfNull(
@@ skipping 210 matching lines @@
 /// 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;
 
   CompoundIndexSetStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.COMPOUND_INDEX_SET;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitCompoundIndexSet(node, node.receiver,
             node.arguments.first, operator, node.arguments.tail.head, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperCompoundIndexSet(
             node,
             semantics.element,
             node.arguments.first,
@@ skipping 50 matching lines @@
 }
 
 /// The structure for a [Send] that is a if-null assignment on the index
 /// operator. For instance `a[b] ??= c`.
 class IndexSetIfNullStructure<R, A> implements SendStructure<R, A> {
   /// The target of the index operations.
   final AccessSemantics semantics;
 
   IndexSetIfNullStructure(this.semantics);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.INDEX_SET;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitIndexSetIfNull(node, node.receiver,
             node.arguments.first, node.arguments.tail.head, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndexSetIfNull(
             node,
             semantics.element,
             node.arguments.first,
@@ skipping 49 matching lines @@
 /// `++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;
 
   PrefixStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.PREFIX;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY:
         return visitor.visitIfNotNullDynamicPropertyPrefix(
             node, node.receiver, semantics.name, operator, arg);
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyPrefix(
             node, node.receiver, semantics.name, operator, arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionPrefix(
@@ skipping 216 matching lines @@
 /// `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;
 
   PostfixStructure(this.semantics, this.operator);
 
+  @override
+  SendStructureKind get kind => SendStructureKind.POSTFIX;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY:
         return visitor.visitIfNotNullDynamicPropertyPostfix(
             node, node.receiver, semantics.name, operator, arg);
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyPostfix(
             node, node.receiver, semantics.name, operator, arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionPostfix(
@@ skipping 214 matching lines @@
   /// The send structure for the whole [Send] node. For instance a
   /// [GetStructure] for `deferred.a` where `a` is a top level member of the
   /// deferred library.
   final SendStructure sendStructure;
 
   DeferredPrefixStructure(this.prefix, this.sendStructure) {
     assert(sendStructure != null);
   }
 
   @override
+  SendStructureKind get kind => SendStructureKind.DEFERRED_PREFIX;
+
+  @override
   R dispatch(SemanticSendVisitor<R, A> visitor, Send send, A arg) {
     visitor.previsitDeferredAccess(send, prefix, arg);
     return sendStructure.dispatch(visitor, send, arg);
   }
 }
 
+enum NewStructureKind { NEW_INVOKE, CONST_INVOKE, LATE_CONST, }
+
 /// The structure for a [NewExpression] of a new invocation.
 abstract class NewStructure<R, A> implements SemanticSendStructure<R, A> {
   /// Calls the matching visit method on [visitor] with [node] and [arg].
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg);
+
+  NewStructureKind get kind;
 }
 
 /// The structure for a [NewExpression] of a new invocation. For instance
 /// `new C()`.
 class NewInvokeStructure<R, A> extends NewStructure<R, A> {
   final ConstructorAccessSemantics semantics;
   final Selector selector;
 
   NewInvokeStructure(this.semantics, this.selector);
 
+  @override
+  NewStructureKind get kind => NewStructureKind.NEW_INVOKE;
+
   CallStructure get callStructure => selector.callStructure;
 
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg) {
     switch (semantics.kind) {
       case ConstructorAccessKind.GENERATIVE:
         ConstructorElement constructor = semantics.element;
         if (constructor.isRedirectingGenerative) {
           return visitor.visitRedirectingGenerativeConstructorInvoke(
               node,
               constructor,
@@ skipping 92 matching lines @@
 enum ConstantInvokeKind {
   CONSTRUCTED,
   BOOL_FROM_ENVIRONMENT,
   INT_FROM_ENVIRONMENT,
   STRING_FROM_ENVIRONMENT,
 }
 
 /// The structure for a [NewExpression] of a constant invocation. For instance
 /// `const C()`.
 class ConstInvokeStructure<R, A> extends NewStructure<R, A> {
-  final ConstantInvokeKind kind;
+  final ConstantInvokeKind constantInvokeKind;
   final ConstantExpression constant;
 
-  ConstInvokeStructure(this.kind, this.constant);
+  ConstInvokeStructure(this.constantInvokeKind, this.constant);
+
+  @override
+  NewStructureKind get kind => NewStructureKind.CONST_INVOKE;
 
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg) {
-    switch (kind) {
+    switch (constantInvokeKind) {
       case ConstantInvokeKind.CONSTRUCTED:
         return visitor.visitConstConstructorInvoke(node, constant, arg);
       case ConstantInvokeKind.BOOL_FROM_ENVIRONMENT:
         return visitor.visitBoolFromEnvironmentConstructorInvoke(
             node, constant, arg);
       case ConstantInvokeKind.INT_FROM_ENVIRONMENT:
         return visitor.visitIntFromEnvironmentConstructorInvoke(
             node, constant, arg);
       case ConstantInvokeKind.STRING_FROM_ENVIRONMENT:
         return visitor.visitStringFromEnvironmentConstructorInvoke(
             node, constant, arg);
     }
   }
 }
 
 /// A constant constructor invocation that couldn't be determined fully during
 /// resolution.
 // TODO(johnniwinther): Remove this when all constants are computed during
 // resolution.
 class LateConstInvokeStructure<R, A> extends NewStructure<R, A> {
   final TreeElements elements;
 
   LateConstInvokeStructure(this.elements);
 
+  @override
+  NewStructureKind get kind => NewStructureKind.LATE_CONST;
+
   /// Convert this new structure into a regular new structure using the data
   /// available in [elements].
   NewStructure resolve(NewExpression node) {
     Element element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
     DartType type = elements.getType(node);
     ConstantExpression constant = elements.getConstant(node);
     if (element.isMalformed ||
         constant == null ||
         constant.kind == ConstantExpressionKind.ERRONEOUS) {
@@ skipping 267 matching lines @@
   ThisConstructorInvokeStructure(
       this.node, this.constructor, this.callStructure);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, callStructure, arg);
   }
 
   bool get isConstructorInvoke => true;
 }