Handle NewExpression in SemanticSendVisitor.

pkg/compiler/lib/src/resolution/semantic_visitor_mixins.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.
 
 part of dart2js.semantics_visitor;
 
 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `errorX` methods.
 abstract class ErrorBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleError(Send node, A arg) {
+  R bulkHandleError(Node node, A arg) {
     return bulkHandleNode(node, "Error expression `$node` unhandled.", arg);
   }
 
   @override
   R errorInvalidAssert(
       Send node,
       NodeList arguments,
       A arg) {
     return bulkHandleError(node, arg);
   }
 
   @override
+  R errorAbstractClassConstructorInvoke(
+      NewExpression node,
+      ConstructorElement element,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return bulkHandleError(node, arg);
+  }
+
+  @override
   R errorClassTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleError(node, arg);
   }
 
   @override
@@ skipping 379 matching lines @@
   R errorUnresolvedCompound(
       Send node,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleError(node, arg);
   }
 
   @override
+  R errorUnresolvedClassConstructorInvoke(
+      NewExpression node,
+      Element element,
+      MalformedType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return bulkHandleError(node, arg);
+  }
+
+  @override
+  R errorUnresolvedConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return bulkHandleError(node, arg);
+  }
+
+  @override
   R errorUnresolvedGet(
       Send node,
       Element element,
       A arg) {
     return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedInvoke(
       Send node,
@@ skipping 16 matching lines @@
   @override
   R errorUnresolvedPrefix(
       Send node,
       Element element,
       IncDecOperator operator,
       A arg) {
     return bulkHandleError(node, arg);
   }
 
   @override
+  R errorUnresolvedRedirectingFactoryConstructorInvoke(
+       NewExpression node,
+       ConstructorElement constructor,
+       InterfaceType type,
+       NodeList arguments,
+       Selector selector,
+       A arg) {
+    return bulkHandleError(node, arg);
+  }
+
+  @override
   R errorUnresolvedSet(
       Send node,
       Element element,
       Node rhs,
       A arg) {
     return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperCompoundIndexSet(
@@ skipping 1684 matching lines @@
   @override
   R visitSuperUnary(
       Send node,
       UnaryOperator operator,
       FunctionElement function,
       A arg) {
     return bulkHandleSuper(node, arg);
   }
 }
 
+abstract class NewBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
+  R bulkHandleNode(Node node, String message, A arg);
+
+  R bulkHandleNew(NewExpression node, A arg) {
+    return bulkHandleNode(
+        node, "Constructor invocation `$node` unhandled.", arg);
+  }
+
+  @override
+  R visitConstConstructorInvoke(
+      NewExpression node,
+      ConstructedConstantExpression constant,
+      A arg) {
+    return bulkHandleNew(node, arg);
+  }
+
+  R visitGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return bulkHandleNew(node, arg);
+  }
+
+  R visitRedirectingGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return bulkHandleNew(node, arg);
+  }
+
+  R visitFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return bulkHandleNew(node, arg);
+  }
+
+  R visitRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ConstructorElement effectiveTarget,
+      InterfaceType effectiveTargetType,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return bulkHandleNew(node, arg);
+  }
+}
+
 /// Visitor that implements [SemanticSendVisitor] by the use of `BulkX` mixins.
 ///
 /// This class is useful in itself, but shows how to use the `BulkX` mixins and
 /// tests that the union of the `BulkX` mixins implement all `visit` and `error`
 /// methods of [SemanticSendVisitor].
 class BulkVisitor<R, A> extends SemanticSendVisitor<R, A>
     with GetBulkMixin<R, A>,
          SetBulkMixin<R, A>,
          ErrorBulkMixin<R, A>,
          InvokeBulkMixin<R, A>,
          IndexSetBulkMixin<R, A>,
          CompoundBulkMixin<R, A>,
          UnaryBulkMixin<R, A>,
          BaseBulkMixin<R, A>,
          BinaryBulkMixin<R, A>,
          PrefixBulkMixin<R, A>,
