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 782 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,
+                             Send send,
+                             List<FunctionElement> constructors,
+                             Map<Element, HInstruction> fieldValues) {
+    constructors.addLast(constructor);
+
+    List<HInstruction> arguments = new List<HInstruction>();
+    addStaticSendArgumentsToList(send, constructor, arguments);
+
+    int index = 0;
+    FunctionParameters parameters = constructor.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;
+      }
+    });
+
+    // 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];
+          inlineSuperOrRedirect(target, call, 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);
+        NodeList emptyNodeList = new NodeList(nodes: const EmptyLink());
+        Send syntheticSend = new Send(null, null, emptyNodeList);
+        inlineSuperOrRedirect(target, syntheticSend, 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 816 matching lines @@
       visit(argument);
       return pop();
     }
 
     HInstruction compileConstant(Element constantElement) {
       Constant constant = compiler.compileVariable(constantElement);
       return graph.addConstant(constant);
     }
 
     Selector selector = elements.getSelector(node);
+    // For an implicit super call we construct a synthetic send which is not
+    // in the elements.
+    if (selector == null) {
+      assert(node.argumentsNode.isEmpty());
+      selector = Selector.INVOCATION_0;
+    }

[ngeoffray, 2012/03/30 09:10:03]

I think the creation of the synthethized node, and adding the selector in the
TreeElements should be done in the resolver. 

Likewise, the resolver should report an error if it cannot find a default
constructor to call. I just tried this code:

class A {
  A(a);
}

class B extends A {
  B(c);
}

main() {
  print(new B(1));
}

We report:
foo.dart:2:5: internal error: Cannot find value parameter(a)
  A(a);
    ^
We should clearly report an error before entering codegen. So if the resolver
does the check, it should also add the synthethized send.

[floitsch, 2012/03/30 18:18:28]

Not sure. (I changed this line from "I disagree", to "I think I disagree", to
"Not sure."...).
Definitely.
It would definitely make life easier (both in the CTC as well as in the
builder), but somehow it looks to me as if the synthetic send is an
implementation detail.
That said: we already create a synthetic constructor too. The main-difference
(from my point-of-view), is that the synthetic constructor is a data-structure
that comes from the resolver. Whereas the synthetic send instantiates something
from the Parser.

     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);
     }
   }
@@ skipping 1207 matching lines @@
                                         false,
                                         <HInstruction>[target, input]));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }