dart2js cps: Implement compilation of redirecting factory constructors for reflection.

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 234 matching lines @@
     }
     return null;
   }
 
   ir.Primitive visitRethrow(ast.Rethrow node) {
     assert(irBuilder.isOpen);
     irBuilder.buildRethrow();
     return null;
   }
 
+  /// Construct a method that executes the forwarding call to the target
+  /// constructor.  This is only required, if the forwarding factory
+  /// constructor can potentially be the target of a reflective call, because
+  /// the builder shortcuts calls to redirecting factories at the call site
+  /// (see [JsIrBuilderVisitor.handleConstructorInvoke]).
+  visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
+    ConstructorElement targetConstructor =
+        elements.getRedirectingTargetConstructor(node).implementation;
+    ConstructorElement redirectingConstructor =
+        irBuilder.state.currentElement.implementation;
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    FunctionSignature redirectingSignature =
+        redirectingConstructor.functionSignature;
+    List<String> namedParameters = <String>[];
+    redirectingSignature.forEachParameter((ParameterElement parameter) {
+      arguments.add(irBuilder.environment.lookup(parameter));
+      if (parameter.isNamed) {
+        namedParameters.add(parameter.name);
+      }
+    });
+    ClassElement cls = redirectingConstructor.enclosingClass;
+    InterfaceType targetType =
+          redirectingConstructor.computeEffectiveTargetType(cls.thisType);
+    CallStructure callStructure = new CallStructure(
+        redirectingSignature.parameterCount,
+        namedParameters);
+    arguments = normalizeStaticArguments(callStructure, targetConstructor,
+        arguments);
+    ir.Primitive instance = irBuilder.buildConstructorInvocation(
+        targetConstructor,
+        callStructure,
+        targetType,
+        arguments);
+    irBuilder.buildReturn(instance);
+  }
+
   visitFor(ast.For node) {
     List<LocalElement> loopVariables = <LocalElement>[];
     if (node.initializer is ast.VariableDefinitions) {
       ast.VariableDefinitions definitions = node.initializer;
       for (ast.Node node in definitions.definitions.nodes) {
         LocalElement loopVariable = elements[node];
         loopVariables.add(loopVariable);
       }
     }
 
@@ skipping 3018 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }