dart2js: Rename Fragment to LibrariesMap and Output to Fragment.

pkg/compiler/lib/src/js_emitter/new_emitter/model_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.
 
 library dart2js.new_js_emitter.model_emitter;
 
 import '../../dart2jslib.dart' show Compiler;
 import '../../js/js.dart' as js;
 import '../../js_backend/js_backend.dart' show
     JavaScriptBackend,
@@ skipping 28 matching lines @@
         this.namer = namer,
         constantEmitter =
             new ConstantEmitter(compiler, namer, makeConstantListTemplate);
 
   js.Expression generateEmbeddedGlobalAccess(String global) {
     // TODO(floitsch): We should not use "init" for globals.
     return js.js("init.$global");
   }
 
   int emitProgram(Program program) {
-    List<Output> outputs = program.outputs;
-    MainOutput mainUnit = outputs.first;
-    js.Statement mainAst = emitMainUnit(program);
+    List<Fragment> fragments = program.fragments;
+    MainFragment mainFragment = fragments.first;
+    js.Statement mainAst = emitMainFragment(program);
     String mainCode = js.prettyPrint(mainAst, compiler).getText();
-    compiler.outputProvider(mainUnit.outputFileName, 'js')
+    compiler.outputProvider(mainFragment.outputFileName, 'js')
         ..add(buildGeneratedBy(compiler))
         ..add(mainCode)
         ..close();
     int totalSize = mainCode.length;
 
-    outputs.skip(1).forEach((DeferredOutput deferredUnit) {
-      js.Expression ast = emitDeferredUnit(deferredUnit, mainUnit.holders);
+    fragments.skip(1).forEach((DeferredFragment deferredUnit) {
+      js.Expression ast =
+          emitDeferredFragment(deferredUnit, mainFragment.holders);
       String code = js.prettyPrint(ast, compiler).getText();
       totalSize += code.length;
       compiler.outputProvider(deferredUnit.outputFileName, deferredExtension)
           ..add(code)
           ..close();
     });
     return totalSize;
   }
 
   js.LiteralString unparse(Compiler compiler, js.Expression value) {
     String text = js.prettyPrint(value, compiler).getText();
     if (value is js.Fun) text = '($text)';
     return js.js.escapedString(text);
   }
 
   String buildGeneratedBy(compiler) {
     var suffix = '';
     if (compiler.hasBuildId) suffix = ' version: ${compiler.buildId}';
     return '// Generated by dart2js, the Dart to JavaScript compiler$suffix.\n';
   }
 
-  js.Statement emitMainUnit(Program program) {
-    MainOutput unit = program.outputs.first;
-    List<js.Expression> elements = unit.libraries.map(emitLibrary).toList();
+  js.Statement emitMainFragment(Program program) {
+    MainFragment fragment = program.fragments.first;
+    List<js.Expression> elements = fragment.libraries.map(emitLibrary).toList();
     elements.add(
-        emitLazilyInitializedStatics(unit.staticLazilyInitializedFields));
+        emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
 
     js.Statement nativeBoilerplate;
     if (NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
       nativeBoilerplate =
           NativeGenerator.generateIsolateAffinityTagInitialization(
               backend,
               generateEmbeddedGlobalAccess,
               // TODO(floitsch): convertToFastObject.
               js.js("(function(x) { return x; })", []));
     } else {
       nativeBoilerplate = js.js.statement(";");
     }
 
     js.Expression code = new js.ArrayInitializer(elements);
 
     return js.js.statement(
         boilerplate,
         {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
-         'holders': emitHolders(unit.holders),
+         'holders': emitHolders(fragment.holders),
          'cyclicThrow':
            backend.emitter.staticFunctionAccess(backend.getCyclicThrowHelper()),
          'outputContainsConstantList': program.outputContainsConstantList,
          'embeddedGlobals': emitEmbeddedGlobals(program.loadMap),
-         'constants': emitConstants(unit.constants),
-         'staticNonFinals': emitStaticNonFinalFields(unit.staticNonFinalFields),
+         'constants': emitConstants(fragment.constants),
+         'staticNonFinals': emitStaticNonFinalFields(fragment.staticNonFinalFields),
          'nativeBoilerplate': nativeBoilerplate,
-         'eagerClasses': emitEagerClassInitializations(unit.libraries),
-         'main': unit.main,
+         'eagerClasses': emitEagerClassInitializations(fragment.libraries),
+         'main': fragment.main,
          'code': code});
   }
 
   js.Block emitHolders(List<Holder> holders) {
     // The top-level variables for holders must *not* be renamed by the
     // JavaScript pretty printer because a lot of code already uses the
     // non-renamed names. The generated code looks like this:
     //
     //    var H = {}, ..., G = {};
     //    var holders = [ H, ..., G ];
@@ skipping 13 matching lines @@
     ];
     return new js.Block(statements);
   }
 
   static js.Template get makeConstantListTemplate {
     // TODO(floitsch): remove hard-coded name.
     // TODO(floitsch): there is no harm in caching the template.
     return js.js.uncachedExpressionTemplate('makeConstList(#)');
   }
 
-  js.Block emitEmbeddedGlobals(Map<String, List<Output>> loadMap) {
+  js.Block emitEmbeddedGlobals(Map<String, List<Fragment>> loadMap) {
     List<js.Property> globals = <js.Property>[];
 
     if (loadMap.isNotEmpty) {
       globals.addAll(emitLoadUrisAndHashes(loadMap));
       globals.add(emitIsHunkLoadedFunction());
       globals.add(emitInitializeLoadedHunk());
     }
 
     js.ObjectInitializer globalsObject = new js.ObjectInitializer(globals);
 
     List<js.Statement> statements =
         [new js.ExpressionStatement(
             new js.VariableDeclarationList(
                 [new js.VariableInitialization(
                     new js.VariableDeclaration("init", allowRename: false),
                     globalsObject)]))];
     return new js.Block(statements);
   }
 
-  List<js.Property> emitLoadUrisAndHashes(Map<String, List<Output>> loadMap) {
-    js.ArrayInitializer outputUris(List<Output> outputs) {
-      return js.stringArray(outputs.map((DeferredOutput output) =>
-          "${output.outputFileName}$deferredExtension"));
+  List<js.Property> emitLoadUrisAndHashes(Map<String, List<Fragment>> loadMap) {
+    js.ArrayInitializer outputUris(List<Fragment> fragments) {
+      return js.stringArray(fragments.map((DeferredFragment fragment) =>
+          "${fragment.outputFileName}$deferredExtension"));
     }
-    js.ArrayInitializer outputHashes(List<Output> outputs) {
+    js.ArrayInitializer outputHashes(List<Fragment> fragments) {
       // TODO(floitsch): the hash must depend on the generated code.
       return js.numArray(
-          outputs.map((DeferredOutput output) => output.hashCode));
+          fragments.map((DeferredFragment fragment) => fragment.hashCode));
     }
 
     List<js.Property> uris = new List<js.Property>(loadMap.length);
     List<js.Property> hashes = new List<js.Property>(loadMap.length);
     int count = 0;
-    loadMap.forEach((String loadId, List<Output> outputList) {
-      uris[count] = new js.Property(js.string(loadId), outputUris(outputList));
+    loadMap.forEach((String loadId, List<Fragment> fragmentList) {
+      uris[count] =
+          new js.Property(js.string(loadId), outputUris(fragmentList));
       hashes[count] =
-          new js.Property(js.string(loadId), outputHashes(outputList));
+          new js.Property(js.string(loadId), outputHashes(fragmentList));
       count++;
     });
 
     return <js.Property>[
          new js.Property(js.string(DEFERRED_LIBRARY_URIS),
                          new js.ObjectInitializer(uris)),
          new js.Property(js.string(DEFERRED_LIBRARY_HASHES),
                          new js.ObjectInitializer(hashes))
          ];
   }
@@ skipping 11 matching lines @@
         js.js("function(hash) { return !!$deferredInitializersGlobal[hash]; }");
     return new js.Property(js.string(IS_HUNK_LOADED), function);
   }
 
   js.Property emitInitializeLoadedHunk() {
     js.Expression function =
         js.js("function(hash) { eval($deferredInitializersGlobal[hash]); }");
     return new js.Property(js.string(INITIALIZE_LOADED_HUNK), function);
   }
 
-  js.Expression emitDeferredUnit(DeferredOutput unit, List<Holder> holders) {
+  js.Expression emitDeferredFragment(DeferredFragment fragment,
+                                     List<Holder> holders) {
     // TODO(floitsch): initialize eager classes.
     // TODO(floitsch): the hash must depend on the output.
     int hash = this.hashCode;
-    if (unit.constants.isNotEmpty) {
+    if (fragment.constants.isNotEmpty) {
       throw new UnimplementedError("constants in deferred units");
     }
     js.ArrayInitializer content =
-        new js.ArrayInitializer(unit.libraries.map(emitLibrary)
-                                              .toList(growable: false));
+        new js.ArrayInitializer(fragment.libraries.map(emitLibrary)
+                                                  .toList(growable: false));
     return js.js("$deferredInitializersGlobal[$hash] = #", content);
   }
 
   js.Block emitConstants(List<Constant> constants) {
     Iterable<js.Statement> statements = constants.map((Constant constant) {
       js.Expression code =
           constantEmitter.initializationExpression(constant.value);
       return js.js.statement("#.# = #;",
                              [constant.holder.name, constant.name, code]);
     });
@@ skipping 332 matching lines @@
 
   var end = Date.now();
   print('Setup: ' + (end - start) + ' ms.');
 
   #main();  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }