Emit declarations for typedefs that are needed by reflection.

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 37 matching lines @@
   final Map<ClassElement, Map<String, jsAst.Expression>> additionalProperties =
       new Map<ClassElement, Map<String, jsAst.Expression>>();
 
   /// Records if a type variable is read dynamically for type tests.
   final Set<TypeVariableElement> readTypeVariables =
       new Set<TypeVariableElement>();
 
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
+  List<TypedefElement> typedefsNeededForReflection;
+
   JavaScriptBackend get backend => compiler.backend;
   TypeVariableHandler get typeVariableHandler => backend.typeVariableHandler;
 
   String get _ => space;
   String get space => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
   String get N => compiler.enableMinification ? "\n" : ";\n";
 
+  CodeBuffer getBuffer(OutputUnit outputUnit) {
+    return outputBuffers.putIfAbsent(outputUnit, () => new CodeBuffer());
+  }
+
   CodeBuffer get mainBuffer {
-    return outputBuffers.putIfAbsent(compiler.deferredLoadTask.mainOutputUnit,
-        () => new CodeBuffer());
+    return getBuffer(compiler.deferredLoadTask.mainOutputUnit);
   }
 
   /**
    * List of expressions and statements that will be included in the
    * precompiled function.
    *
    * To save space, dart2js normally generates constructors and accessors
    * dynamically. This doesn't work in CSP mode, and may impact startup time
    * negatively. So dart2js will emit these functions to a separate file that
    * can be optionally included to support CSP mode or for faster startup.
@@ skipping 666 matching lines @@
           '$namedArguments';
       return (isConstructor) ? 'new $suffix' : suffix;
     }
     Element element = elementOrSelector;
     if (element.isGenerativeConstructorBody) {
       return null;
     } else if (element.isClass) {
       ClassElement cls = element;
       if (cls.isUnnamedMixinApplication) return null;
       return cls.name;
+    } else if (element.isTypedef) {
+      return element.name;
     }
     throw compiler.internalError(element,
         'Do not know how to reflect on this $element.');
   }
 
   String namedParametersAsReflectionNames(Selector selector) {
     if (selector.getOrderedNamedArguments().isEmpty) return '';
     String names = selector.getOrderedNamedArguments().join(':');
     return ':$names';
   }
@@ skipping 89 matching lines @@
   void emitStaticFunctions() {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember && !element.isField;
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
 
     for (Element element in Elements.sortedByPosition(elements)) {
       ClassBuilder builder = new ClassBuilder(element, namer);
       containerBuilder.addMember(element, builder);
-      getElementDecriptor(element).properties.addAll(builder.properties);
+      getElementDescriptor(element).properties.addAll(builder.properties);
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     JavaScriptConstantCompiler handler = backend.constants;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
@@ skipping 267 matching lines @@
         // The back-end introduces some constants, like "InterceptorConstant" or
         // some list constants. They are emitted in the main output-unit.
         // TODO(sigurdm): We should track those constants.
         constantUnit = compiler.deferredLoadTask.mainOutputUnit;
       }
       outputConstantLists.putIfAbsent(constantUnit, () => new List<Constant>())
           .add(constant);
     }
   }
 
-  /**
-   * Compute all the classes that must be emitted.
-   */
-  void computeNeededClasses() {
+  /// Compute all the classes and typedefs that must be emitted.
+  void computeNeededDeclarations() {
+    // Compute needed typedefs.
+    typedefsNeededForReflection = Elements.sortedByPosition(
+        compiler.world.allTypedefs
+            .where(backend.isAccessibleByReflection)
+            .toList());
+
+    // Compute needed classes.
     instantiatedClasses =
         compiler.codegenWorld.instantiatedClasses.where(computeClassFilter())
             .toSet();
 
     void addClassWithSuperclasses(ClassElement cls) {
       neededClasses.add(cls);
       for (ClassElement superclass = cls.superclass;
           superclass != null;
           superclass = superclass.superclass) {
         neededClasses.add(superclass);
@@ skipping 138 matching lines @@
   }
 
   void writeLibraryDescriptors(LibraryElement library) {
     var uri = "";
     if (!compiler.enableMinification || backend.mustRetainUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.outputUri != null) {
         uri = relativize(compiler.outputUri, library.canonicalUri, false);
       }
     }
+    Map<OutputUnit, ClassBuilder> descriptors = elementDescriptors[library];
     String libraryName =
         (!compiler.enableMinification || backend.mustRetainLibraryNames) ?
         library.getLibraryName() :
         "";
-    Map<OutputUnit, ClassBuilder> descriptors =
-        elementDescriptors[library];
 
     for (OutputUnit outputUnit in compiler.deferredLoadTask.allOutputUnits) {
-      ClassBuilder descriptor =
-          descriptors.putIfAbsent(outputUnit,
-                                  () => new ClassBuilder(library, namer));
-      if (descriptor.properties.isEmpty) continue;
-      bool isDeferred =
-          outputUnit != compiler.deferredLoadTask.mainOutputUnit;
+      if (!descriptors.containsKey(outputUnit)) continue;
+
+      ClassBuilder descriptor = descriptors[outputUnit];
       jsAst.Fun metadata = metadataEmitter.buildMetadataFunction(library);
 
-      jsAst.ObjectInitializer initializers =
-          descriptor.toObjectInitializer();
-      CodeBuffer outputBuffer =
-          outputBuffers.putIfAbsent(outputUnit, () => new CodeBuffer());
+      jsAst.ObjectInitializer initializers = descriptor.toObjectInitializer();
+      CodeBuffer outputBuffer = getBuffer(outputUnit);
+
       int sizeBefore = outputBuffer.length;
       compiler.dumpInfoTask.registerElementAst(library, metadata);
       compiler.dumpInfoTask.registerElementAst(library, initializers);
       outputBuffers[outputUnit]
           ..write('["$libraryName",$_')
           ..write('"${uri}",$_')
           ..write(metadata == null ? "" : jsAst.prettyPrint(metadata,
                                                 compiler,
                                                 monitor: compiler.dumpInfoTask))
           ..write(',$_')
           ..write(namer.globalObjectFor(library))
           ..write(',$_')
           ..write(jsAst.prettyPrint(initializers,
                                     compiler,
                                     monitor: compiler.dumpInfoTask))
           ..write(library == compiler.mainApp ? ',${n}1' : "")
           ..write('],$n');
       int sizeAfter = outputBuffer.length;
     }
   }
 
+  void emitPrecompiledConstructor(String constructorName,
+                                  jsAst.Expression constructorAst) {
+    precompiledFunction.add(
+        new jsAst.FunctionDeclaration(
+            new jsAst.VariableDeclaration(constructorName), constructorAst));
+    precompiledFunction.add(
+   js.statement(r'''{
+          #.builtin$cls = #;
+          if (!"name" in #)
+              #.name = #;
+          $desc=$collectedClasses.#;
+          if ($desc instanceof Array) $desc = $desc[1];
+          #.prototype = $desc;
+        }''',
+        [   constructorName, js.string(constructorName),
+            constructorName,
+            constructorName, js.string(constructorName),
+            constructorName,
+            constructorName
+         ]));
+
+    precompiledConstructorNames.add(js('#', constructorName));
+  }
+
   String assembleProgram() {
     measure(() {
       invalidateCaches();
 
       // Compute the required type checks to know which classes need a
       // 'is$' method.
       typeTestEmitter.computeRequiredTypeChecks();
 
-      computeNeededClasses();
+      computeNeededDeclarations();
 
       mainBuffer.add(buildGeneratedBy());
       addComment(HOOKS_API_USAGE, mainBuffer);
 
       if (!compiler.deferredLoadTask.splitProgram) {
         mainBuffer.add('(function(${namer.currentIsolate})$_{$n');
       }
 
       // Using a named function here produces easier to read stack traces in
       // Chrome/V8.
@@ skipping 14 matching lines @@
       // Shorten the code by using [namer.currentIsolate] as temporary.
       isolateProperties = namer.currentIsolate;
       mainBuffer.add(
           '$isolateProperties$_=$_$isolatePropertiesName$N');
 
       emitStaticFunctions();
 
       // Only output the classesCollector if we actually have any classes.
       if (!(nativeClasses.isEmpty &&
             compiler.codegenWorld.staticFunctionsNeedingGetter.isEmpty &&
-          outputClassLists.values.every((classList) => classList.isEmpty))) {
+          outputClassLists.values.every((classList) => classList.isEmpty) &&
+          typedefsNeededForReflection.isEmpty)) {
         // Shorten the code by using "$$" as temporary.
         classesCollector = r"$$";
         mainBuffer.add('var $classesCollector$_=$_{}$N$n');
       }
 
       // Emit native classes on [nativeBuffer].
       // Might create methodClosures.
       final CodeBuffer nativeBuffer = new CodeBuffer();
       if (!nativeClasses.isEmpty) {
         addComment('Native classes', nativeBuffer);
         addComment('Native classes', mainBuffer);
         nativeEmitter.generateNativeClasses(nativeClasses, mainBuffer,
             additionalProperties);
       }
 
       // As a side-effect, emitting classes will produce "bound closures" in
       // [methodClosures].  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).
 
       // Might create methodClosures.
       for (List<ClassElement> outputClassList in outputClassLists.values) {
         for (ClassElement element in outputClassList) {
-          generateClass(element, getElementDecriptor(element));
+          generateClass(element, getElementDescriptor(element));
         }
       }
 
       nativeEmitter.finishGenerateNativeClasses();
       nativeEmitter.assembleCode(nativeBuffer);
 
 
       // After this assignment we will produce invalid JavaScript code if we use
       // the classesCollector variable.
       classesCollector = 'classesCollector should not be used from now on';
 
       // TODO(sigurdm): Need to check this for each outputUnit.
       if (!elementDescriptors.isEmpty) {
         var oldClassesCollector = classesCollector;
         classesCollector = r"$$";
         if (compiler.enableMinification) {
           mainBuffer.write(';');
         }
 
+        // TODO(karlklose): document what kinds of fields this loop adds to the
+        // library class builder.
         for (Element element in elementDescriptors.keys) {
           // TODO(ahe): Should iterate over all libraries.  Otherwise, we will
           // not see libraries that only have fields.
           if (element.isLibrary) {
             LibraryElement library = element;
             ClassBuilder builder = new ClassBuilder(library, namer);
             if (classEmitter.emitFields(
                     library, builder, null, emitStatics: true)) {
               OutputUnit mainUnit = compiler.deferredLoadTask.mainOutputUnit;
               jsAst.ObjectInitializer initializer =
                 builder.toObjectInitializer();
               compiler.dumpInfoTask.registerElementAst(builder.element,
                                                        initializer);
               getElementDescriptorForOutputUnit(library, mainUnit)
                   .properties.addAll(initializer.properties);
             }
           }
         }
 
+        // Emit all required typedef declarations into the main output unit.
+        // TODO(karlklose): unify required classes and typedefs to declarations
+        // and have builders for each kind.
+        for (TypedefElement typedef in typedefsNeededForReflection) {
+          OutputUnit mainUnit = compiler.deferredLoadTask.mainOutputUnit;
+          LibraryElement library = typedef.library;
+          // TODO(karlklose): add a TypedefBuilder and move this code there.
+          DartType type = typedef.alias;
+          int typeIndex = metadataEmitter.reifyType(type);
+          String typeReference =
+              encoding.encodeTypedefFieldDescriptor(typeIndex);
+          jsAst.Property descriptor = new jsAst.Property(
+              js.string(namer.classDescriptorProperty),
+              js.string(typeReference));
+          jsAst.Node declaration = new jsAst.ObjectInitializer([descriptor]);
+          String mangledName = namer.getNameX(typedef);
+          String reflectionName = getReflectionName(typedef, mangledName);
+          getElementDescriptorForOutputUnit(library, mainUnit)
+              ..addProperty(mangledName, declaration)
+              ..addProperty("+$reflectionName", js.string(''));
+          // Also emit a trivial constructor for CSP mode.
+          String constructorName = mangledName;
+          jsAst.Expression constructorAst = js('function() {}');
+          emitPrecompiledConstructor(constructorName, constructorAst);
+        }
+
         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(
@@ skipping 236 matching lines @@
 
   ClassBuilder getElementDescriptorForOutputUnit(Element element,
                                                  OutputUnit outputUnit) {
     Map<OutputUnit, ClassBuilder> descriptors =
         elementDescriptors.putIfAbsent(
             element, () => new Map<OutputUnit, ClassBuilder>());
     return descriptors.putIfAbsent(outputUnit,
         () => new ClassBuilder(element, namer));
   }
 
-  ClassBuilder getElementDecriptor(Element element) {
+  ClassBuilder getElementDescriptor(Element element) {
     Element owner = element.library;
     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.enclosingClassOrCompilationUnit.declaration;
       if (compiler.codegenWorld.instantiatedClasses.contains(cls)
           && !cls.isNative) {
         owner = cls;
@@ skipping 94 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }