Revert "dart2js cps: Handle optional parameters in builder."

pkg/compiler/lib/src/universe/universe.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.
 
 library universe;
 
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../types/types.dart';
@@ skipping 488 matching lines @@
   /**
    * Returns a `List` with the evaluated arguments in the normalized order.
    *
    * [compileDefaultValue] is a function that returns a compiled constant
    * of an optional argument that is not in [compiledArguments].
    *
    * Precondition: `this.applies(element, world)`.
    *
    * Invariant: [element] must be the implementation element.
    */
-  /*<T>*/ List/*<T>*/ makeArgumentsList(
+  /*<S, T>*/ List/*<T>*/ makeArgumentsList(
+        FunctionElement element,
+        List/*<T>*/ compiledArguments,
+        /*T*/ compileDefaultValue(ParameterElement element)) {
+    assert(invariant(element, element.isImplementation));
+    List/*<T>*/ result = new List();
+    FunctionSignature parameters = element.functionSignature;
+    int i = 0;
+    parameters.forEachRequiredParameter((ParameterElement element) {
+      result.add(compiledArguments[i]);
+      ++i;
+    });
+
+    if (!parameters.optionalParametersAreNamed) {
+      parameters.forEachOptionalParameter((ParameterElement element) {
+        if (i < compiledArguments.length) {
+          result.add(compiledArguments[i]);
+          ++i;
+        } else {
+          result.add(compileDefaultValue(element));
+        }
+      });
+    } else {
+      int offset = i;
+      // Iterate over the optional parameters of the signature, and try to
+      // find them in [compiledNamedArguments]. If found, we use the
+      // value in the temporary list, otherwise the default value.
+      parameters.orderedOptionalParameters
+          .forEach((ParameterElement element) {
+        int foundIndex = namedArguments.indexOf(element.name);
+        if (foundIndex != -1) {
+          result.add(compiledArguments[offset + foundIndex]);
+        } else {
+          result.add(compileDefaultValue(element));
+        }
+      });
+    }
+    return result;
+  }
+
+  /// This is a version of [makeArgumentsList] that works for a `Link`
+  /// representation of arguments.
+  /*<T>*/ List/*<T>*/ makeArgumentsList2(
       Link<Node> arguments,
       FunctionElement element,
       /*T*/ compileArgument(Node argument),
       /*T*/ compileDefaultValue(ParameterElement element)) {
     assert(invariant(element, element.isImplementation));
     List/*<T>*/ result = new List();
 
     FunctionSignature parameters = element.functionSignature;
     parameters.forEachRequiredParameter((ParameterElement element) {
       result.add(compileArgument(arguments.head));
@@ skipping 24 matching lines @@
         if (foundIndex != -1) {
           result.add(compiledNamedArguments[foundIndex]);
         } else {
           result.add(compileDefaultValue(element));
         }
       });
     }
     return result;
   }
 
+
   /**
    * Fills [list] with the arguments in the order expected by
    * [callee], and where [caller] is a synthesized element
    *
    * [compileArgument] is a function that returns a compiled version
    * of a parameter of [callee].
    *
    * [compileConstant] is a function that returns a compiled constant
    * of an optional argument that is not in the parameters of [callee].
    *
@@ skipping 47 matching lines @@
     if (signature.optionalParametersAreNamed) {
       namedParameters =
           signature.optionalParameters.mapToList((e) => e.name);
     }
     Selector selector = new Selector.call(callee.name,
                                           caller.library,
                                           signature.parameterCount,
                                           namedParameters);
 
     if (!selector.applies(callee, world)) return false;
-    list.addAll(selector.makeArgumentsList(nodes,
-                                           callee,
-                                           internalCompileArgument,
-                                           compileConstant));
+    list.addAll(selector.makeArgumentsList2(nodes,
+                                            callee,
+                                            internalCompileArgument,
+                                            compileConstant));
 
     return true;
   }
 
   static bool sameNames(List<String> first, List<String> second) {
     for (int i = 0; i < first.length; i++) {
       if (first[i] != second[i]) return false;
     }
     return true;
   }
@@ skipping 164 matching lines @@
 
   Selector extendIfReachesAll(Compiler compiler) {
     bool canReachAll = compiler.enabledInvokeOn
         && mask.needsNoSuchMethodHandling(this, compiler.world);
     return canReachAll
         ? new TypedSelector(
             compiler.typesTask.dynamicType, this, compiler.world)
         : this;
   }
 }