Support named parameters for super initializers and redirections.

frog/leg/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 689 matching lines @@
           compiler.resolver.resolveMethodElement(constructor);
       compiler.enqueue(new WorkItem.toCodegen(bodyElement, treeElements));
       classElement.backendMembers =
           classElement.backendMembers.prepend(bodyElement);
     }
     assert(bodyElement.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY);
     return bodyElement;
   }
 
   /**
-   * Call [f] for every argument and parameter element of [target]
-   * that is used in the invocation [send].
-   */
-  forEachArgument(Send send, FunctionElement target,
-                  f(VariableElement parameter, Node argument)) {
-    final FunctionParameters parameters = target.computeParameters(compiler);
-    Link<Element> parameterElements = parameters.requiredParameters;
-    for (Link<Node> arguments = send.arguments;
-         !arguments.isEmpty();
-         arguments = arguments.tail) {
-      if (parameterElements.isEmpty()) {
-        parameterElements = parameters.optionalParameters;
-      }
-      f(parameterElements.head, arguments.head);
-      parameterElements = parameterElements.tail;
-    };
-  }
-
-  /**
    * Run through the initializers and inline all field initializers. Returns the
    * next constructor to analyze.
    */
   FunctionElement analyzeInitializers(Link<Node> initializers) {
     FunctionElement nextConstructor;
     for (Link<Node> link = initializers; !link.isEmpty(); link = link.tail) {
       assert(link.head is Send);
       if (link.head is !SendSet) {
         // A super initializer or constructor redirection.
         Send call = link.head;
         assert(Initializers.isSuperConstructorCall(call) ||
                Initializers.isConstructorRedirect(call));
         assert(nextConstructor === null);
         nextConstructor = elements[call];
         // Visit arguments and map the corresponding parameter value to
         // the resulting HInstruction value.
-        forEachArgument(call, nextConstructor, (parameter, node) {
-          visit(node);
-          HInstruction value = pop();
-          localsHandler.updateLocal(parameter, value);
+        List<HInstruction> arguments = new List<HInstruction>();
+        addStaticSendArgumentsToList(call, nextConstructor, arguments);
+        int index = 0;
+        FunctionParameters parameters =
+            nextConstructor.computeParameters(compiler);
+        parameters.forEachParameter((parameter) {
+          localsHandler.updateLocal(parameter, arguments[index++]);
         });
       } else {
         // A field initializer.
         SendSet init = link.head;
         Link<Node> arguments = init.arguments;
         assert(!arguments.isEmpty() && arguments.tail.isEmpty());
         visit(arguments.head);
         // We treat the init field-elements like locals. In the context of
         // the factory this is correct, and simplifies dealing with
         // parameter-initializers (like A(this.x)).
@@ skipping 1531 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 }