Reapply "Use default values of named arguments when invoking the default super constructor."

lib/compiler/implementation/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 785 matching lines @@
       TreeElements treeElements =
           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;
   }
 
+  void inlineSuperOrRedirect(FunctionElement constructor,
+                             Selector selector,
+                             Link<Node> arguments,
+                             List<FunctionElement> constructors,
+                             Map<Element, HInstruction> fieldValues) {
+    constructors.addLast(constructor);
+
+    List<HInstruction> compiledArguments = new List<HInstruction>();
+    bool succeeded = addStaticSendArgumentsToList(selector,
+                                                  arguments,
+                                                  constructor,
+                                                  compiledArguments);
+    if (!succeeded) {
+      // Non-matching super and redirects are compile-time errors and thus
+      // checked by the resolver. 
+      compiler.internalError(
+          "Parameters and arguments didn't match for super/redirect call",
+          element: constructor);
+    }
+
+    int index = 0;
+    FunctionParameters parameters = constructor.computeParameters(compiler);
+    parameters.forEachParameter((Element parameter) {
+      HInstruction argument = compiledArguments[index++];
+      localsHandler.updateLocal(parameter, argument);
+      // Don't forget to update the field, if the parameter is of the
+      // form [:this.x:].
+      if (parameter.kind == ElementKind.FIELD_PARAMETER) {
+        FieldParameterElement fieldParameterElement = parameter;
+        fieldValues[fieldParameterElement.fieldElement] = argument;
+      }
+    });
+
+    // Build the initializers in the context of the new constructor.
+    TreeElements oldElements = elements;
+    elements = compiler.resolver.resolveMethodElement(constructor);
+    buildInitializers(constructor, constructors, fieldValues);
+    elements = oldElements;
+  }
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
    */
-  void inlineInitializers(FunctionElement constructor,
-                          List<FunctionElement> constructors,
-                          Map<Element, HInstruction> fieldValues) {
-    TreeElements oldElements = elements;
-    constructors.addLast(constructor);
-    bool initializedSuper = false;
-    elements = compiler.resolver.resolveMethodElement(constructor);
+  void buildInitializers(FunctionElement constructor,
+                         List<FunctionElement> constructors,
+                         Map<Element, HInstruction> fieldValues) {
     FunctionExpression functionNode = constructor.parseNode(compiler);
 
+    bool foundSuperOrRedirect = false;
+
     if (functionNode.initializers !== null) {
       Link<Node> initializers = functionNode.initializers.nodes;
       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));
-          FunctionElement nextConstructor = elements[call];
-          // Visit arguments and map the corresponding parameter value to
-          // the resulting HInstruction value.
-          List<HInstruction> arguments = new List<HInstruction>();
-          addStaticSendArgumentsToList(call, nextConstructor, arguments);
-          int index = 0;
-          FunctionParameters parameters =
-              nextConstructor.computeParameters(compiler);
-          parameters.forEachParameter((Element parameter) {
-            HInstruction argument = arguments[index++];
-            localsHandler.updateLocal(parameter, argument);
-            // Don't forget to update the field, if the parameter is of the
-            // form [:this.x:].
-            if (parameter.kind == ElementKind.FIELD_PARAMETER) {
-              FieldParameterElement fieldParameterElement = parameter;
-              fieldValues[fieldParameterElement.fieldElement] = argument;
-            }
-          });
-          inlineInitializers(nextConstructor, constructors, fieldValues);
-          initializedSuper = true;
+          FunctionElement target = elements[call];
+          Selector selector = elements.getSelector(call);
+          Link<Node> arguments = call.arguments;
+          inlineSuperOrRedirect(target, selector, arguments, constructors,
+                                fieldValues);
+          foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> arguments = init.arguments;
           assert(!arguments.isEmpty() && arguments.tail.isEmpty());
           visit(arguments.head);
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
-    if (!initializedSuper) {
+    if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.enclosingElement;
       ClassElement superClass = enclosingClass.superclass;
       if (enclosingClass != compiler.objectClass) {
         assert(superClass !== null);
         assert(superClass.isResolved);
-        FunctionElement nextConstructor =
-            superClass.lookupConstructor(superClass.name);
-        if (nextConstructor === null) {
+        FunctionElement target = superClass.lookupConstructor(superClass.name);
+        if (target === null) {
           compiler.internalError("no default constructor available");
         }
-        inlineInitializers(nextConstructor, constructors, fieldValues);
+        inlineSuperOrRedirect(target,
+                              Selector.INVOCATION_0,
+                              const EmptyLink<Node>(),
+                              constructors,
+                              fieldValues);
       }
     }
-
-    elements = oldElements;
   }
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
@@ skipping 15 matching lines @@
         // If the [element] is a field-parameter (such as [:this.x:] then
         // initialize the field element with its value.
         FieldParameterElement fieldParameterElement = element;
         HInstruction parameterValue = localsHandler.readLocal(element);
         fieldValues[fieldParameterElement.fieldElement] = parameterValue;
       }
     });
 
     final Map<FunctionElement, TreeElements> constructorElements =
         compiler.resolver.constructorElements;
