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) {
-    ResolvedKind oldKind;
-    ResolvedKind newKind;
-    assert(invariant(node, () {
-      oldKind = _oldDispatch(node, const ResolvedKindComputer());
-      newKind = _newDispatch(
-          node, const ResolvedKindComputer(), _resolvedKindDispatcher);
-      return oldKind == newKind;
-    }, message: () => '$oldKind != $newKind'));
+    assert(checkResolvedKind(
+        node,
+        _oldDispatch(node, const ResolvedKindComputer()),
+        _newDispatch(node, const ResolvedKindComputer(),
+            _resolvedKindDispatcher)));
     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,
-      SendStructure sendStructure) {
-    return sendStructure.dispatch(_semanticDispatcher, node, this);
+      SemanticSendStructure structure) {
+    return structure.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) {
-    return visitor.internalError(node, "No resolved kind for node.");
+    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.");
   }
 
   @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.visitOperatorSend(node);
+    return visitor.handleSendSet(node);
   }
 
   @override
   R bulkHandlePostfix(Node node, ResolvedKindVisitor<R> visitor) {
-    return visitor.visitOperatorSend(node);
+    return visitor.handleSendSet(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,
       LocalFunctionElement function,
       op.IncDecOperator operator,
       ResolvedKindVisitor<R> visitor) {
-    return visitor.visitOperatorSend(node);
+    return visitor.handleSendSet(node);
   }
 
   @override
   R errorLocalFunctionPrefix(
       Send node,
       LocalFunctionElement function,
       op.IncDecOperator operator,
       ResolvedKindVisitor<R> visitor) {
-    return visitor.visitOperatorSend(node);
+    return visitor.handleSendSet(node);
   }
 
   @override
   R errorStaticSetterGet(
       Send node,
       FunctionElement setter,
       ResolvedKindVisitor<R> visitor) {
     return visitor.visitGetterSend(node);
   }
 
@@ skipping 85 matching lines @@
     }
     return visitor.visitStaticSend(node);
   }
 
   @override
   R errorUnresolvedPostfix(
       Send node,
       Element element,
       op.IncDecOperator operator,
       ResolvedKindVisitor<R> visitor) {
-    if (node.isSuperCall) {
-      return visitor.visitSuperSend(node);
-    }
-    return visitor.visitOperatorSend(node);
+    return visitor.handleSendSet(node);
   }
 
   @override
   R errorUnresolvedPrefix(
       Send node,
       Element element,
       op.IncDecOperator operator,
       ResolvedKindVisitor<R> visitor) {
-    if (node.isSuperCall) {
-      return visitor.visitSuperSend(node);
-    }
-    return visitor.visitOperatorSend(node);
+    return visitor.handleSendSet(node);
   }
 
   @override
   R errorUnresolvedSuperBinary(
       Send node,
       Element element,
       op.BinaryOperator operator,
       Node argument,
       ResolvedKindVisitor<R> visitor) {
     return visitor.visitSuperSend(node);
@@ skipping 266 matching lines @@
 
   @override
   R errorUnresolvedSuperIndex(
       Send node,
       Element function,
       Node index,
       ResolvedKindVisitor<R> visitor) {
     return visitor.visitSuperSend(node);
   }
 }