Concept of how dart:mirrors LibraryMirror, ClassMirror can be implemented in dart2js.

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 30 matching lines @@
   CodeBuffer boundClosureBuffer;
   CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   Set<ClassElement> neededClasses;
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
+  List<js.Expression> libraryMirrorsParametersList;
+  Map<String, int> libraryMirrorsIndices;
+
   String get _ => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
   String get N => compiler.enableMinification ? "\n" : ";\n";
 
   /**
    * A cache of closures that are used to closurize instance methods.
    * A closure is dynamically bound to the instance used when
    * closurized.
    */
   final Map<int, String> boundClosureCache;
@@ skipping 962 matching lines @@
           generateGetter(member, name, accessorName, buffer);
         }
         if (needsSetter) {
           emitComma();
           generateSetter(member, name, accessorName, buffer);
         }
       }
     });
   }
 
+  void emitClassLibraryGetter(ClassElement classElement, CodeBuffer buffer) {
+    var name = classElement.getLibrary().getLibraryOrScriptName();
+    // Some builtin classes come from js_helper libraries, which are
+    // not in libraryMirrorsIndices collection. At this point we
+    // will ignore them.
+    if (libraryMirrorsIndices.containsKey(name)) {
+      buffer.add(",$n$_${_}builtin\$library:$_${libraryMirrorsIndices[name]}");
+    }
+  }
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void generateClass(ClassElement classElement, CodeBuffer buffer) {
     assert(invariant(classElement, classElement.isDeclaration));
     if (classElement.isNative()) {
       nativeEmitter.generateNativeClass(classElement);
       return;
@@ skipping 15 matching lines @@
     buffer.add('$classesCollector.$className$_=$_{');
     emitClassConstructor(classElement, buffer);
     emitSuper(superName, buffer);
     emitClassFields(classElement, buffer, false,
                     superClass: superName, classIsNative: false);
     // TODO(floitsch): the emitInstanceMember should simply always emit a ',\n'.
     // That does currently not work because the native classes have a different
     // syntax.
     emitClassGettersSetters(classElement, buffer, true);
     emitInstanceMembers(classElement, buffer, true);
+    if (compiler.hasMirrorsSupport()) {
+      emitClassLibraryGetter(classElement, buffer);
+    }
     buffer.add('$n}$N$n');
   }
 
   bool get getterAndSetterCanBeImplementedByFieldSpec => true;
 
   void emitInterceptorMethods(
       void defineInstanceMember(String name, StringBuffer memberBuffer)) {
     JavaScriptBackend backend = compiler.backend;
     // Emit forwarders for the ObjectInterceptor class. We need to
     // emit all possible sends on intercepted methods.
@@ skipping 1022 matching lines @@
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
           superclass != null;
           superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
       }
     }
   }
 
+  Collection<js.Expression> extract(listElements, filterToApply) {
+    return new js.ArrayInitializer.from(
+        listElements
+            .filter(filterToApply)
+            .map((member) => js.string(namer.getName(member))));
+  }
+
+  Collection extractClasses(listElements) {
+    var classDescriptions = [];
+    var classes = listElements.filter((e) => Elements.isClass(e));
+    for (Element classElement in classes) {
+      var classMembers = [];
+      for (var classMember in classElement.localMembers) {
+        var prefixType;
+        var name;
+        if (classMember.isGetter()) {
+          prefixType = 'G';
+          name = qualifiedFunctionName(classMember);
+        } else if (classMember.isSetter()) {
+          prefixType = 'S';
+          name = qualifiedFunctionName(classMember);
+        } else if (classMember.isField()) {
+          prefixType = 'V';
+          name = qualifiedVariableName(classMember);
+        } else if (classMember.isConstructor()) {
+          prefixType = 'C';
+          name = namer.getName(classMember);
+        } else if (classMember.isTypeVariable()) {
+          prefixType = 'T';
+          name = namer.getName(classMember);
+        } else if (classMember.isParameter()) {
+          prefixType = 'A';
+          name = namer.getName(classMember);
+        } else {
+          prefixType = 'M';
+          name = qualifiedFunctionName(classMember);
+        }
+        var originalName = classMember.name.slowToString();
+        if (name != originalName) {
+          name = "$name[$originalName]";
+        }
+        classMembers.add(js.string("$prefixType:$name"));
+      }
+      classDescriptions.add(
+          new js.ArrayInitializer.from(
+              [js.string(namer.getName(classElement)),
+              new js.ArrayInitializer.from(classMembers)]));
+    }
+    return new js.ArrayInitializer.from(classDescriptions);
+  }
+
+  String qualifiedFunctionName(Element functionElement) {
+    String prefixType;
+    if (functionElement.modifiers.isStatic()) {
+      prefixType = 'S';
+    } else {
+      prefixType = 'I';
+    }
+    var typeName = "";
+    var libraryID = "";
+    assert(functionElement.type != null);
+    DartType dt = functionElement.type;
+    // Ignore types that weren't computed.
+    if (dt != null) {
+      if (dt.kind == TypeKind.FUNCTION) {
+        typeName = dt.returnType.name.slowToString();
+        if (typeName == 'void' || typeName == 'dynamic') {
+          libraryID = "";
+        } else {
+          var library = dt.returnType.element.getLibrary();
+          var libraryName = library.getLibraryOrScriptName();
+          libraryID = libraryMirrorsIndices[libraryName];
+        }
+      }
+    }
+    return "$prefixType:$libraryID:$typeName:${namer.getName(functionElement)}";
+  }
+
+  Collection extractMethods(listElements, filterToApply) {
+    var methodsDescription =
+      listElements
+          .filter(filterToApply)
+          .map((e) => js.string(qualifiedFunctionName(e)));
+    return new js.ArrayInitializer.from(methodsDescription);
+  }
+
+  String qualifiedVariableName(Element fieldElement) {
+    String prefixType;
+    if (fieldElement.modifiers.isStatic()) {
+      prefixType = 'S';
+    } else {
+      prefixType = 'I';
+    }
+    // Use case to indicate whether field is final or not.
+    // Is it too fancy?
+    if (fieldElement.modifiers.isFinal()) {
+      prefixType = prefixType.toLowerCase();
+    }
+    var name = namer.getName(fieldElement);
+    var originalName = fieldElement.name.slowToString();
+    if (name != originalName) {
+      name = "$name[$originalName]";
+    }
+    return "$prefixType:$name";
+  }
+
+  Collection extractVariables(listElements) {
+    var fieldsDescription =
+      listElements
+          .filter((e) => e.isField())
+          .map((e) => js.string(qualifiedVariableName(e)));
+    return new js.ArrayInitializer.from(fieldsDescription);
+  }
+
+  Collection extractClosures(Collection<ClosureClassMap> listClosures) {
+    var closuresDescriptions =
+      listClosures.map(
+          (map) => js.string(
+              "${namer.getName(map.closureClassElement)}:"
+              "${namer.getName(map.callElement)}:"
+              "${map.callElement.functionSignature.requiredParameterCount}:"
+              "${map.callElement.functionSignature.optionalParameterCount}:"));
+    return new js.ArrayInitializer.from(closuresDescriptions);
+  }
+
+  void computeLibraryMirrors() {
+    int index = 0;
+    libraryMirrorsParametersList = new List<js.Expression>();
+    libraryMirrorsIndices = new Map<String, int>();
+    for (LibraryElement libraryElement in compiler.libraries.values) {
+      //
+      //        [lib1,
+      //            [[class1, classConstructor, [member1,...]]
+      //              ...],
+      //            [function1...],
+      //            [getter1...]
+      //            [setter1...]
+      //            [variable1...]
+      //            [closure1...]
+      //        ]...
+      //
+      var elements =
+          new List<Element>.from(libraryElement.localMembers);
+      var libraryName = libraryElement.getLibraryOrScriptName();
+      libraryMirrorsParametersList.add(
+          new js.ArrayInitializer.from(
+              <js.Expression>[
+                  js.string(libraryName),
+                  extractClasses(elements),
+                  extractMethods(elements, (e) => e.isFunction()),
+                  extractMethods(elements, (e) => e.isGetter()),
+                  extractMethods(elements, (e) => e.isSetter()),
+                  extractVariables(elements),
+                  extractClosures(
+                      new List<ClassElement>.from(
+                          compiler.closureToClassMapper
+                              .closureMappingCache.values
+                              .filter((map) => map.closureElement != null
+                                              && map.closureElement.getLibrary()
+                                                 == libraryElement)))
+              ]));
+      libraryMirrorsIndices[libraryName] = index++;
+    }
+  }
+
+  void emitMirrorsSupport(CodeBuffer buffer) {
+    Element createMirrorSystem =
+        compiler.mirrorsLibrary.find(Compiler.CREATE_MIRROR_SYSTEM);
+    String isolateCreateMirrorSystem =
+        namer.isolateAccess(createMirrorSystem);
+
+    // createMirrorSystem([library1, library2, ...])
+    var createMirrorSystemCall =
+        new js.ExpressionStatement(
+            js.call(
+                js.use(isolateCreateMirrorSystem),
+                [new js.ArrayInitializer.from(libraryMirrorsParametersList)]));
+    mainBuffer.add(js.prettyPrint(createMirrorSystemCall, compiler));
+  }
+
   String assembleProgram() {
     measure(() {
       computeNeededClasses();
+      if (compiler.hasMirrorsSupport()) {
+        // Create library mirror structure up front so that we can refer to
+        // library elements during class construction by array index.
+        computeLibraryMirrors();
+      }
 
       mainBuffer.add(GENERATED_BY);
       if (!compiler.enableMinification) mainBuffer.add(HOOKS_API_USAGE);
       mainBuffer.add('function ${namer.isolateName}()$_{}\n');
       mainBuffer.add('init()$N$n');
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
       mainBuffer.add('var $classesCollector$_=$_{}$N');
       // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
       isolateProperties = namer.CURRENT_ISOLATE;
       mainBuffer.add(
           'var $isolateProperties$_=$_$isolatePropertiesName$N');
       emitClasses(mainBuffer);
       mainBuffer.add(boundClosureBuffer);
       // Clear the buffer, so that we can reuse it for the native classes.
       boundClosureBuffer.clear();
       emitStaticFunctions(mainBuffer);
       emitStaticFunctionGetters(mainBuffer);
       // We need to finish the classes before we construct compile time
       // constants.
       emitFinishClassesInvocationIfNecessary(mainBuffer);
       emitRuntimeClassesAndTests(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
       emitGetInterceptorMethods(mainBuffer);
       emitLazilyInitializedStaticFields(mainBuffer);
 
+      if (compiler.hasMirrorsSupport()) {
+        emitMirrorsSupport(mainBuffer);
+      }
+
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
       // initialStatics.
       mainBuffer.add('var ${namer.CURRENT_ISOLATE}$_=${_}null$N');
       mainBuffer.add(boundClosureBuffer);
       emitFinishClassesInvocationIfNecessary(mainBuffer);
       // After this assignment we will produce invalid JavaScript code if we use
       // the classesCollector variable.
       classesCollector = 'classesCollector should not be used from now on';
 
@@ skipping 38 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].
 """;