Implement Function.apply in dart2js.

lib/compiler/implementation/js_backend/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 458 matching lines @@
     // (1) No stub generated, call is direct.
     // (2) foo$2(a, b) => foo$4(a, b, null, null)
     // (3) foo$3(a, b, c) => foo$4(a, b, c, null)
     // (4) foo$3$c(a, b, c) => foo$4(a, b, c, null);
     // (5) foo$3$d(a, b, d) => foo$4(a, b, null, d);
     // (6) foo$4$c$d(a, b, c, d) => foo$4(a, b, c, d);
     // (7) Same as (5).
     //
     // We need to generate a stub for (5) because the order of the
     // stub arguments and the real method may be different.
-    Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
-    if (selectors == null) return;
-    // Keep a cache of which stubs have already been generated, to
-    // avoid duplicates. Note that even if selectors are
-    // canonicalized, we would still need this cache: a typed selector
-    // on A and a typed selector on B could yield the same stub.
     Set<String> generatedStubNames = new Set<String>();
-    for (Selector selector in selectors) {
-      if (!selector.applies(member, compiler)) continue;
-      addParameterStub(
-          member, selector, defineInstanceMember, generatedStubNames);
+    if (compiler.enabledFunctionApply
+        && member.name == Namer.CLOSURE_INVOCATION_NAME) {
+      // If [Function.apply] is called, we pessimistically compile all
+      // possible stubs for this closure.
+      // TODO(5074): This functionality only supports the new
+      // parameter specification, and this comment should be removed
+      // once the old specification is not supported.
+      FunctionSignature signature = member.computeSignature(compiler);
+      Set<Selector> selectors = signature.optionalParametersAreNamed
+          ? computeNamedSelectors(signature, member)
+          : computeOptionalSelectors(signature, member);
+      for (Selector selector in selectors) {
+        addParameterStub(
+            member, selector, defineInstanceMember, generatedStubNames);
+      }
+    } else {
+      Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
+      if (selectors == null) return;
+      // Keep a cache of which stubs have already been generated, to

[kasperl, 2012/10/09 11:35:18]

Where did the cache move? I guess the comment needs updating.

[ngeoffray, 2012/10/09 11:56:58]

Done.

+      // avoid duplicates. Note that even if selectors are
+      // canonicalized, we would still need this cache: a typed selector
+      // on A and a typed selector on B could yield the same stub.
+      for (Selector selector in selectors) {
+        if (!selector.applies(member, compiler)) continue;
+        addParameterStub(
+            member, selector, defineInstanceMember, generatedStubNames);
+      }
     }
   }
 
+  /**
+   * Compute the set of possible selectors in the presence of named
+   * parameters.
+   */
+  Set<Selector> computeNamedSelectors(FunctionSignature signature,
+                                      FunctionElement element) {
+    Set<Selector> selectors = new Set<Selector>();
+    // Add the selector that does not have any optional argument.
+    selectors.add(new Selector(SelectorKind.CALL,
+                               element.name,
+                               element.getLibrary(),
+                               signature.requiredParameterCount,
+                               <SourceString>[]));
+
+    // For each optional parameter, we iterator over the set of
+    // already computed selectors and create new selectors with that
+    // parameter now being passed.
+    signature.forEachOptionalParameter((Element element) {
+      // We will iterate over the set and add new selectors. Make a copy
+      // of a set to not change it while iterating.
+      Set<Selector> newSet = new Set<Selector>.from(selectors);

[kasperl, 2012/10/09 11:35:18]

Wouldn't it be simpler to collect the new selectors in another set and add them
in one step using addAll at the end? That way you don't have to copy the ever
growing set of all the selectors.

[ngeoffray, 2012/10/09 11:56:58]

Good point. Done.

+      newSet.forEach((Selector other) {
+        List<SourceString> namedArguments = [element.name];
+        namedArguments.addAll(other.namedArguments);
+        selectors.add(new Selector(other.kind,
+                                   other.name,
+                                   other.library,
+                                   other.argumentCount + 1,
+                                   namedArguments));
+      });
+    });
+    return selectors;
+  }
+
+  /**
+   * Compute the set of possible selectors in the presence of optional
+   * non-named parameters.
+   */
+  Set<Selector> computeOptionalSelectors(FunctionSignature signature,
+                                         FunctionElement element) {
+    Set<Selector> selectors = new Set<Selector>();
+    // Add the selector that does not have any optional argument.
+    selectors.add(new Selector(SelectorKind.CALL,
+                               element.name,
+                               element.getLibrary(),
+                               signature.requiredParameterCount,
+                               <SourceString>[]));
+
+    // For each optional parameter, we increment the number of passed
+    // argument.
+    for (int i = 1; i <= signature.optionalParameterCount; i++) {
+      selectors.add(new Selector(SelectorKind.CALL,
+                                 element.name,
+                                 element.getLibrary(),
+                                 signature.requiredParameterCount + i,
+                                 <SourceString>[]));
+    }
+    return selectors;
+  }
+
   bool instanceFieldNeedsGetter(Element member) {
     assert(member.isField());
     return compiler.codegenWorld.hasInvokedGetter(member, compiler);
   }
 
   bool instanceFieldNeedsSetter(Element member) {
     assert(member.isField());
     return (!member.modifiers.isFinalOrConst())
         && compiler.codegenWorld.hasInvokedSetter(member, compiler);
   }
@@ skipping 932 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;