Implement reflective access to static methods.

dart/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 119 matching lines @@
    * typedefs and implicitly through type annotations in checked mode.
    */
   Set<FunctionType> checkedFunctionTypes;
 
   Map<ClassElement, Set<FunctionType>> checkedGenericFunctionTypes =
       new Map<ClassElement, Set<FunctionType>>();
 
   Set<FunctionType> checkedNonGenericFunctionTypes =
       new Set<FunctionType>();
 
+  /**
+   * For classes and libraries, record code for static/top-level members.
+   * Later, this code is emitted when the class or library is emitted.

[ngeoffray, 2013/07/17 07:35:57]

Would there be a way to just produce them when we produce the class?

[ahe, 2013/07/17 07:55:27]

Yes. I hope to clean this up.

However, there are, AFAIK, some important ordering issues related to bound
closures. So AFAIK, this isn't trivial.

I'll add a TODO.

[ngeoffray, 2013/07/17 08:08:42]

I agree it's not trivial.

+   * See [bufferForElement].
+   */
+  final Map<Element, List<CodeBuffer>> elementBuffers =
+      new Map<Element, List<CodeBuffer>>();
+
   void registerDynamicFunctionTypeCheck(FunctionType functionType) {
     ClassElement classElement = Types.getClassContext(functionType);
     if (classElement != null) {
       checkedGenericFunctionTypes.putIfAbsent(classElement,
           () => new Set<FunctionType>()).add(functionType);
     } else {
       checkedNonGenericFunctionTypes.add(functionType);
     }
   }
 
@@ skipping 1627 matching lines @@
     var metadata = buildMetadataFunction(classElement);
     if (metadata != null) {
       builder.addProperty("@", metadata);
     }
     emitClassGettersSetters(classElement, builder);
     if (!classElement.isMixinApplication) {
       emitInstanceMembers(classElement, builder);
     }
     emitIsTests(classElement, builder);
 
+    List<CodeBuffer> classBuffers = elementBuffers[classElement];
+    CodeBuffer statics = new CodeBuffer();
+    bool hasStatics = false;
+    if (classBuffers != null) {
+      statics.write('{$n');
+      elementBuffers.remove(classElement);
+      for (CodeBuffer classBuffer in classBuffers) {
+        // TODO(ahe): What about deferred?
+        if (classBuffer != null) {
+          hasStatics = true;
+          statics.addBuffer(classBuffer);
+        }
+      }
+      statics.write('}$n');
+    }
+    if (hasStatics) {
+      builder.addProperty('static', new jsAst.Blob(statics));
+    }
+
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     if (!buffer.isEmpty) {
       buffer.write(',$n$n');
     }
     buffer.write('$className:$_');
     buffer.write(jsAst.prettyPrint(builder.toObjectInitializer(), compiler));
     if (backend.retainName(classElement.name)) {
       buffer.write(',$n$n"+${classElement.name.slowToString()}": 0');
     }
   }
@@ skipping 1585 matching lines @@
         mainBuffer.add('(function(${namer.CURRENT_ISOLATE})$_{$n');
       }
 
       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(
           '$isolateProperties$_=$_$isolatePropertiesName$N');
 
+      emitStaticFunctions(mainBuffer);
+
       if (!regularClasses.isEmpty ||
           !deferredClasses.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
@@ skipping 34 matching lines @@
       for (jsAst.Node node in boundClosures) {
         // TODO(ahe): Some of these can be deferred.
         mainBuffer.add(jsAst.prettyPrint(node, compiler));
         mainBuffer.add("$N$n");
       }
 
       // After this assignment we will produce invalid JavaScript code if we use
       // the classesCollector variable.
       classesCollector = 'classesCollector should not be used from now on';
 
-      emitStaticFunctions(mainBuffer);
-
-      if (!libraryBuffers.isEmpty) {
+      if (!elementBuffers.isEmpty) {
         var oldClassesCollector = classesCollector;
         classesCollector = r"$$";
         if (compiler.enableMinification) {
           mainBuffer.write(';');
         }
         if (!mangledFieldNames.isEmpty) {
           var keys = mangledFieldNames.keys.toList();
           keys.sort();
           var properties = [];
           for (String key in keys) {
             var value = js.string('${mangledFieldNames[key]}');
             properties.add(new jsAst.Property(js.string(key), value));
           }
           var map = new jsAst.ObjectInitializer(properties);
           mainBuffer.write(
               jsAst.prettyPrint(
                   js('init.mangledNames = #', map).toStatement(), compiler));
           if (compiler.enableMinification) {
             mainBuffer.write(';');
           }
         }
         mainBuffer
             ..write(getReflectionDataParser())
             ..write('([$n');
 
-        var sortedLibraries = Elements.sortedByPosition(libraryBuffers.keys);
-        for (LibraryElement library in sortedLibraries) {
-          List<CodeBuffer> buffers = libraryBuffers[library];
+        var sortedElements = Elements.sortedByPosition(elementBuffers.keys);

[karlklose, 2013/07/17 08:01:40]

Type this variable (and also b in l. 3505)?

[ahe, 2013/07/17 08:31:24]

Done.

+        bool hasPendingStatics = false;
+        for (Element element in sortedElements) {
+          if (!element.isLibrary()) {
+            for (var b in elementBuffers[element]) {

[ngeoffray, 2013/07/17 07:35:57]

Add a TODO to remove this once you implement it for non-instantiated classes and
native classes?

[ahe, 2013/07/17 07:55:27]

I'm not sure this code would go away. Consider it an assertion.

[ngeoffray, 2013/07/17 08:08:42]

OK. So after reading the code again, I realize I misunderstood something. I
thought this was a way for you to know which static was not correctly
implemented (because it's on a native class, abstract, ....). It actually isn't.

So this check feels like a validation thing that we could do after doing the
emission. Would it make sense to add a validate method after emission that would
a) Make sure the internal data structure in the emitter make sense (like you're
doing here)
b) potentially do a run on the CodeBuffer to ensure it's valid syntax (but
that's long term).

[ahe, 2013/07/17 08:31:24]

If feel that would be easier to accomplish once I switch to generating statics
as part of the class as you suggested above at line 142.

+              if (b != null) {
+                hasPendingStatics = true;
+                compiler.reportInfo(
+                    element, MessageKind.GENERIC, {'text': 'Pending statics.'});
+                print(b.getText());
+              }
+            }
+            continue;
+          }
+          LibraryElement library = element;
+          List<CodeBuffer> buffers = elementBuffers[library];
           var buffer = buffers[0];
           var uri = library.canonicalUri;
           if (uri.scheme == 'file' && compiler.sourceMapUri != null) {
             // TODO(ahe): It is a hack to use compiler.sourceMapUri
             // here.  It should be relative to the main JavaScript
             // output file.
             uri = relativize(
                 compiler.sourceMapUri, library.canonicalUri, false);
           }
           if (buffer != null) {
@@ skipping 11 matching lines @@
           buffer = buffers[1];
           if (buffer != null) {
             deferredLibraries
                 ..write('["${library.getLibraryOrScriptName()}",$_')
                 ..write('"${uri}",$_')
                 ..write('[],$_')
                 ..write('{$n')
                 ..addBuffer(buffer)
                 ..write('}],$n');
           }
-          libraryBuffers[library] = const [];
+          elementBuffers[library] = const [];
+        }
+        if (hasPendingStatics) {
+          compiler.internalError('Pending statics (see above).');

[ngeoffray, 2013/07/17 07:35:57]

Is that an internal error, or a not yet implemented error? I'd prefer using the
latter to avoid confusing people in the team seeing a crash report.

[ahe, 2013/07/17 07:55:27]

It is an internal error.

If a static is "pending" it means that no code is generated for it.  This is an
error as we have not been able to eliminate the method using tree shaking, which
means that it might be called.

         }
         mainBuffer.write('])$N');
 
         emitFinishClassesInvocationIfNecessary(mainBuffer);
         classesCollector = oldClassesCollector;
       }
 
       emitStaticFunctionGetters(mainBuffer);
 
       emitRuntimeTypeSupport(mainBuffer);
@@ skipping 29 matching lines @@
       }
       compiler.assembledCode = mainBuffer.getText();
       outputSourceMap(mainBuffer, compiler.assembledCode, '');
 
       emitDeferredCode();
 
     });
     return compiler.assembledCode;
   }
 
-  final Map<LibraryElement, List<CodeBuffer>> libraryBuffers =
-      new Map<LibraryElement, List<CodeBuffer>>();
-
   CodeBuffer bufferForElement(Element element, CodeBuffer eagerBuffer) {
-    LibraryElement library = element.getLibrary();
-    List<CodeBuffer> buffers = libraryBuffers.putIfAbsent(
-        library, () => <CodeBuffer>[null, null]);
+    Element owner = element.getLibrary();
+    if (!element.isTopLevel() && !element.isNative()) {
+      // For static (not top level) elements, record their code in a buffer
+      // specific to the class. For now, not supported for native classes and
+      // native elements.
+      ClassElement cls =
+          element.getEnclosingClassOrCompilationUnit().declaration;
+      if (compiler.codegenWorld.instantiatedClasses.contains(cls)
+          && !cls.isNative()) {
+        owner = cls;
+      }
+    }
+    if (owner == null) {

[ngeoffray, 2013/07/17 07:35:57]

This looks too defensive.

[ahe, 2013/07/17 07:55:27]

At first sight, yes. But notice that if we don't check for null, we simply store
null in elementBuffers.

When I was debugging, it wasn't clear if that was the problem I had, so I wanted
to be sure. I prefer to keep the check.

+      throw 'Bad owner of $element';

[karlklose, 2013/07/17 08:01:40]

Could you call internalError instead?

[ahe, 2013/07/17 08:31:24]

Done.

+    }
+    List<CodeBuffer> buffers = elementBuffers.putIfAbsent(
+        owner, () => <CodeBuffer>[null, null]);
     bool deferred = isDeferred(element);
     int index = deferred ? 1 : 0;
     CodeBuffer buffer = buffers[index];
     if (buffer == null) {
       buffer = buffers[index] = new CodeBuffer();
     }
     return buffer;
   }
 
   /**
@@ skipping 100 matching lines @@
 
   // TODO(ahe): Remove this when deferred loading is fully implemented.
   void warnNotImplemented(Element element, String message) {
     compiler.reportMessage(compiler.spanFromSpannable(element),
                            MessageKind.GENERIC.error({'text': message}),
                            api.Diagnostic.WARNING);
   }
 
   // TODO(ahe): This code should be integrated in finishClasses.
   String getReflectionDataParser() {
+    String metadataField = '"${namer.metadataField}"';
     return '''
 (function (reflectionData) {
   if (!init.libraries) init.libraries = [];
   if (!init.mangledNames) init.mangledNames = {};
   if (!init.mangledGlobalNames) init.mangledGlobalNames = {};
+  if (!init.statics) init.statics = {};
   init.getterPrefix = "${namer.getterPrefix}";
   init.setterPrefix = "${namer.setterPrefix}";
   var libraries = init.libraries;
   var mangledNames = init.mangledNames;
   var mangledGlobalNames = init.mangledGlobalNames;
   var hasOwnProperty = Object.prototype.hasOwnProperty;
   var length = reflectionData.length;
   for (var i = 0; i < length; i++) {
     var data = reflectionData[i];
     var name = data[0];
     var uri = data[1];
     var metadata = data[2];
     var descriptor = data[3];
     var classes = [];
     var functions = [];
-    for (var property in descriptor) {
-      if (!hasOwnProperty.call(descriptor, property)) continue;
-      var element = descriptor[property];
-      var firstChar = property.substring(0, 1);
-      var previousProperty;
-      if (firstChar == "+") {
-        mangledGlobalNames[previousProperty] = property.substring(1);
-      } else if (firstChar == "@") {
-        property = property.substring(1);
-        ${namer.CURRENT_ISOLATE}[property]["${namer.metadataField}"] = element;
-      } else if (typeof element === "function") {
-        ${namer.CURRENT_ISOLATE}[previousProperty = property] = element;
-        functions.push(property);
-      } else {
-        previousProperty = property;
-        var newDesc = {};
-        var previousProp;
-        for (var prop in element) {
-          if (!hasOwnProperty.call(element, prop)) continue;
-          firstChar = prop.substring(0, 1);
-          if (firstChar == "+") {
-            mangledNames[previousProp] = prop.substring(1);
-          } else if (firstChar == "@" && prop != "@") {
-            newDesc[prop.substring(1)]["${namer.metadataField}"] ='''
-'''element[prop];
-          } else {
-            newDesc[previousProp = prop] = element[prop];
+    function processStatics(descriptor) {
+      for (var property in descriptor) {
+        if (!hasOwnProperty.call(descriptor, property)) continue;
+        var element = descriptor[property];
+        var firstChar = property.substring(0, 1);
+        var previousProperty;
+        if (firstChar === "+") {
+          mangledGlobalNames[previousProperty] = property.substring(1);
+        } else if (firstChar === "@") {
+          property = property.substring(1);
+          ${namer.CURRENT_ISOLATE}[property][$metadataField] = element;
+        } else if (typeof element === "function") {
+          ${namer.CURRENT_ISOLATE}[previousProperty = property] = element;
+          functions.push(property);
+        } else {
+          previousProperty = property;
+          var newDesc = {};
+          var previousProp;
+          for (var prop in element) {
+            if (!hasOwnProperty.call(element, prop)) continue;
+            firstChar = prop.substring(0, 1);
+            if (prop === "static") {
+              processStatics(init.statics[property] = element[prop]);
+            } else if (firstChar === "+") {
+              mangledNames[previousProp] = prop.substring(1);
+            } else if (firstChar === "@" && prop !== "@") {
+              newDesc[prop.substring(1)][$metadataField] = element[prop];
+            } else {
+              newDesc[previousProp = prop] = element[prop];
+            }
           }
+          $classesCollector[property] = newDesc;
+          classes.push(property);
         }
-        $classesCollector[property] = newDesc;
-        classes.push(property);
       }
     }
+    processStatics(descriptor);
     libraries.push([name, uri, classes, functions, metadata]);
   }
 })''';
   }
 }
 
 const String GENERATED_BY = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 """;
 
 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].
 """;