-    List<FunctionElement> constructors = new List<FunctionElement>();
+    List<FunctionElement> constructors = <FunctionElement>[functionElement];
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
-    inlineInitializers(functionElement, constructors, fieldValues);
+    buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
       HInstruction value = fieldValues[member];
       if (value === null) {
         // The field has no value in the initializer list. Initialize it
@@ skipping 841 matching lines @@
       // Iterate through the named arguments to add them to the list
       // of instructions, in an order that can be shared with
       // selectors with the same named arguments.
       List<SourceString> orderedNames = selector.getOrderedNamedArguments();
       for (SourceString name in orderedNames) {
         list.add(instructions[name]);
       }
     }
   }
 
-  void addStaticSendArgumentsToList(Send node,
+  /**
+   * Returns true if the arguments were compatible with the function signature.
+   */
+  bool addStaticSendArgumentsToList(Selector selector,
+                                    Link<Node> arguments,
                                     FunctionElement element,
                                     List<HInstruction> list) {
     HInstruction compileArgument(Node argument) {
       visit(argument);
       return pop();
     }
 
     HInstruction compileConstant(Element constantElement) {
       Constant constant = compiler.compileVariable(constantElement);
       return graph.addConstant(constant);
     }
 
-    Selector selector = elements.getSelector(node);
     FunctionParameters parameters = element.computeParameters(compiler);
-    bool succeeded = selector.addSendArgumentsToList(node, list, parameters,
-                                                     compileArgument,
-                                                     compileConstant);
-   if (!succeeded) {
-      // TODO(ngeoffray): Match the VM behavior and throw an
-      // exception at runtime.
-      compiler.cancel('Unimplemented non-matching static call', node: node);
-    }
+    return selector.addArgumentsToList(arguments, list, parameters,
+                                       compileArgument, compileConstant);
   }
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
     for (; !link.isEmpty(); link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
   visitDynamicSend(Send node) {
@@ skipping 245 matching lines @@
       push(new HInvokeSuper(const Selector(SelectorKind.INVOCATION, 2),
                             inputs));
       return;
     }
     HInstruction target = new HStatic(element);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
     if (element.kind == ElementKind.FUNCTION ||
         element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-      addStaticSendArgumentsToList(node, element, inputs);
+      bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
+                                                    element, inputs);
+      if (!succeeded) {
+        // TODO(ngeoffray): Match the VM behavior and throw an
+        // exception at runtime.
+        compiler.cancel('Unimplemented non-matching static call', node);
+      }
       push(new HInvokeSuper(selector, inputs));
     } else {
       target = new HInvokeSuper(Selector.GETTER, inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
       compiler.resolver.resolveMethodElement(element);
       FunctionElement functionElement = element;
       element = functionElement.defaultImplementation;
     }
     HInstruction target = new HStatic(element);
     add(target);
     var inputs = <HInstruction>[];
     inputs.add(target);
     if (element.kind == ElementKind.FUNCTION ||
         element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-      addStaticSendArgumentsToList(node, element, inputs);
+      bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
+                                                    element, inputs);
+      if (!succeeded) {
+        // TODO(ngeoffray): Match the VM behavior and throw an
+        // exception at runtime.
+        compiler.cancel('Unimplemented non-matching static call', node: node);
+      }
       push(new HInvokeStatic(selector, inputs));
     } else {
       if (element.kind == ElementKind.GETTER) {
         target = new HInvokeStatic(Selector.GETTER, inputs);
         add(target);
         inputs = <HInstruction>[target];
       }
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
@@ skipping 935 matching lines @@
                                         false,
                                         <HInstruction>[target, input]));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }