Generate tear-off closures dynamically.

dart/sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart

Index: dart/sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart
diff --git a/dart/sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart b/dart/sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart
index 935cc722b6982c5df1116bb93a873e4cef6fea53..98ba8b2c0528764636fbde85f6a2ae93360c6e94 100644
--- a/dart/sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart
+++ b/dart/sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart
@@ -25,7 +25,7 @@ class ContainerBuilder extends CodeEmitterHelper {
    */
   void addParameterStub(FunctionElement member,
                         Selector selector,
-                        DefineStubFunction defineStub,
+                        AddStubFunction addStub,
                         Set<String> alreadyGenerated) {
     FunctionSignature parameters = member.computeSignature(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
@@ -121,25 +121,30 @@ class ContainerBuilder extends CodeEmitterHelper {
           member, isInterceptedMethod, invocationName,
           parametersBuffer, argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
-    } else {
+    } else if (member.isInstanceMember()) {
       body = [js.return_(
           js('this')[namer.getNameOfInstanceMember(member)](argumentsBuffer))];
+    } else {
+      body = [js.return_(namer.elementAccess(member)(argumentsBuffer))];
     }
 
     jsAst.Fun function = js.fun(parametersBuffer, body);
 
-    defineStub(invocationName, function);
+    addStub(selector, function);
+  }
 
-    String reflectionName = task.getReflectionName(selector, invocationName);
-    if (reflectionName != null) {
-      var reflectable =
-          js(backend.isAccessibleByReflection(member) ? '1' : '0');
-      defineStub('+$reflectionName', reflectable);
+  void addParameterStubs(FunctionElement member, AddStubFunction defineStub,
+                         [bool canTearOff = false]) {
+    if (member.enclosingElement.isClosure()) {
+      ClosureClassElement cls = member.enclosingElement;
+      if (cls.supertype.element == compiler.boundClosureClass) {
+        compiler.internalErrorOnElement(cls.methodElement, 'Bound closure1.');
+      }
+      if (cls.methodElement.isInstanceMember()) {
+        compiler.internalErrorOnElement(cls.methodElement, 'Bound closure2.');
+      }
     }
-  }
 
-  void addParameterStubs(FunctionElement member,
-                         DefineStubFunction defineStub) {
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, {c, d});
@@ -169,92 +174,63 @@ class ContainerBuilder extends CodeEmitterHelper {
     // 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>();
-    bool isClosureInvocation =
-        member.name == namer.closureInvocationSelectorName;
-    if (backend.isNeededForReflection(member) ||
-        (compiler.enabledFunctionApply && isClosureInvocation)) {
-      // If [Function.apply] is called, we pessimistically compile all
-      // possible stubs for this closure.
-      FunctionSignature signature = member.computeSignature(compiler);
-      Set<Selector> selectors = signature.optionalParametersAreNamed
-          ? computeSeenNamedSelectors(member)
-          : computeOptionalSelectors(signature, member);
-      for (Selector selector in selectors) {
-        addParameterStub(member, selector, defineStub, generatedStubNames);
-      }
-      if (signature.optionalParametersAreNamed && isClosureInvocation) {
-        addCatchAllParameterStub(member, signature, defineStub);
-      }
-    } else {
-      Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
-      if (selectors == null) return;
-      for (Selector selector in selectors) {
-        if (!selector.applies(member, compiler)) continue;
-        addParameterStub(member, selector, defineStub, generatedStubNames);
-      }
+    Set<Selector> selectors = null;

[kasperl, 2013/11/29 10:10:55]

Maybe use ?: so the comment about not needing stubs for static methods goes with
the null value.

[ahe, 2013/12/06 15:57:53]

Done.

+    if (member.isInstanceMember()) {
+      // No stubs needed for static methods.
+      selectors = compiler.codegenWorld.invokedNames[member.name];
     }
-  }
 
-  Set<Selector> computeSeenNamedSelectors(FunctionElement element) {
-    Set<Selector> selectors = compiler.codegenWorld.invokedNames[element.name];
-    Set<Selector> result = new Set<Selector>();
-    if (selectors == null) return result;
-    for (Selector selector in selectors) {
-      if (!selector.applies(element, compiler)) continue;
-      result.add(selector);
+    /// Returns all closure call selectors renamed to match this member.
+    Set<Selector> callSelectorsAsNamed() {
+      if (!canTearOff) return null;
+      Set<Selector> callSelectors = compiler.codegenWorld.invokedNames[
+          namer.closureInvocationSelectorName];
+      if (callSelectors == null) return null;
+      return callSelectors.map((Selector callSelector) {
+        return new Selector.call(
+            member.name, member.getLibrary(),
+            callSelector.argumentCount, callSelector.namedArguments);
+      }).toSet();
     }
-    return result;
-  }
-
-  void addCatchAllParameterStub(FunctionElement member,
-                                FunctionSignature signature,
-                                DefineStubFunction defineStub) {
-    // See Primities.applyFunction in js_helper.dart for details.
-    List<jsAst.Property> properties = <jsAst.Property>[];
-    for (Element element in signature.orderedOptionalParameters) {
-      String jsName = backend.namer.safeName(element.name);
-      Constant value = compiler.constantHandler.initialVariableValues[element];
-      jsAst.Expression reference = null;
-      if (value == null) {
-        reference = new jsAst.LiteralNull();
-      } else {
-        reference = task.constantReference(value);
+    if (selectors == null) {
+      selectors = callSelectorsAsNamed();
+      if (selectors == null) return;
+    } else {
+      Set<Selector> callSelectors = callSelectorsAsNamed();
+      if (callSelectors != null) {
+        selectors = selectors.union(callSelectors);
       }
-      properties.add(new jsAst.Property(js.string(jsName), reference));
     }
-    defineStub(
-        backend.namer.callCatchAllName,
-        js.fun([], js.return_(new jsAst.ObjectInitializer(properties))));
-  }
-
-  /**
-   * 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,
-                               <String>[]));
-
-    // 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,
-                                 <String>[]));
+    Set<Selector> untypedSelectors = new Set();
+    if (selectors != null) {
+      for (Selector selector in selectors) {
+        if (!selector.appliesUnnamed(member, compiler)) continue;
+        if (untypedSelectors.add(selector.asUntyped)) {
+          // TODO(ahe): Is the last argument to [addParameterStub] needed?
+          addParameterStub(member, selector, defineStub, new Set<String>());
+        }
+      }
+    }
+    if (canTearOff) {
+      selectors = compiler.codegenWorld.invokedNames[
+          namer.closureInvocationSelectorName];
+      if (selectors != null) {
+        for (Selector selector in selectors) {
+          selector = new Selector.call(
+              member.name, member.getLibrary(),
+              selector.argumentCount, selector.namedArguments);
+          if (!selector.appliesUnnamed(member, compiler)) continue;
+          if (untypedSelectors.add(selector)) {
+            // TODO(ahe): Is the last argument to [addParameterStub] needed?
+            addParameterStub(member, selector, defineStub, new Set<String>());
+          }
+        }
+      }
     }
-    return selectors;
   }
 
   void emitStaticFunctionGetters(CodeBuffer eagerBuffer) {
+    return;
     task.addComment('Static function getters', task.mainBuffer);
     for (FunctionElement element in
              Elements.sortedByPosition(staticGetters.keys)) {
@@ -276,6 +252,7 @@ class ContainerBuilder extends CodeEmitterHelper {
   }
 
   void emitStaticFunctionClosures() {
+    return;
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in
@@ -309,7 +286,12 @@ class ContainerBuilder extends CodeEmitterHelper {
       closureBuilder.addProperty('',
           js.string("$superName;${fieldNames.join(',')}"));
 
-      addParameterStubs(callElement, closureBuilder.addProperty);
+      addParameterStubs(
+          callElement,
+          (Selector selector, jsAst.Fun function) {
+            closureBuilder.addProperty(
+                namer.invocationName(selector), function);
+          });
 
       void emitFunctionTypeSignature(Element method, FunctionType methodType) {
         RuntimeTypes rti = backend.rti;
@@ -372,7 +354,7 @@ class ContainerBuilder extends CodeEmitterHelper {
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
-                                 DefineStubFunction defineStub) {
+                                 AddPropertyFunction addProperty) {
     assert(invariant(member, member.isDeclaration));
     assert(task.instantiatedClasses.contains(compiler.boundClosureClass));
     // For every method that has the same name as a property-get we create a
@@ -442,7 +424,12 @@ class ContainerBuilder extends CodeEmitterHelper {
             js('this')[fieldNames[1]]['call'](arguments)));
     boundClosureBuilder.addProperty(invocationName, fun);
 
-    addParameterStubs(callElement, boundClosureBuilder.addProperty);
+    addParameterStubs(
+        callElement,
+        (Selector selector, jsAst.Fun function) {
+          boundClosureBuilder.addProperty(
+              namer.invocationName(selector), function);
+        });
 
     void emitFunctionTypeSignature(Element method, FunctionType methodType) {
       jsAst.Expression encoding = backend.rti.getSignatureEncoding(
@@ -487,7 +474,7 @@ class ContainerBuilder extends CodeEmitterHelper {
     jsAst.Expression getterFunction = js.fun(
         parameters, js.return_(js(closureClass).newWith(arguments)));
 
-    defineStub(getterName, getterFunction);
+    addProperty(getterName, getterFunction);
   }
 
   /**
@@ -497,7 +484,7 @@ class ContainerBuilder extends CodeEmitterHelper {
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
-                             DefineStubFunction defineStub) {
+                             AddPropertyFunction addProperty) {
     assert(invariant(member, member.isDeclaration));
     LibraryElement memberLibrary = member.getLibrary();
     // If the method is intercepted, the stub gets the
@@ -549,7 +536,7 @@ class ContainerBuilder extends CodeEmitterHelper {
             parameters,
             js.return_(buildGetter()[closureCallName](arguments)));
 
-        defineStub(invocationName, function);
+        addProperty(invocationName, function);
       }
     }
   }
@@ -566,10 +553,6 @@ class ContainerBuilder extends CodeEmitterHelper {
       if (selectors != null && !selectors.isEmpty) {
         emitCallStubForGetter(member, selectors, builder.addProperty);
       }
-    } else if (member.isFunction()) {
-      if (compiler.codegenWorld.hasInvokedGetter(member, compiler)) {
-        emitDynamicFunctionGetter(member, builder.addProperty);
-      }
     }
   }
 
@@ -595,30 +578,181 @@ class ContainerBuilder extends CodeEmitterHelper {
     jsAst.Expression code = backend.generatedCode[member];
     if (code == null) return;
     String name = namer.getNameOfMember(member);
-    if (backend.isInterceptedMethod(member)) {
-      task.interceptorEmitter.interceptorInvocationNames.add(name);
+    task.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
+    FunctionSignature parameters = member.computeSignature(compiler);
+    bool needsStubs = !parameters.optionalParameters.isEmpty;
+    bool canTearOff = false;
+    bool isClosure = false;
+    String tearOffName;
+    if (!member.isFunction() || member.isConstructor() || member.isAccessor()) {
+      canTearOff = false;
+    } else if (member.isInstanceMember()) {
+      if (member.getEnclosingClass().isClosure()) {
+        canTearOff = false;
+        isClosure = true;
+      } else {
+        // Careful with operators.
+        canTearOff = compiler.codegenWorld.hasInvokedGetter(member, compiler);
+        tearOffName = namer.getterName(member);
+      }
+    } else {
+      canTearOff =
+          compiler.codegenWorld.staticFunctionsNeedingGetter.contains(member);
+      tearOffName = namer.getStaticClosureName(member);
     }
-    code = task.metadataEmitter.extendWithMetadata(member, code);
-    builder.addProperty(name, code);
-    String reflectionName = task.getReflectionName(member, name);
-    if (reflectionName != null) {
-      var reflectable =
-          js(backend.isAccessibleByReflection(member) ? '1' : '0');
-      builder.addProperty('+$reflectionName', reflectable);
-      jsAst.Node defaultValues =
-          task.metadataEmitter.reifyDefaultArguments(member);
-      if (defaultValues != null) {
-        String unmangledName = member.name;
-        builder.addProperty('*$unmangledName', defaultValues);
+
+    bool canBeReflected = backend.isAccessibleByReflection(member);
+    bool needStructuredInfo = canTearOff || canBeReflected || compiler.enabledFunctionApply;

[kasperl, 2013/11/29 10:10:55]

Long line.

[ahe, 2013/12/06 15:57:53]

Done.

+    if (!needStructuredInfo) {
+      builder.addProperty(name, code);
+      if (needsStubs) {
+        addParameterStubs(
+            member,
+            (Selector selector, jsAst.Fun function) {
+              builder.addProperty(namer.invocationName(selector), function);
+            });
       }
+      return;
     }
-    if (member.isInstanceMember()) {
-      // TODO(ahe): Where is this done for static/top-level methods?
-      FunctionSignature parameters = member.computeSignature(compiler);
-      if (!parameters.optionalParameters.isEmpty) {
-        addParameterStubs(member, builder.addProperty);
+
+    if (canTearOff) {
+      assert(invariant(member, !member.isGenerativeConstructor()));
+      assert(invariant(member, !member.isGenerativeConstructorBody()));
+      assert(invariant(member, !member.isConstructor()));
+    }
+
+    // This element is needed for reflection or needs additional stubs. So we
+    // need to retain additional information.
+
+    // The information is stored in an array with this format:
+    //
+    // 1.   The JS function for this member.
+    // 2.   First stub.
+    // 3.   Name of first stub.
+    // ...
+    // M.   Call name of this member.
+    // M+1. Call name of first stub.
+    // ...
+    // N.   Getter name for tearOff.
+    // N+1. (Required parameter count << 1) + (member.isAccessor() ? 1 : 0).
+    // N+2. (Optional parameter count << 1) +
+    //                      (parameters.optionalParametersAreNamed ? 1 : 0).
+    // N+3. Index to function type in constant pool.
+    // N+4. First default argument.
+    // ...
+    // O.   First parameter name (if needed for reflection or Function.apply).
+    // ...
+    // P.   Unmangled name (if reflectable).
+    // P+1. First metadata (if reflectable).
+    // ...
+
+    List expressions = [];
+
+    Selector callSelector;
+    if (member.isFunction()) {
+      callSelector =
+          new Selector.fromElement(member, compiler).toCallSelector();
+    }
+
+    // On [requiredParameterCount], the lower bit is set if this method can be
+    // called reflectively.
+    int requiredParameterCount = parameters.requiredParameterCount << 1;
+    if (member.isAccessor()) requiredParameterCount++;
+
+    int optionalParameterCount = parameters.optionalParameterCount << 1;
+    if (parameters.optionalParametersAreNamed) optionalParameterCount++;
+
+    expressions.add(code);
+
+    String callSelectorString =
+        callSelector == null ? null : '"${namer.invocationName(callSelector)}"';
+    List tearOffInfo =
+        [new jsAst.LiteralString('$callSelectorString /* tearOffInfo */')];
+
+    if (needsStubs || canTearOff) {
+      addParameterStubs(member, (Selector selector, jsAst.Fun function) {
+        expressions.add(function);
+        if (member.isInstanceMember()) {
+          Set invokedSelectors =
+              compiler.codegenWorld.invokedNames[member.name];
+          if (invokedSelectors != null && invokedSelectors.contains(selector)) {
+            expressions.add(js.string(namer.invocationName(selector)));
+          } else {
+            // Don't add a stub for calling this as a regular instance method,
+            // we only need the "call" stub for implicit closures of this
+            // method.
+            expressions.add("null");
+          }
+        } else {
+          // Static methods don't need "named" stubs as the default arguments
+          // are inlined at call sites. But static methods might need "call"
+          // stubs for implicit closures.
+          expressions.add("null");
+          // TOOD(ahe): Since we know when reading static data versus instance
+          // data, we can eliminate this element.
+        }
+        Set<Selector> callSelectors = compiler.codegenWorld.invokedNames[
+            namer.closureInvocationSelectorName];
+        Selector callSelector = selector.toCallSelector();
+        String callSelectorString = 'null';
+        if (canTearOff && callSelectors != null && callSelectors.contains(callSelector)) {

[kasperl, 2013/11/29 10:10:55]

Long lines (there are a number of occurrences in this method).

[ahe, 2013/12/06 15:57:53]

Done.

+          callSelectorString = '"${namer.invocationName(callSelector)}"';
+        }
+        tearOffInfo.add(new jsAst.LiteralString('$callSelectorString /* tearOffInfo */'));
+      }, canTearOff);
+    }
+
+    jsAst.Expression memberTypeExpression;
+    if ((canTearOff || canBeReflected) && !member.isGenerativeConstructorBody()) {
+      DartType memberType = member.computeType(compiler);
+      if (memberType.containsTypeVariables) {
+        jsAst.Expression thisAccess = js(r'this.$receiver');
+        memberTypeExpression =
+            backend.rti.getSignatureEncoding(memberType, thisAccess);
+      } else {
+        memberTypeExpression =
+            js.toExpression(task.metadataEmitter.reifyType(memberType));
+      }
+    } else {
+      memberTypeExpression = js('null');
+    }
+
+    expressions
+        ..addAll(tearOffInfo)
+        ..add((tearOffName == null || member.isAccessor())
+              ? js("null") : js.string(tearOffName))
+        ..add(requiredParameterCount)
+        ..add(optionalParameterCount)
+        ..add(memberTypeExpression)
+        ..addAll(task.metadataEmitter.reifyDefaultArguments(member));
+
+    if (canBeReflected || compiler.enabledFunctionApply) {
+      parameters.orderedForEachParameter((Element parameter) {
+        expressions.add(task.metadataEmitter.reifyName(parameter.name));
+      });
+    }
+    if (canBeReflected) {
+      jsAst.LiteralString reflectionName;
+      if (member.isConstructor()) {
+        String reflectionNameString = task.getReflectionName(member, name);
+        reflectionName =
+            new jsAst.LiteralString(
+                '"new ${Elements.reconstructConstructorName(member)}" /* $reflectionNameString */');
+      } else {
+        reflectionName = js.string(member.name);
       }
+      expressions
+          ..add(reflectionName)
+          ..addAll(task.metadataEmitter.computeMetadata(member));
+    } else if (isClosure && compiler.enabledFunctionApply) {
+      expressions.add(js.string(member.name));
     }
+
+    builder.addProperty(name, js.toExpression(expressions));
+
+    // if (canTearOff) {
+    //   emitDynamicFunctionGetter(member, builder.addProperty);
+    // }
   }
 
   void addMemberField(VariableElement member, ClassBuilder builder) {