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.
+   * See [bufferForElement].
+   */
+  // TODO(ahe): Generate statics with their class, and store only libraries in
+  // this map.
+  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];
+        List<Element> sortedElements =
+            Elements.sortedByPosition(elementBuffers.keys);
+        bool hasPendingStatics = false;
+        for (Element element in sortedElements) {
+          if (!element.isLibrary()) {
+            for (CodeBuffer b in elementBuffers[element]) {
+              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).');
         }
         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) {
+      compiler.internalErrorOnElement(element, 'Owner is null');
+    }
+    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].
 """;