dart2js: fully assemble program before emitting it.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 66 matching lines @@
 
   /**
    * Accumulate properties for classes and libraries, describing their
    * static/top-level members.
    * Later, these members are emitted when the class or library is emitted.
    *
    * See [getElementDescriptor].
    */
   // TODO(ahe): Generate statics with their class, and store only libraries in
   // this map.
-  final Map<Element, ClassBuilder> elementDescriptors =
-      new Map<Element, ClassBuilder>();
+  final Map<Fragment, Map<Element, ClassBuilder>> elementDescriptors =
+      new Map<Fragment, Map<Element, ClassBuilder>>();
 
   final bool generateSourceMap;
 
   OldEmitter(Compiler compiler, Namer namer, this.generateSourceMap, this.task)
       : this.compiler = compiler,
         this.namer = namer,
         cachedEmittedConstants = compiler.cacheStrategy.newSet(),
         cachedClassBuilders = compiler.cacheStrategy.newMap(),
         cachedElements = compiler.cacheStrategy.newSet() {
     constantEmitter = new ConstantEmitter(
@@ skipping 328 matching lines @@
         var \$desc;
         #;
         return #;
       };''',
         [generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
          cspPrecompiledFunctionFor(outputUnit),
          new jsAst.ArrayInitializer(
              cspPrecompiledConstructorNamesFor(outputUnit))]);
   }
 
-  void emitClass(Class cls, ClassBuilder enclosingBuilder) {
+  void assembleClass(Class cls, ClassBuilder enclosingBuilder,
+                     Fragment fragment) {
     ClassElement classElement = cls.element;
     compiler.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
               ClassBuilder builder = new ClassBuilder(classElement, namer);
-              classEmitter.emitClass(cls, builder);
+              classEmitter.emitClass(cls, builder, fragment);
               return builder;
             });
         invariant(classElement, cachedBuilder.fields.isEmpty);
         invariant(classElement, cachedBuilder.superName == null);
         invariant(classElement, cachedBuilder.functionType == null);
         invariant(classElement, cachedBuilder.fieldMetadata == null);
         enclosingBuilder.properties.addAll(cachedBuilder.properties);
       } else {
-        classEmitter.emitClass(cls, enclosingBuilder);
+        classEmitter.emitClass(cls, enclosingBuilder, fragment);
       }
     });
   }
 
-  void emitStaticFunctions(Iterable<Method> staticFunctions) {
+  void assembleStaticFunctions(Iterable<Method> staticFunctions,
+                               Fragment fragment) {
     if (staticFunctions == null) return;
 
     for (Method method in staticFunctions) {
       Element element = method.element;
       // We need to filter out null-elements for the interceptors.
       // TODO(floitsch): use the precomputed interceptors here.
       if (element == null) continue;
       ClassBuilder builder = new ClassBuilder(element, namer);
       containerBuilder.addMemberMethod(method, builder);
-      getElementDescriptor(element).properties.addAll(builder.properties);
+      getElementDescriptor(element, fragment).properties
+          .addAll(builder.properties);
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeOutput output,
                                               OutputUnit outputUnit) {
     void emitInitialization(Element element, jsAst.Expression initialValue) {
       jsAst.Expression init =
         js('$isolateProperties.# = #',
             [namer.globalPropertyName(element), initialValue]);
       output.addBuffer(jsAst.prettyPrint(init, compiler,
@@ skipping 467 matching lines @@
           return object.__proto__ &&
                  object.__proto__.p === cls.prototype.p;
          })();
       ''');
     }
 
     output.addBuffer(jsAst.prettyPrint(supportsDirectProtoAccess, compiler));
     output.add(N);
   }
 
-  void writeLibraryDescriptor(CodeOutput output, LibraryElement library) {
+  void writeLibraryDescriptor(CodeOutput output, LibraryElement library,
+                              Fragment fragment) {
     var uri = "";
     if (!compiler.enableMinification || backend.mustPreserveUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.outputUri != null) {
         uri = relativize(compiler.outputUri, library.canonicalUri, false);
       }
     }
-    ClassBuilder descriptor = elementDescriptors[library];
+    ClassBuilder descriptor = elementDescriptors[fragment][library];
     if (descriptor == null) {
       // Nothing of the library was emitted.
       // TODO(floitsch): this should not happen. We currently have an example
       // with language/prefix6_negative_test.dart where we have an instance
       // method without its corresponding class.
       return;
     }
 
     String libraryName =
         (!compiler.enableMinification || backend.mustRetainLibraryNames) ?
@@ skipping 18 matching lines @@
         ..add(',$_')
         ..add(namer.globalObjectFor(library))
         ..add(',$_')
         ..addBuffer(jsAst.prettyPrint(initializers,
                                       compiler,
                                       monitor: compiler.dumpInfoTask))
         ..add(library == compiler.mainApp ? ',${n}1' : "")
         ..add('],$n');
   }
 
-  void emitPrecompiledConstructor(OutputUnit outputUnit,
-                                  String constructorName,
-                                  jsAst.Expression constructorAst,
-                                  List<String> fields) {
+  void assemblePrecompiledConstructor(OutputUnit outputUnit,
+                                      String constructorName,
+                                      jsAst.Expression constructorAst,
+                                      List<String> fields) {
     cspPrecompiledFunctionFor(outputUnit).add(
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration(constructorName), constructorAst));
 
     String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
     bool hasIsolateSupport = compiler.hasIsolateSupport;
     jsAst.Node fieldNamesArray =
         hasIsolateSupport ? js.stringArray(fields) : new jsAst.LiteralNull();
 
     cspPrecompiledFunctionFor(outputUnit).add(js.statement(r'''
         {
           #constructorName.builtin$cls = #constructorNameString;
           if (!"name" in #constructorName)
               #constructorName.name = #constructorNameString;
           $desc = $collectedClasses.#constructorName[1];
           #constructorName.prototype = $desc;
           ''' /* next string is not a raw string */ '''
           if (#hasIsolateSupport) {
             #constructorName.$fieldNamesProperty = #fieldNamesArray;
           }
         }''',
         {"constructorName": constructorName,
          "constructorNameString": js.string(constructorName),
          "hasIsolateSupport": hasIsolateSupport,
          "fieldNamesArray": fieldNamesArray}));
 
     cspPrecompiledConstructorNamesFor(outputUnit).add(js('#', constructorName));
   }
 
