dart2js: fix named arguments with Function.apply in the startup emitter.

pkg/compiler/lib/src/js_emitter/startup_emitter/fragment_emitter.dart

 // Copyright (c) 2015, 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.
 
 part of dart2js.js_emitter.startup_emitter.model_emitter;
 
 /// The name of the property that stores the tear-off getter on a static
 /// function.
 ///
 /// This property is only used when isolates are used.
@@ skipping 595 matching lines @@
     List<js.Property> properties = <js.Property>[];
 
     if (cls.superclass == null) {
       properties.add(new js.Property(js.string("constructor"),
       classReference(cls)));
       properties.add(new js.Property(namer.operatorIs(cls.element),
       js.number(1)));
     }
 
     allMethods.forEach((Method method) {
-      emitInstanceMethod(method).forEach((js.Name name, js.Expression code) {
+      emitInstanceMethod(method)
+          .forEach((js.Expression name, js.Expression code) {
         properties.add(new js.Property(name, code));
       });
     });
 
     return new js.ObjectInitializer(properties);
   }
 
   /// Generates a getter for the given [field].
   Method generateGetter(Field field) {
     assert(field.needsGetter);
@@ skipping 45 matching lines @@
 
     return [getters, setters].expand((x) => x);
   }
 
   /// Emits the given instance [method].
   ///
   /// The given method may be a stub-method (for example for is-checks).
   ///
   /// If it is a Dart-method, all necessary stub-methods are emitted, too. In
   /// that case the returned map contains more than just one entry.
-  Map<js.Name, js.Expression> emitInstanceMethod(Method method) {
-    Map<js.Name, js.Expression> jsMethods = <js.Name, js.Expression>{};
+  ///
+  /// If the method is a closure call-method, also returns the necessary
+  /// properties in case the closure can be applied.
+  Map<js.Expression, js.Expression> emitInstanceMethod(Method method) {
+    var properties = <js.Expression, js.Expression>{};
 
-    jsMethods[method.name] = method.code;
+    properties[method.name] = method.code;
     if (method is InstanceMethod) {
       for (ParameterStubMethod stubMethod in method.parameterStubs) {
-        jsMethods[stubMethod.name] = stubMethod.code;
+        properties[stubMethod.name] = stubMethod.code;
+      }
+
+      if (method.isClosureCallMethod && method.canBeApplied) {
+        properties[js.string(namer.callCatchAllName)] =
+            js.quoteName(method.name);
+        properties[js.string(namer.requiredParameterField)] =
+            js.number(method.requiredParameterCount);
+        properties[js.string(namer.defaultValuesField)] =
+            js.js('function() { return #; }',
+                  _encodeOptionalParameterDefaultValues(method));
       }
     }
 
-    return jsMethods;
+    return properties;
   }
 
   /// Emits the inheritance block of the fragment.
   ///
   /// In this section prototype chains are updated and mixin functions are
   /// copied.
   js.Statement emitInheritance(Fragment fragment) {
     List<js.Expression> inheritCalls = <js.Expression>[];
     List<js.Expression> mixinCalls = <js.Expression>[];
 
@@ skipping 49 matching lines @@
     // TODO(herhut): Replace [js.LiteralNull] with [js.ArrayHole].
     if (method.optionalParameterDefaultValues is List) {
       List<ConstantValue> defaultValues = method.optionalParameterDefaultValues;
       Iterable<js.Expression> elements =
           defaultValues.map(generateConstantReference);
       return new js.ArrayInitializer(elements.toList());
     } else {
       Map<String, ConstantValue> defaultValues =
           method.optionalParameterDefaultValues;
       List<js.Property> properties = <js.Property>[];
-      defaultValues.forEach((String name, ConstantValue value) {
+      List<String> names = defaultValues.keys.toList(growable: false);
+      // Sort the names the same way we sort them for the named-argument calling
+      // convention.
+      names.sort();
+
+      for (String name in names) {
+        ConstantValue value = defaultValues[name];
         properties.add(new js.Property(js.string(name),
         generateConstantReference(value)));
-      });
+      }
       return new js.ObjectInitializer(properties);
     }
   }
 
   /// Emits the statement that installs a tear off for a method.
   ///
   /// Tear-offs might be passed to `Function.apply` which means that all
   /// calling-conventions (with or without optional positional/named arguments)
   /// are possible. As such, the tear-off needs enough information to fill in
   /// missing parameters.
@@ skipping 33 matching lines @@
       isIntercepted = backend.isInterceptedMethod(method.element);
     }
     int requiredParameterCount = 0;
     js.Expression optionalParameterDefaultValues = new js.LiteralNull();
     if (method.canBeApplied) {
       requiredParameterCount = method.requiredParameterCount;
       optionalParameterDefaultValues =
           _encodeOptionalParameterDefaultValues(method);
     }
 
-// TODO(floitsch): this can be more efficient.
+    // TODO(floitsch): this can be more efficient.
     return js.js.statement('''
         installTearOff(#container, #getterName, #isStatic, #isIntercepted,
                        #requiredParameterCount, #optionalParameterDefaultValues,
                        #callNames, #funsOrNames, #funType)''',
         {
           "container": container,
           "getterName": js.quoteName(method.tearOffName),
           "isStatic": new js.LiteralBool(method.isStatic),
           "isIntercepted": new js.LiteralBool(isIntercepted),
           "requiredParameterCount": js.number(requiredParameterCount),
@@ skipping 383 matching lines @@
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
     statements.add(js.js.statement("setOrUpdateLeafTags(#);",
         js.objectLiteral(leafTags)));
     statements.add(subclassAssignment);
 
     return new js.Block(statements);
   }
 }