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

lib/compiler/implementation/compile_time_constants.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 Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
@@ skipping 934 matching lines @@
   visitSendSet(SendSet node) {
     error(node);
   }
 
   /** Returns the list of constants that are passed to the static function. */
   List<Constant> evaluateArgumentsToConstructor(Send send,
                                                 FunctionElement target) {
     FunctionParameters parameters = target.computeParameters(compiler);
     List<Constant> arguments = <Constant>[];
     Selector selector = elements.getSelector(send);
+    // For an implicit super call we construct a synthetic send which is not
+    // in the elements.
+    if (selector == null) {
+      assert(send.argumentsNode.isEmpty());
+      selector = Selector.INVOCATION_0;
+    }
 
     Function compileArgument = evaluate;
     Function compileConstant = compiler.compileVariable;
     bool succeeded = selector.addSendArgumentsToList(
         send, arguments, parameters, compileArgument, compileConstant);
     if (!succeeded) error(send);
     return arguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
@@ skipping 70 matching lines @@
     parameters.forEachParameter((Element parameter) {
       Constant argument = arguments[index++];
       definitions[parameter] = argument;
       if (parameter.kind == ElementKind.FIELD_PARAMETER) {
         FieldParameterElement fieldParameterElement = parameter;
         fieldValues[fieldParameterElement.fieldElement] = argument;
       }
     });    
   }
 
-  void evaluateSuperOrRedirectSend(FunctionElement targetConstructor,
-                                   List<Constant> targetArguments) {
+  void evaluateSuperOrRedirectSend(Send send,
+                                   FunctionElement targetConstructor) {
+    List<Constant> arguments =
+        evaluateArgumentsToConstructor(send, targetConstructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(targetConstructor, compiler);
-    evaluator.evaluateConstructorFieldValues(targetArguments);
+    evaluator.evaluateConstructorFieldValues(arguments);
     // Copy over the fieldValues from the super/redirect-constructor.
     evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
   }
 
   /**
    * Runs through the initializers of the given [constructor] and updates
    * the [fieldValues] map.
    */
   void evaluateConstructorInitializers() {
     FunctionExpression functionNode = constructor.parseNode(compiler);
     NodeList initializerList = functionNode.initializers;
 
     bool foundSuperOrRedirect = false;
 
     if (initializerList !== null) {
       for (Link<Node> link = initializerList.nodes;
            !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;
           FunctionElement targetConstructor = elements[call];
-          List<Constant> targetArguments =
-              evaluateArgumentsToConstructor(call, targetConstructor);
-          evaluateSuperOrRedirectSend(targetConstructor, targetArguments);
+          evaluateSuperOrRedirectSend(call, targetConstructor);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> initArguments = init.arguments;
           assert(!initArguments.isEmpty() && initArguments.tail.isEmpty());
           Constant fieldValue = evaluate(initArguments.head);
           fieldValues[elements[init]] = fieldValue;
         }
       }
     }
 
     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 targetConstructor =
             superClass.lookupConstructor(superClass.name);
         if (targetConstructor === null) {
           compiler.internalError("no default constructor available");
         }
-        evaluateSuperOrRedirectSend(targetConstructor, const <Constant>[]);
+        NodeList emptyNodeList = new NodeList(nodes: const EmptyLink());
+        Send syntheticSend = new Send(null, null, emptyNodeList);        
+        evaluateSuperOrRedirectSend(syntheticSend, targetConstructor);
       }
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
    * [arguments] to obtain the field values that need to be passed to the
    * native JavaScript constructor.
    */
   void evaluateConstructorFieldValues(List<Constant> arguments) {
@@ skipping 12 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileVariable(field);
       }
       jsNewArguments.add(fieldValue);          
     });
     return jsNewArguments;
   }
 }