Handle NewExpression in SemanticSendVisitor.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 112 matching lines @@
  * to the [builder] and return the last added statement for trees that represent
  * an expression.
  */
 abstract class IrBuilderVisitor extends SemanticVisitor<ir.Primitive, dynamic>
     with IrBuilderMixin<ast.Node>,
          BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfSuperIncDecsMixin<ir.Primitive, dynamic>,
+         BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
          ErrorBulkMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
 
   // In SSA terms, join-point continuation parameters are the phis and the
   // continuation invocation arguments are the corresponding phi inputs.  To
   // support name introduction and renaming for source level variables, we use
   // nested (delimited) visitors for constructing subparts of the IR that will
   // need renaming.  Each source variable is assigned an index.
@@ skipping 491 matching lines @@
     return irBuilder.buildCallInvocation(receiver, selector, arguments);
   }
 
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
-  ir.Primitive handleConstantGet(ast.Send node,
-                                 ConstantExpression constant, _) {
+  ir.Primitive handleConstantGet(
+      ast.Node node,
+      ConstantExpression constant, _) {
     return irBuilder.buildConstantLiteral(constant);
   }
 
   /// If [node] is null, returns this.
   /// Otherwise visits [node] and returns the result.
   ir.Primitive translateReceiver(ast.Expression node) {
     return node != null ? visit(node) : irBuilder.buildThis();
   }
 
   @override
@@ skipping 1040 matching lines @@
       _) {
     return translateCompound(
         getValue: () => irBuilder.buildSuperGet(method),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildSuperSet(setter, result);
         });
   }
 
-  ir.Primitive visitNewExpression(ast.NewExpression node) {
-    if (node.isConst) {
-      return translateConstant(node);
-    }
-    FunctionElement element = elements[node.send];
-    Selector selector = elements.getSelector(node.send);
-    DartType type = elements.getType(node);
-    ast.Node selectorNode = node.send.selector;
+  @override
+  ir.Primitive handleConstructorInvoke(
+      ast.NewExpression node,
+      ConstructorElement constructor,
+      DartType type,
+      ast.NodeList arguments,
+      Selector selector, _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
-    arguments = normalizeStaticArguments(selector, element, arguments);
+    arguments = normalizeStaticArguments(selector, constructor, arguments);
     return irBuilder.buildConstructorInvocation(
-        element, selector, type, arguments);
+        constructor, selector, type, arguments);
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
     return irBuilder.buildStringConcatenation([first, second]);
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
@@ skipping 924 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }