Implement reflecting on static fields.

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 64 matching lines @@
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final List<ClassElement> regularClasses = <ClassElement>[];
   final List<ClassElement> deferredClasses = <ClassElement>[];
   final List<ClassElement> nativeClasses = <ClassElement>[];
   final List<Selector> trivialNsmHandlers = <Selector>[];
   final Map<String, String> mangledFieldNames = <String, String>{};
+  final Map<String, String> mangledGlobalFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
   final Set<String> interceptorInvocationNames = new Set<String>();
 
   /// A list of JS expressions that represent metadata, parameter names and
   /// type, and return types.
   final List<String> globalMetadata = [];
 
   /// A map used to canonicalize the entries of globalMetadata.
   final Map<String, int> globalMetadataMap = <String, int>{};
 
@@ skipping 1355 matching lines @@
       functionTypes.forEach(addSignature);
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void visitClassFields(ClassElement classElement,
+                        bool visitStatics,
                         void addField(Element member,
                                       String name,
                                       String accessorName,
                                       bool needsGetter,
                                       bool needsSetter,
                                       bool needsCheckedSetter)) {
     assert(invariant(classElement, classElement.isDeclaration));
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can simplify its JavaScript constructor.
     bool isInstantiated =
@@ skipping 46 matching lines @@
         // Getters and setters with suffixes will be generated dynamically.
         addField(member,
                  fieldName,
                  accessorName,
                  needsGetter,
                  needsSetter,
                  needsCheckedSetter);
       }
     }
 
-    // TODO(kasperl): We should make sure to only emit one version of
-    // overridden fields. Right now, we rely on the ordering so the
-    // fields pulled in from mixins are replaced with the fields from
-    // the class definition.
+    if (visitStatics) {
+      classElement.implementation.forEachStaticField(visitField);
+    } else {
+      // TODO(kasperl): We should make sure to only emit one version of
+      // overridden fields. Right now, we rely on the ordering so the
+      // fields pulled in from mixins are replaced with the fields from
+      // the class definition.
 
-    // If a class is not instantiated then we add the field just so we can
-    // generate the field getter/setter dynamically. Since this is only
-    // allowed on fields that are in [classElement] we don't need to visit
-    // superclasses for non-instantiated classes.
-    classElement.implementation.forEachInstanceField(
-        visitField,
-        includeSuperAndInjectedMembers: isInstantiated);
+      // If a class is not instantiated then we add the field just so we can
+      // generate the field getter/setter dynamically. Since this is only
+      // allowed on fields that are in [classElement] we don't need to visit
+      // superclasses for non-instantiated classes.
+      classElement.implementation.forEachInstanceField(
+          visitField,
+          includeSuperAndInjectedMembers: isInstantiated);
+    }
   }
 
   void generateGetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String getterName = namer.getterNameFromAccessorName(accessorName);
     String receiver = backend.isInterceptorClass(member.getEnclosingClass())
         ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member)
         ? ['receiver']
         : [];
@@ skipping 65 matching lines @@
   }
 
   void emitRuntimeName(String runtimeName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
   void recordMangledField(Element member,
                           String accessorName,
                           String memberName) {
     if (!backend.retainGetter(member)) return;
-    String previousName = mangledFieldNames.putIfAbsent(
-        '${namer.getterPrefix}$accessorName',
-        () => memberName);
+    String previousName;
+    if (member.isInstanceMember()) {
+      previousName = mangledFieldNames.putIfAbsent(
+          '${namer.getterPrefix}$accessorName',
+          () => memberName);
+    } else {
+      previousName = mangledGlobalFieldNames.putIfAbsent(
+          accessorName,
+          () => memberName);
+    }
     assert(invariant(member, previousName == memberName,
                      message: '$previousName != ${memberName}'));
   }
 
   /// Returns `true` if fields added.
   bool emitClassFields(ClassElement classElement,
                        ClassBuilder builder,
                        String superName,
-                       { bool classIsNative: false }) {
+                       { bool classIsNative: false,
+                         bool emitStatics: false }) {
     assert(superName != null);
     String separator = '';
     String nativeName = namer.getPrimitiveInterceptorRuntimeName(classElement);
     StringBuffer buffer = new StringBuffer();
-    if (nativeName != null) {
-      buffer.write('$nativeName/');
+    if (!emitStatics) {
+      if (nativeName != null) {
+        buffer.write('$nativeName/');
+      }
+      buffer.write('$superName;');
     }
-    buffer.write('$superName;');
     int bufferClassLength = buffer.length;
 
     var fieldMetadata = [];
     bool hasMetadata = false;
 
-    visitClassFields(classElement, (Element member,
-                                    String name,
-                                    String accessorName,
-                                    bool needsGetter,
-                                    bool needsSetter,
-                                    bool needsCheckedSetter) {
+    visitClassFields(classElement, emitStatics,
+                     (Element member,
+                      String name,
+                      String accessorName,
+                      bool needsGetter,
+                      bool needsSetter,
+                      bool needsCheckedSetter) {
       // Ignore needsCheckedSetter - that is handled below.
       bool needsAccessor = (needsGetter || needsSetter);
       // We need to output the fields for non-native classes so we can auto-
       // generate the constructor.  For native classes there are no
       // constructors, so we don't need the fields unless we are generating
       // accessors at runtime.
       if (!classIsNative || needsAccessor) {
         buffer.write(separator);
         separator = ',';
         var metadata = buildMetadataFunction(member);
@@ skipping 57 matching lines @@
       fieldMetadata.insert(0, classDataNode);
       classDataNode = new jsAst.ArrayInitializer.from(fieldMetadata);
     }
     builder.addProperty('', classDataNode);
     return fieldsAdded;
   }
 
   void emitClassGettersSetters(ClassElement classElement,
                                ClassBuilder builder) {
 
-    visitClassFields(classElement, (Element member,
-                                    String name,
-                                    String accessorName,
-                                    bool needsGetter,
-                                    bool needsSetter,
-                                    bool needsCheckedSetter) {
+    visitClassFields(classElement, false,
+                     (Element member,
+                      String name,
+                      String accessorName,
+                      bool needsGetter,
+                      bool needsSetter,
+                      bool needsCheckedSetter) {
       compiler.withCurrentElement(member, () {
         if (needsCheckedSetter) {
           assert(!needsSetter);
           generateCheckedSetter(member, name, accessorName, builder);
         }
         if (!getterAndSetterCanBeImplementedByFieldSpec) {
           if (needsGetter) {
             generateGetter(member, name, accessorName, builder);
           }
           if (needsSetter) {
@@ skipping 39 matching lines @@
     if (metadata != null) {
       builder.addProperty("@", metadata);
     }
     emitClassGettersSetters(classElement, builder);
     if (!classElement.isMixinApplication) {
       emitInstanceMembers(classElement, builder);
     }
     emitIsTests(classElement, builder);
 
     List<CodeBuffer> classBuffers = elementBuffers[classElement];
+    if (classBuffers == null) {
+      classBuffers = [];
+    } else {
+      elementBuffers.remove(classElement);
+    }
     CodeBuffer statics = new CodeBuffer();
+    statics.write('{$n');
     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);
-        }
+    ClassBuilder staticsBuilder = new ClassBuilder();
+    if (emitClassFields(
+            classElement, staticsBuilder, superName, emitStatics: true)) {
+      hasStatics = true;
+      statics.write('"":$_');
+      statics.write(
+          jsAst.prettyPrint(staticsBuilder.properties.single.value, compiler));
+      statics.write(',$n');
+    }
+    for (CodeBuffer classBuffer in classBuffers) {
+      // TODO(ahe): What about deferred?
+      if (classBuffer != null) {
+        hasStatics = true;
+        statics.addBuffer(classBuffer);
       }
-      statics.write('}$n');
     }
+    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));
@@ skipping 1667 matching lines @@
             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(';');
           }
         }
+        if (!mangledGlobalFieldNames.isEmpty) {
+          var keys = mangledGlobalFieldNames.keys.toList();
+          keys.sort();
+          var properties = [];
+          for (String key in keys) {
+            var value = js.string('${mangledGlobalFieldNames[key]}');
+            properties.add(new jsAst.Property(js.string(key), value));
+          }
+          var map = new jsAst.ObjectInitializer(properties);
+          mainBuffer.write(
+              jsAst.prettyPrint(
+                  js('init.mangledGlobalNames = #', map).toStatement(),
+                  compiler));
+          if (compiler.enableMinification) {
+            mainBuffer.write(';');
+          }
+        }
         mainBuffer
             ..write(getReflectionDataParser())
             ..write('([$n');
 
         var sortedElements = Elements.sortedByPosition(elementBuffers.keys);
         bool hasPendingStatics = false;
         for (Element element in sortedElements) {
           if (!element.isLibrary()) {
             for (var b in elementBuffers[element]) {
               if (b != null) {
@@ skipping 247 matching lines @@
     var data = reflectionData[i];
     var name = data[0];
     var uri = data[1];
     var metadata = data[2];
     var descriptor = data[3];
     var classes = [];
     var functions = [];
     function processStatics(descriptor) {
       for (var property in descriptor) {
         if (!hasOwnProperty.call(descriptor, property)) continue;
+        if (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;
@@ skipping 33 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].
 """;