Canonicalize bound closures for non-optional-arg methods.

lib/compiler/implementation/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 13 matching lines @@
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsClosureClass = false;
   final Namer namer;
   NativeEmitter nativeEmitter;
   StringBuffer boundClosureBuffer;
   StringBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
+  final Map<int, String> boundClosureCache;
 
   CodeEmitterTask(Compiler compiler)
       : namer = compiler.namer,
         boundClosureBuffer = new StringBuffer(),
         mainBuffer = new StringBuffer(),
+        boundClosureCache = new Map<int, String>(),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   String get name() => 'CodeEmitter';
 
   String get defineClassName()
       => '${namer.ISOLATE}.\$defineClass';
   String get finishClassesName()
       => '${namer.ISOLATE}.\$finishClasses';
@@ skipping 572 matching lines @@
       });
     }
   }
 
   void emitDynamicFunctionGetter(FunctionElement member,
                                  defineInstanceMember(String invocationName,
                                                       String definition)) {
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
-    // 'foo'. Then we generate the following code (in pseudo Dart):
+    // 'foo'. Then we generate the following code (in pseudo Dart/Js):

[kasperl, 2012/05/30 08:15:51]

Js -> JavaScript

[floitsch, 2012/05/30 13:24:07]

Done.

     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
-    //    get foo() { return new BoundClosure499(this); }
+    //    get foo() { return new BoundClosure499(this, "foo"); }
     // }
     // class BoundClosure499 extends Closure {
     //   var self;
-    //   BoundClosure499(this.self);
-    //   $call3(x, y, z) { return self.foo(x, y, z); }
+    //   BoundClosure499(this.self, this.name);
+    //   $call3(x, y, z) { return self[name](x, y, z); }
     // }
 
     // TODO(floitsch): share the closure classes with other classes
-    // if they share methods with the same signature.
+    // if they share methods with the same signature. Currently we do this only
+    // if there are no optional parameters.

[ngeoffray, 2012/05/30 10:23:33]

Explain why.

[floitsch, 2012/05/30 13:24:07]

Done.

 
-    // The closure class.
-    SourceString name = const SourceString("BoundClosure");
-    ClassElement closureClassElement =
-        new ClosureClassElement(compiler, member.getCompilationUnit());
-    String mangledName = namer.getName(closureClassElement);
-    String superName = namer.getName(closureClassElement.superclass);
-    needsClosureClass = true;
+    bool hasOptionalParameters = member.optionalParameterCount(compiler) != 0;
+    int parameterCount = member.parameterCount(compiler);
+    member.parameterCount(compiler);

[kasperl, 2012/05/30 08:15:51]

This looks fishy.

[floitsch, 2012/05/30 13:24:07]

removed.

 
-    // Define the constructor with a name so that Object.toString can
-    // find the class name of the closure class.
-    boundClosureBuffer.add("$defineClassName('$mangledName', '$superName', ");
-    boundClosureBuffer.add("function $name(self) { this.self = self; }, {\n");
+    String closureClass = null;

[kasperl, 2012/05/30 08:15:51]

Maybe use something ala:

   String closureClass = hasOptionalParameters
       ? null
       : boundClosureCache[parameterCount];

[floitsch, 2012/05/30 13:24:07]

Done.

+    if (!hasOptionalParameters) {
+      closureClass = boundClosureCache[parameterCount];
+    }
+    if (closureClass === null) {
+      // Either the class was not cached yet, or there are optional parameters.
+      // Create a new closure class.
+      SourceString name = const SourceString("BoundClosure");
+      ClassElement closureClassElement =
+          new ClosureClassElement(compiler, member.getCompilationUnit());
+      String mangledName = namer.getName(closureClassElement);
+      String superName = namer.getName(closureClassElement.superclass);
+      needsClosureClass = true;
 
-    // Now add the methods on the closure class. The instance method does not
-    // have the correct name. Since [addParameterStubs] use the name to create
-    // its stubs we simply create a fake element with the correct name.
-    // Note: the callElement will not have any enclosingElement.
-    FunctionElement callElement =
-        new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
+      // Define the constructor with a name so that Object.toString can
+      // find the class name of the closure class.
+      boundClosureBuffer.add("$defineClassName('$mangledName', '$superName', ");
+      boundClosureBuffer.add("['self', 'target'], {\n");
 
-    int parameterCount = member.parameterCount(compiler);
-    String invocationName =
-        namer.instanceMethodName(member.getLibrary(),
-                                 callElement.name, parameterCount);
-    String targetName = namer.instanceMethodName(member.getLibrary(),

[floitsch, 2012/05/25 14:17:21]

This line has been moved down.

-                                                 member.name, parameterCount);
-    List<String> arguments = new List<String>(parameterCount);
-    for (int i = 0; i < parameterCount; i++) {
-      arguments[i] = "arg$i";
+      // Now add the methods on the closure class. The instance method does not
+      // have the correct name. Since [addParameterStubs] use the name to create
+      // its stubs we simply create a fake element with the correct name.
+      // Note: the callElement will not have any enclosingElement.
+      FunctionElement callElement =
+          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
+
+      String invocationName =
+          namer.instanceMethodName(member.getLibrary(),
+                                   callElement.name, parameterCount);
+      List<String> arguments = new List<String>(parameterCount);
+      for (int i = 0; i < parameterCount; i++) {
+        arguments[i] = "arg$i";

[kasperl, 2012/05/30 08:15:51]

I wonder if a shorter name wouldn't be as nice. p0, p1?

[floitsch, 2012/05/30 13:24:07]

Done.

+      }
+      String joinedArgs = Strings.join(arguments, ", ");
+      boundClosureBuffer.add(
+          "$invocationName: function($joinedArgs) {");
+      boundClosureBuffer.add(" return this.self[this.target]($joinedArgs);");
+      boundClosureBuffer.add(" }");
+      addParameterStubs(callElement, (String stubName, String memberValue) {
+        boundClosureBuffer.add(',\n $stubName: $memberValue');
+      });
+      boundClosureBuffer.add("\n});\n");
+
+      closureClass = namer.isolateAccess(closureClassElement);

[floitsch, 2012/05/25 14:17:21]

Starting at 696 we have lines that weren't in the previous revision. Otherwise
the code just has been indented.

+
+      // Cache it.
+      if (!hasOptionalParameters) {
+        boundClosureCache[parameterCount] = closureClass;
+      }
     }
-    String joinedArgs = Strings.join(arguments, ", ");
-    boundClosureBuffer.add(
-        " $invocationName: function($joinedArgs) {");
-    boundClosureBuffer.add(" return this.self.$targetName($joinedArgs);");
-    boundClosureBuffer.add(" }");
-    addParameterStubs(callElement, (String stubName, String memberValue) {
-      boundClosureBuffer.add(',\n $stubName: $memberValue');
-    });
-    boundClosureBuffer.add("\n});\n");
 
     // And finally the getter.
     String getterName = namer.getterName(member.getLibrary(), member.name);
-    String closureClass = namer.isolateAccess(closureClassElement);
-    defineInstanceMember(getterName,
-                         "function() { return new $closureClass(this); }");
+    String targetName = namer.instanceMethodName(member.getLibrary(),
+                                                 member.name, parameterCount);
+    defineInstanceMember(
+        getterName,
+        "function() { return new $closureClass(this, '$targetName'); }");
   }
 
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              void defineInstanceMember(String invocationName,
                                                        String definition)) {
     String getter;
     if (member.kind == ElementKind.GETTER) {
       getter = "this.${namer.getterName(member.getLibrary(), member.name)}()";
     } else {
@@ skipping 269 matching lines @@
       mainBuffer.add('function init() {\n');
       mainBuffer.add('  $isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }