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
+      // 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);
+      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].
 """;