Revert "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 931 matching lines @@
       return folded;
     }
     return super.visitSend(send);
   }
 
   visitSendSet(SendSet node) {
     error(node);
   }
 
   /** Returns the list of constants that are passed to the static function. */
-  List<Constant> evaluateArgumentsToConstructor(Selector selector,
-                                                Link<Node> arguments,
+  List<Constant> evaluateArgumentsToConstructor(Send send,
                                                 FunctionElement target) {
     FunctionParameters parameters = target.computeParameters(compiler);
-    List<Constant> compiledArguments = <Constant>[];
+    List<Constant> arguments = <Constant>[];
+    Selector selector = elements.getSelector(send);
 
     Function compileArgument = evaluate;
     Function compileConstant = compiler.compileVariable;
-    bool succeeded = selector.addArgumentsToList(arguments, compiledArguments,
-                                                 parameters, compileArgument,
-                                                 compileConstant);
-    assert(succeeded);
-    return compiledArguments;
+    bool succeeded = selector.addSendArgumentsToList(
+        send, arguments, parameters, compileArgument, compileConstant);
+    if (!succeeded) error(send);
+    return arguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
     if (!node.isConst()) error(node);
 
-    Send send = node.send;
-    FunctionElement constructor = elements[send];
+    FunctionElement constructor = elements[node.send];
     ClassElement classElement = constructor.enclosingElement;
     if (classElement.isInterface()) {
       compiler.resolver.resolveMethodElement(constructor);
       constructor = constructor.defaultImplementation;
       classElement = constructor.enclosingElement;
     }
 
-    Selector selector = elements.getSelector(send);
     List<Constant> arguments =
-        evaluateArgumentsToConstructor(selector, send.arguments, constructor);
+        evaluateArgumentsToConstructor(node.send, constructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructor, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
-    List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
+    List<Constant>jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
     compiler.registerInstantiatedClass(classElement);
     // TODO(floitsch): take generic types into account.
     Type type = classElement.computeType(compiler);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
@@ skipping 44 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(Selector selector,
-                                   Link<Node> arguments,
-                                   FunctionElement targetConstructor) {
-    List<Constant> compiledArguments =
-        evaluateArgumentsToConstructor(selector, arguments, targetConstructor);
-
+  void evaluateSuperOrRedirectSend(FunctionElement targetConstructor,
+                                   List<Constant> targetArguments) {
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(targetConstructor, compiler);
-    evaluator.evaluateConstructorFieldValues(compiledArguments);
+    evaluator.evaluateConstructorFieldValues(targetArguments);
     // 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];
-          Selector selector = elements.getSelector(call);
-          Link<Node> arguments = call.arguments;
-          evaluateSuperOrRedirectSend(selector, arguments, targetConstructor);
+          List<Constant> targetArguments =
+              evaluateArgumentsToConstructor(call, targetConstructor);
+          evaluateSuperOrRedirectSend(targetConstructor, targetArguments);
           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",
-                                 node: functionNode);
+          compiler.internalError("no default constructor available");
         }
-
-        evaluateSuperOrRedirectSend(Selector.INVOCATION_0,
-                                    const EmptyLink<Node>(),
-                                    targetConstructor);
+        evaluateSuperOrRedirectSend(targetConstructor, const <Constant>[]);
       }
     }
   }
 
   /**
    * 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;
   }
 }