dart2js: restructure emitter.

sdk/lib/_internal/compiler/implementation/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 65 matching lines @@
    * 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.
    */
   Map<OutputUnit, List<jsAst.Node>> _cspPrecompiledFunctions =
       new Map<OutputUnit, List<jsAst.Node>>();
 
   Map<OutputUnit, List<jsAst.Expression>> _cspPrecompiledConstructorNames =
       new Map<OutputUnit, List<jsAst.Expression>>();
 
-  // True if Isolate.makeConstantList is needed.
-  bool hasMakeConstantList = false;
-
   /**
    * Accumulate properties for classes and libraries, describing their
    * static/top-level members.
    * Later, these members are emitted when the class or library is emitted.
    *
-   * For supporting deferred loading we keep one list per output unit.
-   *
-   * See [getElementDecriptor].
+   * See [getElementDescriptor].
    */
   // TODO(ahe): Generate statics with their class, and store only libraries in
   // this map.
-  final Map<Element, Map<OutputUnit, ClassBuilder>> elementDescriptors
-      = new Map<Element, Map<OutputUnit, ClassBuilder>>();
+  final Map<Element, ClassBuilder> elementDescriptors =
+      new Map<Element, ClassBuilder>();
 
   final bool generateSourceMap;
 
   OldEmitter(Compiler compiler, Namer namer, this.generateSourceMap, this.task)
       : this.compiler = compiler,
         this.namer = namer,
         constantEmitter = new ConstantEmitter(compiler, namer),
         cachedEmittedConstants = compiler.cacheStrategy.newSet(),
         cachedClassBuilders = compiler.cacheStrategy.newMap(),
         cachedElements = compiler.cacheStrategy.newSet() {
@@ skipping 462 matching lines @@
   }
 
   jsAst.Fun get finishIsolateConstructorFunction {
     // We replace the old Isolate function with a new one that initializes
     // all its fields with the initial (and often final) value of all globals.
     //
     // We also copy over old values like the prototype, and the
     // isolateProperties themselves.
     return js('''
       function (oldIsolate) {
-        var isolateProperties = oldIsolate.#;
+        var isolateProperties = oldIsolate.#;  // isolatePropertiesName
         function Isolate() {
           var hasOwnProperty = Object.prototype.hasOwnProperty;
           for (var staticName in isolateProperties)
             if (hasOwnProperty.call(isolateProperties, staticName))
               this[staticName] = isolateProperties[staticName];
 
           // Reset lazy initializers to null.
           // When forcing the object to fast mode (below) v8 will consider
           // functions as part the object's map. Since we will change them
           // (after the first call to the getter), we would have a map
@@ skipping 11 matching lines @@
           new ForceEfficientMap();
 
           // Now, after being a fast map we can set the lazies again.
           for (var lazyInit in lazies) {
             var lazyInitName = lazies[lazyInit];
             this[lazyInitName] = isolateProperties[lazyInitName];
           }
         }
         Isolate.prototype = oldIsolate.prototype;
         Isolate.prototype.constructor = Isolate;
-        Isolate.# = isolateProperties;
-        if (#)
-          Isolate.# = oldIsolate.#;
-        if (#)
-          Isolate.# = oldIsolate.#;
+        Isolate.# = isolateProperties;  // isolatePropertiesName

[Johnni Winther, 2014/10/16 08:04:50]

Maybe we should change [js] to take a map of arguments like MessageKind:

js('Isolate.#{isolatePropertiesName} = isolateProperties;',
{'isolatePropertiesName': namer.isolatePropertiesName})

[floitsch, 2014/10/16 11:53:36]

Thought the same thing.
I might look into this later this or next week.

+        if (#)  // needsDefineClass.
+          Isolate.# = oldIsolate.#;  // finishClassesProperty * 2
+        if (#)  // outputContainsConstantList
+          Isolate.# = oldIsolate.#; // makeConstListProperty * 2
         return Isolate;
       }''',
         [namer.isolatePropertiesName, namer.isolatePropertiesName,
          needsDefineClass, finishClassesProperty, finishClassesProperty,
-         hasMakeConstantList, makeConstListProperty, makeConstListProperty ]);
+         task.outputContainsConstantList,
+         makeConstListProperty, makeConstListProperty ]);
   }
 
   jsAst.Fun get lazyInitializerFunction {
     String isolate = namer.currentIsolate;
     jsAst.Expression cyclicThrow =
         namer.elementAccess(backend.getCyclicThrowHelper());
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
     return js('''
@@ skipping 234 matching lines @@
     if (needsDefineClass) {
       buffer.write('$finishClassesName($classesCollector,'
                    '$_$isolateProperties,'
                    '${_}null)$N');
 
       // Reset the map.
       buffer.write("$classesCollector$_=${_}null$N$n");
     }
   }
 
-  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)) {
+  void emitStaticFunctions(List<Element> staticFunctions) {
+    for (Element element in staticFunctions) {
       ClassBuilder builder = new ClassBuilder(element, namer);
       containerBuilder.addMember(element, builder);
       getElementDescriptor(element).properties.addAll(builder.properties);
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     JavaScriptConstantCompiler handler = backend.constants;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
@@ skipping 92 matching lines @@
     bool isMainBuffer = buffer == mainBuffer;
     if (compiler.hasIncrementalSupport && isMainBuffer) {
       buffer = cachedEmittedConstantsBuffer;
     }
     for (ConstantValue constant in constants) {
       if (compiler.hasIncrementalSupport && isMainBuffer) {
         if (cachedEmittedConstants.contains(constant)) continue;
         cachedEmittedConstants.add(constant);
       }
       String name = namer.constantName(constant);
-      if (constant.isList) emitMakeConstantListIfNotEmitted(buffer);
       jsAst.Expression init = js('#.# = #',
           [namer.globalObjectForConstant(constant), name,
            constantInitializerExpression(constant)]);
       buffer.write(jsAst.prettyPrint(init, compiler,
                                      monitor: compiler.dumpInfoTask));
       buffer.write('$N');
     }
     if (compiler.hasIncrementalSupport && isMainBuffer) {
       mainBuffer.add(cachedEmittedConstantsBuffer);
     }
   }
 
-  void emitMakeConstantListIfNotEmitted(CodeBuffer buffer) {
-    if (hasMakeConstantList) return;
-    hasMakeConstantList = true;
+  void emitMakeConstantList(CodeBuffer buffer) {
     buffer.write(
         jsAst.prettyPrint(
             js.statement(r'''#.# = function(list) {
                                      list.immutable$list = #;
                                      list.fixed$length = #;
                                      return list;
                                    }''',
                          [namer.isolateName, makeConstListProperty, initName,
                           initName]),
             compiler, monitor: compiler.dumpInfoTask));
@@ skipping 187 matching lines @@
         MyClass.prototype = properties;
         new MyClass();
         #;
         return properties;
       }''', [debugCode]);
 
     mainBuffer.add(jsAst.prettyPrint(convertToFastObject, compiler));
     mainBuffer.add(N);
   }
 
