Make static tear-off closures a class, like instance tear-off closures.

sdk/lib/_internal/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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 140 matching lines @@
 
     checkedClasses = new Set<ClassElement>();
     checkedTypedefs = new Set<TypedefElement>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
       if (t is InterfaceType) {
         checkedClasses.add(t.element);
       } else if (t is TypedefType) {
         checkedTypedefs.add(t.element);
       }
     });
+    print(compiler.resolverWorld.isChecks);
+    print(compiler.codegenWorld.isChecks);
   }
 
   ClassElement computeMixinClass(MixinApplicationElement mixinApplication) {
     ClassElement mixin = mixinApplication.mixin;
     while (mixin.isMixinApplication) {
       mixinApplication = mixin;
       mixin = mixinApplication.mixin;
     }
     return mixin;
   }
@@ skipping 1581 matching lines @@
     }
 
     return (ClassElement cls) => !unneededClasses.contains(cls);
   }
 
   void emitClosureClassIfNeeded(CodeBuffer buffer) {
     // The closure class could have become necessary because of the generation
     // of stubs.
     ClassElement closureClass = compiler.closureClass;
     if (needsClosureClass && !instantiatedClasses.contains(closureClass)) {
+      ClassElement objectClass = compiler.objectClass;
+      if (!instantiatedClasses.contains(objectClass)) {
+        generateClass(objectClass, bufferForElement(objectClass, buffer));
+      }
       generateClass(closureClass, bufferForElement(closureClass, buffer));
     }
   }
 
   void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       buffer.write('$finishClassesName($classesCollector,'
                    '$_$isolateProperties,'
                    '${_}null)$N');
 
@@ skipping 35 matching lines @@
 
     // Is it possible the primary function was inlined but the bailout was not?
     for (Element element in
              Elements.sortedByPosition(pendingElementsWithBailouts)) {
       CodeBuffer buffer = bufferForElement(element, eagerBuffer);
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
       emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
     }
   }
 
+  final Map<Element, Element> staticGetters = new Map<Element, Element>();
+
   void emitStaticFunctionGetters(CodeBuffer eagerBuffer) {
+    for (FunctionElement element in
+             Elements.sortedByPosition(staticGetters.keys)) {
+      Element closure = staticGetters[element];
+      CodeBuffer buffer = bufferForElement(element, eagerBuffer);
+      String closureClass = namer.isolateAccess(closure);
+      String name = namer.getStaticClosureName(element);
+      String staticName = namer.getName(element);
+
+      String closureName = namer.getStaticClosureName(element);
+      jsAst.Node assignment = js('$isolateProperties.$name = '
+          'new $closureClass($isolateProperties.$staticName, "$closureName")');

[ahe, 2013/05/16 20:07:56]

This broke deferred loading (and try.dartlang.org).

You're emitting a constant here, but not using bufferForConstant.  This means
that $ isn't the correct object.  We can take a look at that tomorrow or later.

[sra1, 2013/05/16 20:28:33]

This would 'just work' if static function closures were generated as a new kind
of constant, ClosureConstant, which works rather like a ConstructedConstant. 
The arguments would be the FunctionConstant referencing the raw static function
and the name string.
(It might even be reasonable to use ConstructedConstant directly).

[ahe, 2013/05/16 20:30:44]

I was thinking the same thing.  Well, up to the second comma.  Then you thought
ahead :-)

+      buffer.write(jsAst.prettyPrint(assignment, compiler));
+      buffer.write('$N');
+    }
+  }
+
+  void emitStaticFunctionClosures() {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in
              Elements.sortedByPosition(functionsNeedingGetter)) {
-      CodeBuffer buffer = bufferForElement(element, eagerBuffer);
+      String staticName = namer.getName(element);
+      String superName = namer.getName(compiler.closureClass);
+      String name = 'Closure\$${element.name.slowToString()}';
+      needsClosureClass = true;
 
-      // The static function 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.
+      ClassElement closureClassElement = new ClosureClassElement(
+          null, new SourceString(name), compiler, element,
+          element.getCompilationUnit());
+      // 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.closureInvocationSelectorName,
                                        element);
-      String staticName = namer.getName(element);
+
       String invocationName = namer.instanceMethodName(callElement);
-      String fieldAccess = '$isolateProperties.$staticName';
-      buffer.write("$fieldAccess.$invocationName$_=$_$fieldAccess$N");
+      String mangledName = namer.getName(closureClassElement);
 
-      addParameterStubs(callElement, (String name, jsAst.Expression value) {
-        jsAst.Expression assignment =
-            js('$isolateProperties.$staticName.$name = #', value);
-        buffer.write(jsAst.prettyPrint(assignment.toStatement(), compiler));
-        buffer.write('$N');
+      // Define the constructor with a name so that Object.toString can
+      // find the class name of the closure class.
+      ClassBuilder closureBuilder = new ClassBuilder();
+      // If a static function is used as a closure we need to add its name
+      // in case it is used in spawnFunction.
+      String methodName = namer.STATIC_CLOSURE_NAME_NAME;
+      emitBoundClosureClassHeader(
+          mangledName, superName, <String>[invocationName, methodName],
+          closureBuilder);
+
+      addParameterStubs(callElement, closureBuilder.addProperty);
+
+      DartType type = element.computeType(compiler);
+      getTypedefChecksOn(type).forEach((Element typedef) {
+        String operator = namer.operatorIs(typedef);
+        closureBuilder.addProperty(operator, js('true'));
       });
 
-      // If a static function is used as a closure we need to add its name
-      // in case it is used in spawnFunction.
-      String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
-      buffer.write('$fieldAccess.$fieldName$_=$_"$staticName"$N');
-      getTypedefChecksOn(element.computeType(compiler)).forEach(
-        (Element typedef) {
-          String operator = namer.operatorIs(typedef);
-          buffer.write('$fieldAccess.$operator$_=${_}true$N');
-        }
-      );
+      // TODO(ngeoffray): Cache common base classes for clsures, bound
+      // closures, and static closures that have common type checks.
+      boundClosures.add(
+          js('$classesCollector.$mangledName = #',
+              closureBuilder.toObjectInitializer()));
+
+      staticGetters[element] = closureClassElement;
     }
   }
 
   void emitBoundClosureClassHeader(String mangledName,
                                    String superName,
                                    List<String> fieldNames,
                                    ClassBuilder builder) {
     builder.addProperty('',
         js.string("$superName;${fieldNames.join(',')}"));
   }
@@ skipping 483 matching lines @@
     for (String jsName in addedJsNames.keys.toList()..sort()) {
       Selector selector = addedJsNames[jsName];
       jsAst.Expression method = generateMethod(jsName, selector);
       if (method != null) defineStub(jsName, method);
     }
   }
 
   String buildIsolateSetup(CodeBuffer buffer,
                            Element appMain,
                            Element isolateMain) {
-    String mainAccess = "${namer.isolateAccess(appMain)}";
+    String mainAccess = "${namer.isolateStaticClosureAccess(appMain)}";
     String currentIsolate = "${namer.CURRENT_ISOLATE}";
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
-    if (!compiler.codegenWorld.staticFunctionsNeedingGetter.contains(appMain)) {
-      Selector selector = new Selector.callClosure(0);
-      String invocationName = namer.invocationName(selector);
-      buffer.write("$mainAccess.$invocationName = $mainAccess$N");
-    }
     return "${namer.isolateAccess(isolateMain)}($mainAccess)";
   }
 
   String get nameOfDispatchPropertyInitializer => 'initializeDispatchProperty';
 
   jsAst.Expression generateDispatchPropertyInitialization() {
     String ref(Element element) {
       return '${namer.CURRENT_ISOLATE}.${namer.getName(element)}';
     }
 
@@ skipping 71 matching lines @@
         throw 'internal error';
       } else if (cls == backend.jsArrayClass ||
                  cls == backend.jsMutableArrayClass ||
                  cls == backend.jsFixedArrayClass ||
                  cls == backend.jsExtendableArrayClass) {
         condition = js('receiver.constructor == Array');
       } else if (cls == backend.jsStringClass) {
         condition = js('(typeof receiver) == "string"');
       } else if (cls == backend.jsNullClass) {
         condition = js('receiver == null');
-      } else if (cls == backend.jsFunctionClass) {
-        condition = js('(typeof receiver) == "function"');
       } else {
         throw 'internal error';
       }
       return js.if_(condition, buildReturnInterceptor(cls));
     }
 
     bool hasArray = false;
     bool hasBool = false;
     bool hasDouble = false;
-    bool hasFunction = false;
     bool hasInt = false;
     bool hasNull = false;
     bool hasNumber = false;
     bool hasString = false;
     bool hasNative = false;
     for (ClassElement cls in classes) {
       if (cls == backend.jsArrayClass ||
           cls == backend.jsMutableArrayClass ||
           cls == backend.jsFixedArrayClass ||
           cls == backend.jsExtendableArrayClass) hasArray = true;
       else if (cls == backend.jsBoolClass) hasBool = true;
       else if (cls == backend.jsDoubleClass) hasDouble = true;
-      else if (cls == backend.jsFunctionClass) hasFunction = true;
       else if (cls == backend.jsIntClass) hasInt = true;
       else if (cls == backend.jsNullClass) hasNull = true;
       else if (cls == backend.jsNumberClass) hasNumber = true;
       else if (cls == backend.jsStringClass) hasString = true;
       else {
         // TODO(sra): The set of classes includes classes mixed-in to
         // interceptor classes.
         // assert(cls == compiler.objectClass || cls.isNative());
         if (cls.isNative()) hasNative = true;
       }
@@ skipping 40 matching lines @@
     }
     if (hasNull) {
       block.statements.add(buildInterceptorCheck(backend.jsNullClass));
     } else {
       // Returning "undefined" or "null" here will provoke a JavaScript
       // TypeError which is later identified as a null-error by
       // [unwrapException] in js_helper.dart.
       block.statements.add(js.if_('receiver == null',
                                   js.return_(js('receiver'))));
     }
-    if (hasFunction) {
-      block.statements.add(buildInterceptorCheck(backend.jsFunctionClass));
-    }
     if (hasBool) {
       block.statements.add(buildInterceptorCheck(backend.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
       block.statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
 
     if (hasNative) {
@@ skipping 359 matching lines @@
       addComment(HOOKS_API_USAGE, mainBuffer);
       mainBuffer.add('function ${namer.isolateName}()$_{}\n');
       mainBuffer.add('init()$N$n');
       // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
       isolateProperties = namer.CURRENT_ISOLATE;
       mainBuffer.add(
           'var $isolateProperties$_=$_$isolatePropertiesName$N');
 
       if (!regularClasses.isEmpty ||
           !deferredClasses.isEmpty ||
-          !nativeClasses.isEmpty) {
+          !nativeClasses.isEmpty ||
+          !compiler.codegenWorld.staticFunctionsNeedingGetter.isEmpty) {
         // Shorten the code by using "$$" as temporary.
         classesCollector = r"$$";
         mainBuffer.add('var $classesCollector$_=$_{}$N$n');
       }
 
       // As a side-effect, emitting classes will produce "bound closures" in
       // [boundClosures].  The bound closures are JS AST nodes that add
       // properties to $$ [classesCollector].  The bound closures are not
       // emitted until we have emitted all other classes (native or not).
 
@@ skipping 25 matching lines @@
           generateClass(element, deferredBuffer);
         }
 
         deferredBuffer.add('$finishClassesName(\$\$,'
                            '$_${namer.CURRENT_ISOLATE},'
                            '$_$isolatePropertiesName)$N');
         // Reset the map.
         deferredBuffer.add("\$\$$_=${_}null$N$n");
       }
 
+      emitStaticFunctionClosures();
       emitClosureClassIfNeeded(mainBuffer);
 
       addComment('Bound closures', mainBuffer);
       // Now that we have emitted all classes, we know all the bound
       // closures that will be needed.
       for (jsAst.Node node in boundClosures) {
         // TODO(ahe): Some of these can be deferred.
         mainBuffer.add(jsAst.prettyPrint(node, compiler));
         mainBuffer.add("$N$n");
       }
@@ skipping 110 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // 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].
 """;