Handle SendSet and NewExpression through NewResolvedVisitor.

This allows for the handling assignment and new expression through the SemanticSendVisitor methods in SsaBuilder and InferrerVisitor(s).

BUG=
R=karlklose@google.com

Review URL: https://codereview.chromium.org//1079533002

git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@45091 260f80e4-7a28-3924-810f-c04153c831b5

Author: johnniwinther

pkg/compiler/lib/src/dart_backend/placeholder_collector.dart

@@ -152,6 +152,12 @@ class SendVisitor extends OldResolvedVisitor {
       }
     }
   }
+
+  @override
+  handleNewExpression(NewExpression node) => visitNode(node);
+
+  @override
+  handleSendSet(SendSet node) => visitNode(node);
 }
 
 class PlaceholderCollector extends Visitor {

pkg/compiler/lib/src/inferrer/inferrer_visitor.dart

@@ -703,7 +703,7 @@ abstract class InferrerVisitor
     locals = new LocalsHandler<T>(inferrer, types, compiler, node, fieldScope);
   }
 
-  T visitSendSet(SendSet node);
+  T handleSendSet(SendSet node);
 
   T visitSuperSend(Send node);
 
@@ -736,7 +736,7 @@ abstract class InferrerVisitor
     return node.visitChildren(this);
   }
 
-  T visitNewExpression(NewExpression node) {
+  T handleNewExpression(NewExpression node) {
     return node.send.accept(this);
   }
 

pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart

@@ -773,7 +773,8 @@ class SimpleTypeInferrerVisitor<T>
         || (element != null && element.isInstanceMember);
   }
 
-  T visitSendSet(ast.SendSet node) {
+  @override
+  T handleSendSet(ast.SendSet node) {
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType) {
       node.visitChildren(this);

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

@@ -14,11 +14,18 @@ import '../tree/tree.dart';
 import '../universe/universe.dart';
 import '../util/util.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);
+}
+
 /// 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> {
+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);
 }
@@ -1811,7 +1818,7 @@ class PostfixStructure<R, A> implements SendStructure<R, A> {
 }
 
 /// The structure for a [NewExpression] of a new invocation.
-abstract class NewStructure<R, A> {
+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);
 }

pkg/compiler/lib/src/resolved_visitor.dart

@@ -17,6 +17,8 @@ enum ResolvedKind {
   CLOSURE,
   DYNAMIC,
   ERROR,
+  SEND_SET,
+  NEW,
 }
 
 /// Abstract interface for a [ResolvedVisitor].
@@ -28,6 +30,8 @@ abstract class ResolvedKindVisitor<R> {
   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);
@@ -56,6 +60,8 @@ class ResolvedKindComputer implements ResolvedKindVisitor {
   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;
 }
 
@@ -130,6 +136,14 @@ abstract class OldResolvedVisitor<R> extends BaseResolvedVisitor<R> {
   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>
@@ -185,18 +199,54 @@ abstract class NewResolvedVisitor<R> extends BaseResolvedVisitor<R>
     }
   }
 
+  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);
@@ -206,8 +256,8 @@ abstract class NewResolvedVisitor<R> extends BaseResolvedVisitor<R>
   R bulkHandleNode(
       Node node,
       String message,
-      SendStructure sendStructure) {
-    return sendStructure.dispatch(_semanticDispatcher, node, this);
+      SemanticSendStructure structure) {
+    return structure.dispatch(_semanticDispatcher, node, this);
   }
 }
 
@@ -239,13 +289,16 @@ class ResolvedSemanticDispatcher<R> extends Object
       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
@@ -261,19 +314,42 @@ class ResolvedSemanticDispatcher<R> extends Object
 
   @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,

pkg/compiler/lib/src/ssa/builder.dart

@@ -4778,7 +4778,8 @@ class SsaBuilder extends NewResolvedVisitor {
                               existingArguments: existingArguments);
   }
 
-  visitNewExpression(ast.NewExpression node) {
+  @override
+  handleNewExpression(ast.NewExpression node) {
     Element element = elements[node.send];
     final bool isSymbolConstructor = element == compiler.symbolConstructor;
     if (!Elements.isErroneous(element)) {
@@ -4965,7 +4966,8 @@ class SsaBuilder extends NewResolvedVisitor {
                     elements.getOperatorSelectorInComplexSendSet(node), node);
   }
 
-  visitSendSet(ast.SendSet node) {
+  @override
+  handleSendSet(ast.SendSet node) {
     generateIsDeferredLoadedCheckIfNeeded(node);
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType) {