-  void writeLibraryDescriptors(
-      LibraryElement library,
-      Map<OutputUnit, CodeBuffer> libraryDescriptorBuffers) {
+  void writeLibraryDescriptors(CodeBuffer buffer, 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];
+    ClassBuilder descriptor = elementDescriptors[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) ?
         library.getLibraryName() :
         "";
 
-    for (OutputUnit outputUnit in compiler.deferredLoadTask.allOutputUnits) {
-      if (!descriptors.containsKey(outputUnit)) continue;
+    jsAst.Fun metadata = metadataEmitter.buildMetadataFunction(library);
 
-      ClassBuilder descriptor = descriptors[outputUnit];
+    jsAst.ObjectInitializer initializers = descriptor.toObjectInitializer();
 
-      jsAst.Fun metadata = metadataEmitter.buildMetadataFunction(library);
+    CodeBuffer libraryDescriptorBuffer = buffer;

[Johnni Winther, 2014/10/16 08:04:50]

Remove and use [buffer] below.

[floitsch, 2014/10/16 11:53:36]

Was to make diff easier. Wasn't really worth it...
done.

 
-      jsAst.ObjectInitializer initializers = descriptor.toObjectInitializer();
-
-      CodeBuffer libraryDescriptorBuffer =
-          libraryDescriptorBuffers.putIfAbsent(outputUnit,
-              () => new CodeBuffer());
-
-      compiler.dumpInfoTask.registerElementAst(library, metadata);
-      compiler.dumpInfoTask.registerElementAst(library, initializers);
-      libraryDescriptorBuffer
-          ..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');
-    }
+    compiler.dumpInfoTask.registerElementAst(library, metadata);
+    compiler.dumpInfoTask.registerElementAst(library, initializers);
+    libraryDescriptorBuffer
+        ..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');
   }
 
   void emitPrecompiledConstructor(OutputUnit outputUnit,
                                   String constructorName,
                                   jsAst.Expression constructorAst) {
     cspPrecompiledFunctionFor(outputUnit).add(
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration(constructorName), constructorAst));
     cspPrecompiledFunctionFor(outputUnit).add(
     js.statement(r'''{
@@ skipping 23 matching lines @@
     String outName = outPath.substring(outPath.lastIndexOf('/') + 1);
     String extension = addExtension ? ".part.js" : "";
     if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
       return "$outName$extension";
     } else {
       String name = outputUnit.name;
       return "${outName}_$name$extension";
     }
   }
 
-  void emitProgram(Program program) {
+  void emitLibraries(Iterable<LibraryElement> libraries) {
+    if (libraries.isEmpty) return;
+
+    // TODO(karlklose): document what kinds of fields this loop adds to the
+    // library class builder.
+    for (LibraryElement element in libraries) {
+      LibraryElement library = element;
+      ClassBuilder builder = new ClassBuilder(library, namer);
+      if (classEmitter.emitFields(
+              library, builder, null, emitStatics: true)) {
+        jsAst.ObjectInitializer initializer =
+          builder.toObjectInitializer();

[Johnni Winther, 2014/10/16 08:04:50]

Indent by 4.

[floitsch, 2014/10/16 11:53:36]

All the statements here actually fit on one line.

+        compiler.dumpInfoTask.registerElementAst(builder.element,
+                                                 initializer);
+        getElementDescriptor(library)
+            .properties.addAll(initializer.properties);
+      }
+    }
+  }
+
+  void emitTypedefs() {
+    OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
+
+    // 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);
+      getElementDescriptor(library)
+          ..addProperty(mangledName, declaration)
+          ..addProperty("+$reflectionName", js.string(''));
+      // Also emit a trivial constructor for CSP mode.
+      String constructorName = mangledName;
+      jsAst.Expression constructorAst = js('function() {}');
+      emitPrecompiledConstructor(mainOutputUnit,
+                                 constructorName,
+                                 constructorAst);
+    }
+  }
+
+  void emitMangledNames() {
+    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));
+      }
+
+      jsAst.Expression mangledNamesAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.MANGLED_NAMES);
+      var map = new jsAst.ObjectInitializer(properties);
+      mainBuffer.write(
+          jsAst.prettyPrint(
+              js.statement('# = #', [mangledNamesAccess, map]),
+              compiler,
+              monitor: compiler.dumpInfoTask));
+      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));
+      }
+      jsAst.Expression mangledGlobalNamesAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
+      var map = new jsAst.ObjectInitializer(properties);
+      mainBuffer.write(
+          jsAst.prettyPrint(
+              js.statement('# = #', [mangledGlobalNamesAccess, map]),
+              compiler,
+              monitor: compiler.dumpInfoTask));
+      if (compiler.enableMinification) {
+        mainBuffer.write(';');
+      }
+    }
+  }
+
+  void checkEverythingEmitted(Iterable<Element> elements) {
+    List<Element> pendingStatics;
+    if (!compiler.hasIncrementalSupport) {
+      pendingStatics =
+          Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
+
+      pendingStatics.forEach((element) =>
+          compiler.reportInfo(
+              element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
+    }
+
+    if (pendingStatics != null && !pendingStatics.isEmpty) {
+      compiler.internalError(pendingStatics.first,
+          'Pending statics (see above).');
+    }
+  }
+
+  void emitMainOutputUnit(Map<OutputUnit, String> deferredLoadHashes,
+                          CodeBuffer nativeBuffer) {
     bool isProgramSplit = compiler.deferredLoadTask.isProgramSplit;
-    // Maps each output unit to a codebuffers with the library descriptors of
-    // the output unit emitted to it.
-    Map<OutputUnit, CodeBuffer> libraryDescriptorBuffers =
-        new Map<OutputUnit, CodeBuffer>();
-
     OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
 
     mainBuffer.add(buildGeneratedBy());
     addComment(HOOKS_API_USAGE, mainBuffer);
 
     if (isProgramSplit) {
       /// For deferred loading we communicate the initializers via this global
       /// variable. The deferred hunks will add their initialization to this.
       /// The semicolon is important in minified mode, without it the
       /// following parenthesis looks like a call to the object literal.
@@ skipping 34 matching lines @@
     }
 
     mainBuffer.add('function ${namer.isolateName}()$_{}\n');
     if (isProgramSplit) {
       mainBuffer
         .write('${globalsHolder}.${namer.isolateName}$_=$_'
                '${namer.isolateName}$N'
                '${globalsHolder}.$initName$_=${_}$initName$N');
     }
     mainBuffer.add('init()$N$n');
-    // Shorten the code by using [namer.currentIsolate] as temporary.
-    isolateProperties = namer.currentIsolate;
-    mainBuffer.add(
-        '$isolateProperties$_=$_$isolatePropertiesName$N');
+    mainBuffer.add('$isolateProperties$_=$_$isolatePropertiesName$N');
 
-    emitStaticFunctions();
+    emitStaticFunctions(task.outputStaticLists[mainOutputUnit]);
 
     // Only output the classesCollector if we actually have any classes.
     if (!(nativeClasses.isEmpty &&
           compiler.codegenWorld.staticFunctionsNeedingGetter.isEmpty &&
-        outputClassLists.values.every((classList) => classList.isEmpty) &&
-        typedefsNeededForReflection.isEmpty)) {
+          outputClassLists.values.every((classList) => classList.isEmpty) &&
+          typedefsNeededForReflection.isEmpty)) {
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
       mainBuffer.add('var $classesCollector$_=${_}Object.create(null)$N$n');
     }
 
-    // Emit native classes on [nativeBuffer].
-    final CodeBuffer nativeBuffer = new CodeBuffer();
     if (!nativeClasses.isEmpty) {
-      addComment('Native classes', nativeBuffer);
       addComment('Native classes', mainBuffer);
-      nativeEmitter.generateNativeClasses(nativeClasses, mainBuffer,
-          additionalProperties);
     }
 
-    for (List<ClassElement> outputClassList in outputClassLists.values) {
-      for (ClassElement element in outputClassList) {
+    List<ClassElement> classes = task.outputClassLists[mainOutputUnit];
+    if (classes != null) {
+      for (ClassElement element in classes) {
         generateClass(element, getElementDescriptor(element));
       }
     }
 
-    nativeEmitter.finishGenerateNativeClasses();
-    nativeEmitter.assembleCode(nativeBuffer);
+    if (compiler.enableMinification) {
+      mainBuffer.write(';');
+    }
 
+    if (elementDescriptors.isNotEmpty) {
+      Iterable<LibraryElement> libraries =
+          task.outputLibraryLists[mainOutputUnit];
+      if (libraries == null) libraries = [];
+      emitLibraries(libraries);
+      emitTypedefs();
+      emitMangledNames();
 
-    // After this assignment we will produce invalid JavaScript code if we use
-    // the classesCollector variable.
-    classesCollector = 'classesCollector should not be used from now on';
+      checkEverythingEmitted(elementDescriptors.keys);
 
-    // TODO(sigurdm): Need to check this for each outputUnit.
-    if (!elementDescriptors.isEmpty) {
-      var oldClassesCollector = classesCollector;
-      classesCollector = r"$$";
-      if (compiler.enableMinification) {
-        mainBuffer.write(';');
+      CodeBuffer libraryBuffer = new CodeBuffer();
+      for (LibraryElement library in Elements.sortedByPosition(libraries)) {
+        writeLibraryDescriptors(libraryBuffer, library);
+        elementDescriptors.remove(library);
       }
 
-      // 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)) {
-            jsAst.ObjectInitializer initializer =
-              builder.toObjectInitializer();
-            compiler.dumpInfoTask.registerElementAst(builder.element,
-                                                     initializer);
-            getElementDescriptor(library)
-                .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);
-        getElementDescriptor(library)
-            ..addProperty(mangledName, declaration)
-            ..addProperty("+$reflectionName", js.string(''));
-        // Also emit a trivial constructor for CSP mode.
-        String constructorName = mangledName;
-        jsAst.Expression constructorAst = js('function() {}');
-        emitPrecompiledConstructor(mainOutputUnit,
-                                   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));
-        }
-
-        jsAst.Expression mangledNamesAccess =
-            generateEmbeddedGlobalAccess(embeddedNames.MANGLED_NAMES);
-        var map = new jsAst.ObjectInitializer(properties);
-        mainBuffer.write(
-            jsAst.prettyPrint(
-                js.statement('# = #', [mangledNamesAccess, map]),
-                compiler,
-                monitor: compiler.dumpInfoTask));
-        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));
-        }
-        jsAst.Expression mangledGlobalNamesAccess =
-            generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
-        var map = new jsAst.ObjectInitializer(properties);
-        mainBuffer.write(
-            jsAst.prettyPrint(
-                js.statement('# = #', [mangledGlobalNamesAccess, map]),
-                compiler,
-                monitor: compiler.dumpInfoTask));
-        if (compiler.enableMinification) {
-          mainBuffer.write(';');
-        }
-      }
-
-      List<Element> sortedElements =
-          Elements.sortedByPosition(elementDescriptors.keys);
-
-      Iterable<Element> pendingStatics;
-      if (!compiler.hasIncrementalSupport) {
-        pendingStatics = sortedElements.where((element) {
-            return !element.isLibrary &&
-                elementDescriptors[element].values.any((descriptor) =>
-                    descriptor != null);
-        });
-
-        pendingStatics.forEach((element) =>
-            compiler.reportInfo(
-                element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
-      }
-
-      for (LibraryElement library in sortedElements.where((element) =>
-          element.isLibrary)) {
-        writeLibraryDescriptors(library, libraryDescriptorBuffers);
-        elementDescriptors[library] = const {};
-      }
-      if (pendingStatics != null && !pendingStatics.isEmpty) {
-        compiler.internalError(pendingStatics.first,
-            'Pending statics (see above).');
-      }
       mainBuffer
           ..write('(')
           ..write(
               jsAst.prettyPrint(
                   getReflectionDataParser(classesCollector, backend),
                   compiler))
           ..write(')')
           ..write('([$n')
-          ..add(libraryDescriptorBuffers[mainOutputUnit])
+          ..add(libraryBuffer)
           ..write('])$N');
 
       emitFinishClassesInvocationIfNecessary(mainBuffer);
-      classesCollector = oldClassesCollector;
     }
+
     typeTestEmitter.emitRuntimeTypeSupport(mainBuffer, mainOutputUnit);
     interceptorEmitter.emitGetInterceptorMethods(mainBuffer);
     interceptorEmitter.emitOneShotInterceptors(mainBuffer);
+
+    if (task.outputContainsConstantList) {
+      emitMakeConstantList(mainBuffer);
+    }
+
     // Constants in checked mode call into RTI code to set type information
     // which may need getInterceptor (and one-shot interceptor) methods, so
     // we have to make sure that [emitGetInterceptorMethods] and
     // [emitOneShotInterceptors] have been called.
     emitCompileTimeConstants(mainBuffer, mainOutputUnit);
 
-    if (isProgramSplit) {
-      /// 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 =
-          emitDeferredCode(libraryDescriptorBuffers);
-      emitDeferredBoilerPlate(mainBuffer, deferredLoadHashes);
-    }
+    emitDeferredBoilerPlate(mainBuffer, deferredLoadHashes);
 
     // Static field initializations require the classes and compile-time
     // constants to be set up.
     emitStaticNonFinalFieldInitializations(mainBuffer);
     interceptorEmitter.emitInterceptedNames(mainBuffer);
     interceptorEmitter.emitMapTypeToInterceptor(mainBuffer);
     emitLazilyInitializedStaticFields(mainBuffer);
 
+    mainBuffer.writeln();
     mainBuffer.add(nativeBuffer);
 
     metadataEmitter.emitMetadata(mainBuffer);
 
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
     mainBuffer.add('${namer.currentIsolate}$_=${_}null$N');
 
     emitFinishIsolateConstructorInvocation(mainBuffer);
@@ skipping 93 matching lines @@
 
       cspBuffer.write(
           jsAst.prettyPrint(
               precompiledFunctionAst, compiler,
               allowVariableMinification: false).getText());
 
       compiler.outputProvider('', 'precompiled.js')
           ..add(cspBuffer.getText())
           ..close();
     }
+  }
+
+  /// Returns a 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> emitDeferredOutputUnits() {
+    if (!compiler.deferredLoadTask.isProgramSplit) return const {};
+
+    Map<OutputUnit, CodeBuffer> outputBuffers =
+        new Map<OutputUnit, CodeBuffer>();
+
+    for (OutputUnit outputUnit in compiler.deferredLoadTask.allOutputUnits) {
+      if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) continue;
+
+      List<Element> functions = task.outputStaticLists[outputUnit];
+      if (functions != null) {
+        emitStaticFunctions(functions);
+      }
+
+      List<ClassElement> classes = task.outputClassLists[outputUnit];
+      if (classes != null) {
+        for (ClassElement element in classes) {
+          generateClass(element, getElementDescriptor(element));
+        }
+      }
+
+      if (elementDescriptors.isNotEmpty) {
+        Iterable<LibraryElement> libraries =
+            task.outputLibraryLists[outputUnit];
+        if (libraries == null) libraries = [];
+        emitLibraries(libraries);
+
+        CodeBuffer buffer = new CodeBuffer();
+        outputBuffers[outputUnit] = buffer;
+        for (LibraryElement library in Elements.sortedByPosition(libraries)) {
+          writeLibraryDescriptors(buffer, library);
+          elementDescriptors.remove(library);
+        }
+      }
+    }
+
+    return emitDeferredCode(outputBuffers);
+  }
+
+  CodeBuffer buildNativesBuffer() {
+    // Emit native classes on [nativeBuffer].
+    final CodeBuffer nativeBuffer = new CodeBuffer();
+
+    if (nativeClasses.isEmpty) return nativeBuffer;
+
+
+    addComment('Native classes', nativeBuffer);
+
+    nativeEmitter.generateNativeClasses(nativeClasses, mainBuffer,
+        additionalProperties);
+
+    nativeEmitter.finishGenerateNativeClasses();
+    nativeEmitter.assembleCode(nativeBuffer);
+
+    return nativeBuffer;
+  }
+
+  void emitProgram(Program program) {
+    // Shorten the code by using [namer.currentIsolate] as temporary.
+    isolateProperties = namer.currentIsolate;
+
+    classesCollector = r"$$";
+
+    // 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();
+    CodeBuffer nativeBuffer = buildNativesBuffer();
+    emitMainOutputUnit(deferredLoadHashes, nativeBuffer);
 
     if (backend.requiresPreamble &&
         !backend.htmlLibraryIsLoaded) {
       compiler.reportHint(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
   }
 
   String generateSourceMapTag(Uri sourceMapUri, Uri fileUri) {
     if (sourceMapUri != null && fileUri != null) {
       String sourceMapFileName = relativize(fileUri, sourceMapUri, false);
       return '''
 
 //# sourceMappingURL=$sourceMapFileName
 ''';
     }
     return '';
   }
 
-  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 getElementDescriptor(Element element) {
     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.instantiatedClasses.contains(cls)
           && !cls.isNative) {
         owner = cls;
       }
     }
     if (owner == null) {
       compiler.internalError(element, 'Owner is null.');
     }
-    return getElementDescriptorForOutputUnit(owner,
-        compiler.deferredLoadTask.outputUnitForElement(element));
+    return elementDescriptors.putIfAbsent(
+        owner,
+        () => new ClassBuilder(owner, namer));
   }
 
   /// Emits support-code for deferred loading into [buffer].
   void emitDeferredBoilerPlate(CodeBuffer buffer,
                                Map<OutputUnit, String> deferredLoadHashes) {
     // Function for checking if a hunk is loaded given its hash.
     buffer.write(jsAst.prettyPrint(
         js('# = function(hunkHash) {'
            '  return !!$deferredInitializers[hunkHash];'
            '}', generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_LOADED)),
@@ skipping 51 matching lines @@
 
     emitMapping(embeddedNames.DEFERRED_LIBRARY_URIS, deferredLibraryUris);
     emitMapping(embeddedNames.DEFERRED_LIBRARY_HASHES,
                 deferredLibraryHashes);
   }
 
   /// Emits code for all output units except the main.
   /// Returns a mapping from outputUnit to a hash of the corresponding hunk that
   /// can be used for calling the initializer.
   Map<OutputUnit, String> emitDeferredCode(
-      Map<OutputUnit, CodeBuffer> libraryDescriptorBuffers) {
+      Map<OutputUnit, CodeBuffer> deferredBuffers) {
 
     Map<OutputUnit, String> hunkHashes = new Map<OutputUnit, String>();
 
     for (OutputUnit outputUnit in compiler.deferredLoadTask.allOutputUnits) {
       if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) continue;
 
-      CodeBuffer libraryDescriptorBuffer = libraryDescriptorBuffers[outputUnit];
+      CodeBuffer libraryDescriptorBuffer = deferredBuffers[outputUnit];
 
       CodeBuffer outputBuffer = new CodeBuffer();
 
-      var oldClassesCollector = classesCollector;
-      classesCollector = r"$$";
-
       outputBuffer..write(buildGeneratedBy())
         ..write('${deferredInitializers}.current$_=$_'
                 'function$_(${globalsHolder}) {$N');
       for (String globalObject in Namer.reservedGlobalObjectNames) {
         outputBuffer
             .write('var $globalObject$_=$_'
                    '${globalsHolder}.$globalObject$N');
       }
       outputBuffer
           ..write('var init$_=$_${globalsHolder}.init$N')
@@ skipping 19 matching lines @@
            ..write('])$N');
 
         if (outputClassLists.containsKey(outputUnit)) {
           outputBuffer.write(
               '$finishClassesName($classesCollector,$_${namer.currentIsolate},'
               '$_$isolatePropertiesName)$N');
         }
 
       }
 
-      classesCollector = oldClassesCollector;
-
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       // We need to do this, because we use the same variable for setting up
       // the isolate-properties and for storing the current isolate. During
       // the setup (the code above this lines) we must set the variable to
       // the isolate-properties.
       // After we have done the setup (finishing with `finishClasses`) it must
       // point to the current Isolate. Otherwise all methods/functions
       // accessing isolate variables will access the wrong object.
       outputBuffer.write("${namer.currentIsolate}$_=${_}arguments[1]$N");
@@ skipping 85 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }