dart2js: First build all ASTs of deferred code then print them.

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 1291 matching lines @@
     }
 
     // Collect the AST for the decriptors
     Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
     if (descriptors == null) descriptors = const {};
 
     checkEverythingEmitted(descriptors.keys);
 
     Iterable<LibraryElement> libraries =
         task.outputLibraryLists[mainOutputUnit];
-    if (libraries == null) libraries = [];
+    if (libraries == null) libraries = <LibraryElement>[];
 
     List<jsAst.Expression> parts = <jsAst.Expression>[];
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
       parts.add(generateLibraryDescriptor(library, mainFragment));
       descriptors.remove(library);
     }
 
     if (descriptors.isNotEmpty) {
       List<Element> remainingLibraries = descriptors.keys
       .where((Element e) => e is LibraryElement)
@@ skipping 295 matching lines @@
       })(holder, stub, existingStub, existing, method));
     }
   } else {
     method = arrayOrFunction;
     holder[name] = method;
   }
   if (isStatic) globalFunctionsAccess[name] = method;
 }""");
   }
 
-  /// 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(Program program) {
-    if (!program.isSplit) return const {};
-
+  Map<OutputUnit, jsAst.Expression> buildDescriptorsForOutputUnits(
+      Program program) {
     Map<OutputUnit, jsAst.Expression> outputs =
         new Map<OutputUnit, jsAst.Expression>();
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
 
       Map<Element, ClassBuilder> descriptors = elementDescriptors[fragment];
 
       if (descriptors != null && descriptors.isNotEmpty) {
         Iterable<LibraryElement> libraries =
-            task.outputLibraryLists[outputUnit];
+        task.outputLibraryLists[outputUnit];
         if (libraries == null) libraries = [];
 
         // TODO(johnniwinther): Avoid creating [CodeBuffer]s.
         List<jsAst.Expression> parts = <jsAst.Expression>[];
         for (LibraryElement library in Elements.sortedByPosition(libraries)) {
           parts.add(generateLibraryDescriptor(library, fragment));
           descriptors.remove(library);
         }
 
         outputs[outputUnit] = new jsAst.ArrayInitializer(parts);
       }
     }
 
-    return emitDeferredCode(program, outputs);
+    return outputs;
   }
 
   int emitProgram(ProgramBuilder programBuilder) {
     Program program = programBuilder.buildProgram(
         storeFunctionTypesInMetadata: true);
 
     assembleProgram(program);
 
+    // Construct the ASTs for all deferred output units.
+    Map<OutputUnit, jsAst.Program> deferredParts =
+        buildOutputAstForDeferredCode(program);
+
     // 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);
+        emitDeferredOutputUnits(deferredParts);
     emitMainOutputUnit(program, deferredLoadHashes);
 
     if (backend.requiresPreamble &&
         !backend.htmlLibraryIsLoaded) {
       compiler.reportHint(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
@@ skipping 99 matching lines @@
       parts.add(js.statement("# = #", [globalName, initializer]));
     }
 
     emitMapping(embeddedNames.DEFERRED_LIBRARY_URIS, deferredLibraryUris);
     emitMapping(embeddedNames.DEFERRED_LIBRARY_HASHES,
                 deferredLibraryHashes);
 
     return new jsAst.Block(parts);
   }
 
-  /// 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(
-      Program program,
-      Map<OutputUnit, jsAst.Expression> deferredAsts) {
+  Map <OutputUnit, jsAst.Program> buildOutputAstForDeferredCode(
+      Program program) {
+    if (!program.isSplit) return const <OutputUnit, jsAst.Program>{};
 
-    Map<OutputUnit, String> hunkHashes = new Map<OutputUnit, String>();
+    Map<OutputUnit, jsAst.Program> result =
+        new Map<OutputUnit, jsAst.Program>();
+
+    Map<OutputUnit, jsAst.Expression> deferredAsts =
+        buildDescriptorsForOutputUnits(program);
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
-
       jsAst.Expression libraryDescriptor = deferredAsts[outputUnit];
-
-      List<CodeOutputListener> outputListeners = <CodeOutputListener>[];
-      Hasher hasher = new Hasher();
-      outputListeners.add(hasher);
-
-      LineColumnCollector lineColumnCollector;
-      if (generateSourceMap) {
-        lineColumnCollector = new LineColumnCollector();
-        outputListeners.add(lineColumnCollector);
-      }
-
-      String partPrefix =
-          backend.deferredPartFileName(outputUnit.name, addExtension: false);
-      CodeOutput output = new StreamCodeOutput(
-          compiler.outputProvider(partPrefix, 'part.js'),
-          outputListeners);
-
-      outputBuffers[outputUnit] = output;
-
       List<jsAst.Statement> body = <jsAst.Statement>[];
 
       // No renaming in the top-level function to save the locals for the
       // nested context where they will be used more.
       body.add(js.comment("/* ::norenaming:: "));
 
       for (String globalObject in Namer.reservedGlobalObjectNames) {
         body.add(js.statement('var #object = ${globalsHolder}.#object;',
                               {'object': globalObject}));
       }
@@ skipping 26 matching lines @@
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       body.add(js.statement("${namer.currentIsolate} = arguments[1];"));
 
       body.add(buildCompileTimeConstants(fragment.constants,
                                          isMainFragment: false));
       body.add(buildStaticNonFinalFieldInitializations(outputUnit));
 
       List<jsAst.Statement> statements = <jsAst.Statement>[];
 
-      statements..add(buildGeneratedBy())
+      statements
+          ..add(buildGeneratedBy())
           ..add(js.statement('${deferredInitializers}.current = '
-              """function (${globalsHolder}) {
-                   #
-                 }
+                             """function (${globalsHolder}) {
+                                  #
+                                }
                              """, [body]));
 
-      output.addBuffer(jsAst.prettyPrint(new jsAst.Program(statements),
+      result[outputUnit] = new jsAst.Program(statements);
+    }
+
+    return result;
+  }
+
+  /// 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(
+      Map<OutputUnit, jsAst.Program> outputAsts) {
+
+    Map<OutputUnit, String> hunkHashes = new Map<OutputUnit, String>();
+
+    for (OutputUnit outputUnit in outputAsts.keys) {
+      List<CodeOutputListener> outputListeners = <CodeOutputListener>[];
+      Hasher hasher = new Hasher();
+      outputListeners.add(hasher);
+
+      LineColumnCollector lineColumnCollector;
+      if (generateSourceMap) {
+        lineColumnCollector = new LineColumnCollector();
+        outputListeners.add(lineColumnCollector);
+      }
+
+      String partPrefix =
+          backend.deferredPartFileName(outputUnit.name, addExtension: false);
+      CodeOutput output = new StreamCodeOutput(
+          compiler.outputProvider(partPrefix, 'part.js'),
+          outputListeners);
+
+      outputBuffers[outputUnit] = output;
+
+      output.addBuffer(jsAst.prettyPrint(outputAsts[outputUnit],
                                          compiler,
                                          monitor: compiler.dumpInfoTask));
 
       // Make a unique hash of the code (before the sourcemaps are added)
       // This will be used to retrieve the initializing function from the global
       // variable.
       String hash = hasher.getHash();
 
       output.add('$N${deferredInitializers}["$hash"]$_=$_'
                        '${deferredInitializers}.current$N');
@@ skipping 75 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }