cps-ir: Handle factories and redirecting constructors with JS backend.

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 77 matching lines @@
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
       resolved.forEach(buildNode);
     });
   }
 
   bool canBuild(Element element) {
+    // If using JavaScript backend, don't try to bail out early.
+    if (compiler.backend is JavaScriptBackend) return true;
+
     if (element is TypedefElement) return false;
     if (element is FunctionElement) {
       // TODO(sigurdm): Support native functions for dart2js.
       assert(invariant(element, !element.isNative));
 
       if (element is ConstructorElement) {
         if (!element.isGenerativeConstructor) {
           // TODO(kmillikin,sigurdm): Support constructors.
           return false;
         }
@@ skipping 1639 matching lines @@
       _) {
     return translateCompound(
         getValue: () => irBuilder.buildSuperMethodGet(method),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildSuperSetterSet(setter, result);
         });
   }
 
-  @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.callStructure, constructor, arguments);
-    return irBuilder.buildConstructorInvocation(
-        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) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> arguments = [];
@@ skipping 332 matching lines @@
   }
 
   @override
   ir.Primitive buildReifyTypeVariable(ir.Primitive target,
                                       TypeVariableType variable) {
     assert(target == irBuilder.state.enclosingMethodThisParameter);
     ir.Primitive prim = new ir.ReifyTypeVar(variable.element);
     irBuilder.add(new ir.LetPrim(prim));
     return prim;
   }
+
+  @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);
+    return irBuilder.buildConstructorInvocation(
+        constructor,
+        selector,
+        type,
+        arguments);
+  }
 }
 
 /// The [IrBuilder]s view on the information about the program that has been
 /// computed in resolution and and type interence.
 class GlobalProgramInformation {
   final Compiler _compiler;
   JavaScriptBackend get _backend => _compiler.backend;
 
   GlobalProgramInformation(this._compiler);
 
@@ skipping 566 matching lines @@
   @override
   ir.Primitive buildReifyTypeVariable(ir.Primitive target,
                                       TypeVariableType variable) {
     ir.Primitive typeArgument =
         irBuilder.buildTypeVariableAccess(target, variable);
 
     ir.Primitive type = new ir.ReifyRuntimeType(typeArgument);
     irBuilder.add(new ir.LetPrim(type));
     return type;
   }
+
+  @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.callStructure, constructor, arguments);
+    return irBuilder.buildConstructorInvocation(
+        constructor.effectiveTarget,
+        selector,
+        constructor.computeEffectiveTargetType(type),
+        arguments);
+  }
 }
 
 /// Interface for generating [SourceInformation] for the CPS.
 class SourceInformationBuilder {
   const SourceInformationBuilder();
 
   /// Create a [SourceInformationBuilder] for [element].
   SourceInformationBuilder forContext(AstElement element) => this;
 
   /// Generate [SourceInformation] for the read access in [node].
@@ skipping 22 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);
   }
 }