-         PostfixBulkMixin<R, A> {
+         PostfixBulkMixin<R, A>,
+         NewBulkMixin<R, A> {
   @override
   R apply(Node node, A arg) {
     throw new UnimplementedError("BulkVisitor.apply unimplemented");
   }
 
   @override
   R bulkHandleNode(Node node, String message, A arg) {
     throw new UnimplementedError("BulkVisitor.bulkHandleNode unimplemented");
   }
 }
@@ skipping 1837 matching lines @@
   R visitSuperIndexPrefix(
       Send node,
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     apply(index, arg);
     return null;
   }
+
+  @override
+  R visitConstConstructorInvoke(
+      NewExpression node,
+      ConstructedConstantExpression constant,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R errorUnresolvedClassConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      MalformedType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R errorUnresolvedConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+  R visitFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ConstructorElement effectiveTarget,
+      InterfaceType effectiveTargetType,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitRedirectingGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R errorAbstractClassConstructorInvoke(
+      NewExpression node,
+      ConstructorElement element,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R errorUnresolvedRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
 }
 
 /// AST visitor that visits all normal [Send] and [SendSet] nodes using the
 /// [SemanticVisitor].
 class TraversalVisitor<R, A> extends SemanticVisitor<R, A>
     with TraversalMixin<R, A> {
   TraversalVisitor(TreeElements elements) : super(elements);
 
   SemanticSendVisitor<R, A> get sendVisitor => this;
 
   R apply(Node node, A arg) {
     node.accept(this);
     return null;
   }
 
   @override
   internalError(Spannable spannable, String message) {
     throw new SpannableAssertionFailure(spannable, message);
   }
 
   @override
   R visitNode(Node node) {
     node.visitChildren(this);
     return null;
   }
 
-  @override
-  R visitNewExpression(NewExpression node) {
-    // Bypass the [Send] holding the class/constructor name.
-    return apply(node.send.argumentsNode, null);
-  }
-
   void visitParameters(NodeList parameters) {
 
   }
 
   void visitInitializers(NodeList initializers) {
     // TODO(johnniwinther): Visit subnodes of initializers.
   }
 
   @override
   R visitFunctionExpression(FunctionExpression node) {
@@ skipping 625 matching lines @@
 }
 
 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for
 /// constant type literals by delegating calls to `handleConstantX` methods.
 ///
 /// This mixin is useful for the cases where expressions on constants are
 /// handled uniformly.
 abstract class BaseImplementationOfConstantsMixin<R, A>
     implements SemanticSendVisitor<R, A> {
   R handleConstantGet(
-      Send node,
+      Node node,
       ConstantExpression constant,
       A arg);
 
   R handleConstantInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg);
 
   @override
   R visitClassTypeLiteralGet(
       Send node,
       ConstantExpression constant,
       A arg) {
     return handleConstantGet(node, constant, arg);
   }
 
   @override
   R visitClassTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
     return handleConstantInvoke(node, constant, arguments, selector, arg);
   }
 
   @override
+  R visitConstConstructorInvoke(
+      NewExpression node,
+      ConstructedConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
   R visitConstantGet(
       Send node,
       ConstantExpression constant,
       A arg) {
     return handleConstantGet(node, constant, arg);
   }
 
   @override
   R visitConstantInvoke(
       Send node,
@@ skipping 241 matching lines @@
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleDynamicIndexPostfixPrefix(
         node, receiver, index, operator, arg, isPrefix: true);
   }
 }
 
-/// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods for
-/// by delegating calls to `handleSuperXPostfixPrefix` methods.
+/// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by
+/// delegating calls to `handleSuperXPostfixPrefix` methods.
 ///
 /// This mixin is useful for the cases where super prefix/postfix expression are
 /// handled uniformly.
 abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
     implements SemanticSendVisitor<R, A> {
   R handleSuperFieldFieldPostfixPrefix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
@@ skipping 190 matching lines @@
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexPostfixPrefix(
         node, indexFunction, indexSetFunction,
         index, operator, arg, isPrefix: true);
   }
 }
+
+/// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
+/// delegating calls to the `handleConstructorInvoke` method.
+///
+/// This mixin is useful for the cases where all constructor invocations are
+/// handled uniformly.
+abstract class BaseImplementationOfNewMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
+
+  R handleConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
+      A arg);
+
+  R visitGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleConstructorInvoke(
+        node, constructor, type, arguments, selector, arg);
+  }
+
+  R visitRedirectingGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleConstructorInvoke(
+        node, constructor, type, arguments, selector, arg);
+  }
+
+  R visitFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleConstructorInvoke(
+        node, constructor, type, arguments, selector, arg);
+  }
+
+  R visitRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ConstructorElement effectiveTarget,
+      InterfaceType effectiveTargetType,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleConstructorInvoke(
+        node, constructor, type, arguments, selector, arg);
+  }
+}