-  void emitTypedefs() {
-    OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
+  void assembleTypedefs(Program program) {
+    Fragment mainFragment = program.mainFragment;
+    OutputUnit mainOutputUnit = mainFragment.outputUnit;
 
     // 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) {
       LibraryElement library = typedef.library;
       // TODO(karlklose): add a TypedefBuilder and move this code there.
       DartType type = typedef.alias;
       // TODO(zarah): reify type variables once reflection on type arguments of
       // typedefs is supported.
       int typeIndex =
           task.metadataCollector.reifyType(type, ignoreTypeVariables: true);
       ClassBuilder builder = new ClassBuilder(typedef, namer);
       builder.addProperty(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
                           js.number(typeIndex));
       builder.addProperty(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
                           js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(compiler.objectClass != null);
       builder.superName = namer.className(compiler.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
       String mangledName = namer.globalPropertyName(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
-      getElementDescriptor(library)
+      getElementDescriptor(library, mainFragment)
           ..addProperty(mangledName, declaration)
           ..addProperty("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
       String constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<String> fieldNames = [];
-      emitPrecompiledConstructor(mainOutputUnit,
-                                 constructorName,
-                                 constructorAst,
-                                 fieldNames);
+      assemblePrecompiledConstructor(mainOutputUnit,
+                                     constructorName,
+                                     constructorAst,
+                                     fieldNames);
     }
   }
 
   void emitMangledNames(CodeOutput output) {
     if (!mangledFieldNames.isEmpty) {
       var keys = mangledFieldNames.keys.toList();
       keys.sort();
       var properties = [];
       for (String key in keys) {
         var value = js.string('${mangledFieldNames[key]}');
@@ skipping 44 matching lines @@
           compiler.reportInfo(
               element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
     }
 
     if (pendingStatics != null && !pendingStatics.isEmpty) {
       compiler.internalError(pendingStatics.first,
           'Pending statics (see above).');
     }
   }
 
-  void emitLibrary(Library library) {
+  void assembleLibrary(Library library, Fragment fragment) {
     LibraryElement libraryElement = library.element;
 
-    emitStaticFunctions(library.statics);
+    assembleStaticFunctions(library.statics, fragment);
 
-    ClassBuilder libraryBuilder = getElementDescriptor(libraryElement);
+    ClassBuilder libraryBuilder =
+        getElementDescriptor(libraryElement, fragment);
     for (Class cls in library.classes) {
-      emitClass(cls, libraryBuilder);
+      assembleClass(cls, libraryBuilder, fragment);
     }
 
     classEmitter.emitFields(library, libraryBuilder, emitStatics: true);
   }
 
+  void assembleProgram(Program program) {
+    for (Fragment fragment in program.fragments) {
+      for (Library library in fragment.libraries) {
+        assembleLibrary(library, fragment);
+      }
+    }
+    assembleTypedefs(program);
+  }
+
   void emitMainOutputUnit(Program program,
                           Map<OutputUnit, String> deferredLoadHashes) {
     MainFragment mainFragment = program.fragments.first;
     OutputUnit mainOutputUnit = mainFragment.outputUnit;
 
     LineColumnCollector lineColumnCollector;
     List<CodeOutputListener> codeOutputListeners;
     if (generateSourceMap) {
       lineColumnCollector = new LineColumnCollector();
       codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
@@ skipping 79 matching lines @@
       mainOutput.add(
           '${globalsHolder}.${namer.isolateName}$_=$_${namer.isolateName}$N'
           '${globalsHolder}.$initName$_=${_}$initName$N'
           '${globalsHolder}.$setupProgramName$_=$_'
             '$setupProgramName$N');
     }
     mainOutput.add('init()$N$n');
     mainOutput.add('$isolateProperties$_=$_$isolatePropertiesName$N');
 
     emitFunctionThatReturnsNull(mainOutput);
-    mainFragment.libraries.forEach(emitLibrary);
 
     Iterable<LibraryElement> libraries =
         task.outputLibraryLists[mainOutputUnit];
     if (libraries == null) libraries = [];
-    emitTypedefs();
     emitMangledNames(mainOutput);
 
-    checkEverythingEmitted(elementDescriptors.keys);
+    Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
+    checkEverythingEmitted(descriptors.keys);
 
     CodeBuffer libraryBuffer = new CodeBuffer();
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
-      writeLibraryDescriptor(libraryBuffer, library);
-      elementDescriptors.remove(library);
+      writeLibraryDescriptor(libraryBuffer, library, mainFragment);
+      descriptors.remove(library);
     }
 
-    if (elementDescriptors.isNotEmpty) {
-      List<Element> remainingLibraries = elementDescriptors.keys
+    if (descriptors.isNotEmpty) {
+      List<Element> remainingLibraries = descriptors.keys
           .where((Element e) => e is LibraryElement)
           .toList();
 
       // The remaining descriptors are only accessible through reflection.
       // The program builder does not collect libraries that only
       // contain typedefs that are used for reflection.
       for (LibraryElement element in remainingLibraries) {
         assert(element is LibraryElement || compiler.hasIncrementalSupport);
         if (element is LibraryElement) {
-          writeLibraryDescriptor(libraryBuffer, element);
-          elementDescriptors.remove(element);
+          writeLibraryDescriptor(libraryBuffer, element, mainFragment);
+          descriptors.remove(element);
         }
       }
     }
 
     bool needsNativeSupport = program.needsNativeSupport;
     mainOutput.addBuffer(
         jsAst.prettyPrint(
             buildSetupProgram(program, compiler, backend, namer, this),
             compiler));
 
@@ skipping 245 matching lines @@
   /// itself.
   Map<OutputUnit, String> emitDeferredOutputUnits(Program program) {
     if (!program.isSplit) return const {};
 
     Map<OutputUnit, CodeBuffer> outputBuffers =
         new Map<OutputUnit, CodeBuffer>();
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
 
+      Map<Element, ClassBuilder> descriptors = elementDescriptors[fragment];
 
-      fragment.libraries.forEach(emitLibrary);
-
-      if (elementDescriptors.isNotEmpty) {
+      if (descriptors != null && descriptors.isNotEmpty) {
         Iterable<LibraryElement> libraries =
             task.outputLibraryLists[outputUnit];
         if (libraries == null) libraries = [];
 
         // TODO(johnniwinther): Avoid creating [CodeBuffer]s.
         CodeBuffer buffer = new CodeBuffer();
         outputBuffers[outputUnit] = buffer;
         for (LibraryElement library in Elements.sortedByPosition(libraries)) {
-          writeLibraryDescriptor(buffer, library);
-          elementDescriptors.remove(library);
+          writeLibraryDescriptor(buffer, library, fragment);
+          descriptors.remove(library);
         }
       }
     }
 
     return emitDeferredCode(program, outputBuffers);
   }
 
   int emitProgram(ProgramBuilder programBuilder) {
     Program program = programBuilder.buildProgram(
         storeFunctionTypesInMetadata: true);
 
+    assembleProgram(program);
+
     // Shorten the code by using [namer.currentIsolate] as temporary.
     isolateProperties = namer.currentIsolate;
 
     // Emit deferred units first, so we have their hashes.
     // Map from OutputUnit to a hash of its content. The hash uniquely
     // identifies the code of the output-unit. It does not include
     // boilerplate JS code, like the sourcemap directives or the hash
     // itself.
     Map<OutputUnit, String> deferredLoadHashes =
         emitDeferredOutputUnits(program);
@@ skipping 11 matching lines @@
     if (sourceMapUri != null && fileUri != null) {
       String sourceMapFileName = relativize(fileUri, sourceMapUri, false);
       return '''
 
 //# sourceMappingURL=$sourceMapFileName
 ''';
     }
     return '';
   }
 
-  ClassBuilder getElementDescriptor(Element element) {
+  ClassBuilder getElementDescriptor(Element element, Fragment fragment) {
     Element owner = element.library;
     if (!element.isLibrary && !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.directlyInstantiatedClasses.contains(cls) &&
           !cls.isNative &&
           compiler.deferredLoadTask.outputUnitForElement(element) ==
               compiler.deferredLoadTask.outputUnitForElement(cls)) {
         owner = cls;
       }
     }
     if (owner == null) {
       compiler.internalError(element, 'Owner is null.');
     }
-    return elementDescriptors.putIfAbsent(
-        owner,
-        () => new ClassBuilder(owner, namer));
+    return elementDescriptors
+        .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
+        .putIfAbsent(owner, () => new ClassBuilder(owner, namer));
   }
 
   /// Emits support-code for deferred loading into [output].
   void emitDeferredBoilerPlate(CodeOutput output,
                                Map<OutputUnit, String> deferredLoadHashes) {
     jsAst.Statement functions = js.statement('''
         {
           // Function for checking if a hunk is loaded given its hash.
           #isHunkLoaded = function(hunkHash) {
             return !!$deferredInitializers[hunkHash];
@@ skipping 247 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }