Revert "Handle SendSet and NewExpression through NewResolvedVisitor."

pkg/compiler/lib/src/resolved_visitor.dart

 // Copyright (c) 2012, 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.
 
 part of dart2js;
 
 /// Enum for the visit methods added in [ResolvedVisitor].
 // TODO(johnniwinther): Remove this.
 enum ResolvedKind {
   ASSERT,
   TYPE_LITERAL,
   SUPER,
   OPERATOR,
   TYPE_PREFIX,
   GETTER,
   STATIC,
   CLOSURE,
   DYNAMIC,
   ERROR,
-  SEND_SET,
-  NEW,
 }
 
 /// Abstract interface for a [ResolvedVisitor].
 // TODO(johnniwinther): Remove this.
 abstract class ResolvedKindVisitor<R> {
   R visitSuperSend(Send node);
   R visitOperatorSend(Send node);
   R visitGetterSend(Send node);
   R visitClosureSend(Send node);
   R visitDynamicSend(Send node);
   R visitStaticSend(Send node);
-  R handleSendSet(SendSet node);
-  R handleNewExpression(NewExpression node);
 
   /// Visitor callback for a type literal.
   R visitTypeLiteralSend(Send node);
 
   /// Visitor callback for the class prefix of a static access, like `Foo` in
   /// `Foo.staticField`.
   // TODO(johnniwinther): Remove this when not needed by the dart backend.
   R visitTypePrefixSend(Send node);
 
   R visitAssertSend(Send node);
 
   internalError(Spannable node, String reason);
 }
 
 /// Visitor that returns the [ResolvedKind] corresponding to the called visitor
 /// method.
 class ResolvedKindComputer implements ResolvedKindVisitor {
   const ResolvedKindComputer();
 
   ResolvedKind visitSuperSend(Send node) => ResolvedKind.SUPER;
   ResolvedKind visitOperatorSend(Send node) => ResolvedKind.OPERATOR;
   ResolvedKind visitGetterSend(Send node) => ResolvedKind.GETTER;
   ResolvedKind visitClosureSend(Send node) => ResolvedKind.CLOSURE;
   ResolvedKind visitDynamicSend(Send node) => ResolvedKind.DYNAMIC;
   ResolvedKind visitStaticSend(Send node) => ResolvedKind.STATIC;
   ResolvedKind visitTypeLiteralSend(Send node) => ResolvedKind.TYPE_LITERAL;
   ResolvedKind visitTypePrefixSend(Send node) => ResolvedKind.TYPE_PREFIX;
   ResolvedKind visitAssertSend(Send node) => ResolvedKind.ASSERT;
-  ResolvedKind handleSendSet(SendSet node) => ResolvedKind.SEND_SET;
-  ResolvedKind handleNewExpression(NewExpression node) => ResolvedKind.NEW;
   internalError(Spannable node, String reason) => ResolvedKind.ERROR;
 }
 
 abstract class ResolvedVisitor<R>
     implements Visitor<R>, ResolvedKindVisitor<R> {}
 
 abstract class BaseResolvedVisitor<R> extends Visitor<R>
     implements ResolvedVisitor<R> {
 
   TreeElements elements;
@@ skipping 54 matching lines @@
 }
 
 // TODO(johnniwinther): Remove this. Currently need by the old dart2dart
 // backend.
 abstract class OldResolvedVisitor<R> extends BaseResolvedVisitor<R> {
   OldResolvedVisitor(TreeElements elements) : super(elements);
 
   R visitSend(Send node) {
     return _oldDispatch(node, this);
   }
-
-  R visitSendSet(SendSet node) {
-    return handleSendSet(node);
-  }
-
-  R visitNewExpression(NewExpression node) {
-    return handleNewExpression(node);
-  }
 }
 
 abstract class NewResolvedVisitor<R> extends BaseResolvedVisitor<R>
     with SendResolverMixin,
          GetBulkMixin<R, dynamic>,
          SetBulkMixin<R, dynamic>,
          ErrorBulkMixin<R, dynamic>,
          InvokeBulkMixin<R, dynamic>,
          IndexSetBulkMixin<R, dynamic>,
          CompoundBulkMixin<R, dynamic>,
@@ skipping 35 matching lines @@
       if (sendStructure != null) {
         var arg = sendVisitor == _resolvedKindDispatcher
             ? kindVisitor : sendStructure;
         return sendStructure.dispatch(sendVisitor, node, arg);
       } else {
         return kindVisitor.visitStaticSend(node);
       }
     }
   }
 
-  bool checkResolvedKind(Node node,
-                         ResolvedKind oldKind,
-                         ResolvedKind newKind) {
-    return invariant(node, oldKind == newKind, message: '$oldKind != $newKind');
-  }
-
-  ResolvedKind computeResolvedKindFromStructure(
-      Node node, SemanticSendStructure structure) {
-    return structure.dispatch(
-        _resolvedKindDispatcher, node, const ResolvedKindComputer());
-  }
-
-  @override
   R visitSend(Send node) {
-    assert(checkResolvedKind(
-        node,
-        _oldDispatch(node, const ResolvedKindComputer()),
-        _newDispatch(node, const ResolvedKindComputer(),
-            _resolvedKindDispatcher)));
+    ResolvedKind oldKind;
+    ResolvedKind newKind;
+    assert(invariant(node, () {
+      oldKind = _oldDispatch(node, const ResolvedKindComputer());
+      newKind = _newDispatch(
+          node, const ResolvedKindComputer(), _resolvedKindDispatcher);
+      return oldKind == newKind;
+    }, message: () => '$oldKind != $newKind'));
     return _newDispatch(node, this, this);
   }
 
   @override
-  R visitSendSet(Send node) {
-    SendStructure structure = computeSendStructure(node);
-    if (structure == null) {
-      return internalError(node, 'No structure for $node');
-    } else {
-      assert(checkResolvedKind(node,
-          ResolvedKind.SEND_SET,
-          computeResolvedKindFromStructure(node, structure)));
-      return structure.dispatch(this, node, structure);
-    }
-  }
-
-  @override
-  R visitNewExpression(NewExpression node) {
-    NewStructure structure = computeNewStructure(node);
-    if (structure == null) {
-      return internalError(node, 'No structure for $node');
-    } else {
-      assert(checkResolvedKind(node,
-          ResolvedKind.NEW,
-          computeResolvedKindFromStructure(node, structure)));
-      return structure.dispatch(this, node, structure);
-    }
-  }
-
-  @override
   R apply(Node node, arg) {
     return visitNode(node);
   }
 
   @override
   R bulkHandleNode(
       Node node,
       String message,
-      SemanticSendStructure structure) {
-    return structure.dispatch(_semanticDispatcher, node, this);
+      SendStructure sendStructure) {
+    return sendStructure.dispatch(_semanticDispatcher, node, this);
   }
 }
 
 /// Visitor that dispatches [SemanticSendVisitor] calls to the corresponding
 /// visit methods in [ResolvedVisitor].
 class ResolvedSemanticDispatcher<R> extends Object
     with GetBulkMixin<R, ResolvedKindVisitor<R>>,
          SetBulkMixin<R, ResolvedKindVisitor<R>>,
          InvokeBulkMixin<R, ResolvedKindVisitor<R>>,
          PrefixBulkMixin<R, ResolvedKindVisitor<R>>,
@@ skipping 11 matching lines @@
   R apply(Node node, ResolvedKindVisitor<R> visitor) {
     return visitor.internalError(
         node, "ResolvedSemanticDispatcher.apply unsupported.");
   }
 
   @override
   R bulkHandleNode(
       Node node,
       String message,
       ResolvedKindVisitor<R> visitor) {
+    // Set, Compound, IndexSet, and NewExpression are not handled by
+    // [ResolvedVisitor].
     return bulkHandleError(node, visitor);
   }
 
   R bulkHandleError(Node node, ResolvedKindVisitor<R> visitor) {
-    if (node.asSendSet() != null) {
-      return visitor.handleSendSet(node);
-    } else if (node.asNewExpression() != null) {
-      return visitor.handleNewExpression(node);
-    }
-    return visitor.internalError(node, "No resolved kind for $node.");
+    return visitor.internalError(node, "No resolved kind for node.");
   }
 
   @override
   R bulkHandleGet(Node node, ResolvedKindVisitor<R> visitor) {
     return visitor.visitGetterSend(node);
   }
 
   @override
   R bulkHandleInvoke(Node node, ResolvedKindVisitor<R> visitor) {
     // Most invokes are static.
     return visitor.visitStaticSend(node);
   }
 
   @override
   R bulkHandlePrefix(Node node, ResolvedKindVisitor<R> visitor) {
-    return visitor.handleSendSet(node);
+    return visitor.visitOperatorSend(node);
   }
 
   @override
   R bulkHandlePostfix(Node node, ResolvedKindVisitor<R> visitor) {
-    return visitor.handleSendSet(node);
+    return visitor.visitOperatorSend(node);
   }
 
   @override
   R bulkHandleSuper(Node node, ResolvedKindVisitor<R> visitor) {
-    if (node.asSendSet() != null) {
-      return visitor.handleSendSet(node);
-    }
     return visitor.visitSuperSend(node);
   }
 
   @override
-  R bulkHandleSet(SendSet node, ResolvedKindVisitor<R> visitor) {
-    return visitor.handleSendSet(node);
-  }
-
-  @override
-  R bulkHandleCompound(SendSet node, ResolvedKindVisitor<R> visitor) {
-    return visitor.handleSendSet(node);
-  }
-
-  @override
-  R bulkHandleIndexSet(SendSet node, ResolvedKindVisitor<R> visitor) {
-    return visitor.handleSendSet(node);
-  }
-
-  @override
-  R bulkHandleNew(NewExpression node, ResolvedKindVisitor<R> visitor) {
-    return visitor.handleNewExpression(node);
-  }
-
-  @override
   R errorInvalidAssert(
       Send node,
       NodeList arguments,
       ResolvedKindVisitor<R> visitor) {
     return visitor.visitAssertSend(node);
   }
 
   @override
   R errorLocalFunctionPostfix(
       Send node,
@@ skipping 410 matching lines @@
 
   @override
   R errorUnresolvedSuperIndex(
       Send node,
       Element function,
       Node index,
       ResolvedKindVisitor<R> visitor) {
     return visitor.visitSuperSend(node);
   }
 }