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> inputs = <ir.Primitive>[];
+    FunctionSignature targetSignature = targetConstructor.functionSignature;
+    FunctionSignature redirectingSignature =
+    redirectingConstructor.functionSignature;
+    redirectingSignature.forEachRequiredParameter((ParameterElement parameter) {
+      inputs.add(irBuilder.environment.lookup(parameter));
+    });
+    List<Element> targetOptionals =
+        targetSignature.orderedOptionalParameters;
+    List<Element> redirectingOptionals =
+        redirectingSignature.orderedOptionalParameters;
+    // TODO(karlklose): match named parameters correctly, once the mirror
+    // system implements them.

[asgerf, 2015/07/09 09:47:54]

Please use normalizeStaticArguments and get rid of the TODO.

+    int i = 0;
+    for (; i < redirectingOptionals.length; i++) {
+      ParameterElement parameter = redirectingOptionals[i];
+      inputs.add(irBuilder.environment.lookup(parameter));
+    }
+    for (; i < targetOptionals.length; i++) {
+      ConstantValue constantValue = getConstantForVariable(targetOptionals[i]);
+      inputs.add(irBuilder.buildConstant(constantValue));
+    }
+    ClassElement cls = redirectingConstructor.enclosingClass;
+    InterfaceType targetType =
+          redirectingConstructor.computeEffectiveTargetType(cls.thisType);
+    List<String> namedParameters = redirectingSignature.optionalParameters
+        .where((ParameterElement p) => p.isNamed)
+        .map((ParameterElement p) => p.name)
+        .toList();
+    CallStructure callStructure = new CallStructure(
+        redirectingSignature.parameterCount,
+        namedParameters);
+    ir.Primitive instance = irBuilder.buildConstructorInvocation(
+        targetConstructor,
+        callStructure,
+        targetType,
+        inputs);
+    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);
   }
 }