dart2js: Rename Fragment to LibrariesMap and Output to Fragment.

pkg/compiler/lib/src/js_emitter/program_builder.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.js_emitter.program_builder;
 
 import 'js_emitter.dart' show computeMixinClass;
 import 'model.dart';
 
 import '../common.dart';
@@ skipping 31 matching lines @@
       : this._compiler = compiler,
         this._registry = new Registry(compiler);
 
   JavaScriptBackend get backend => _compiler.backend;
   Universe get universe => _compiler.codegenWorld;
 
   /// Mapping from [ClassElement] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
-  /// Mapping from [OutputUnit] to constructed [Output]. We need this to
+  /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
   /// generate the deferredLoadingMap (to know which hunks to load).
-  final Map<OutputUnit, Output> _outputs = <OutputUnit, Output>{};
+  final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
   /// update field-initializers to point to the ConstantModel.
   final Map<ConstantValue, Constant> _constants = <ConstantValue, Constant>{};
 
   Program buildProgram() {
     _task.outputClassLists.forEach(_registry.registerElements);
     _task.outputStaticLists.forEach(_registry.registerElements);
     _task.outputConstantLists.forEach(_registerConstants);
 
     // TODO(kasperl): There's code that implicitly needs access to the special
     // $ holder so we have to register that. Can we track if we have to?
     _registry.registerHolder(r'$');
 
-    MainOutput mainOutput = _buildMainOutput(_registry.mainFragment);
-    Iterable<Output> deferredOutputs = _registry.deferredFragments
-        .map((fragment) => _buildDeferredOutput(mainOutput, fragment));
+    MainFragment mainOutput = _buildMainOutput(_registry.mainLibrariesMap);
+    Iterable<Fragment> deferredOutputs = _registry.deferredLibrariesMap
+        .map((librariesMap) => _buildDeferredOutput(mainOutput, librariesMap));
 
-    List<Output> outputs = new List<Output>(_registry.fragmentCount);
+    List<Fragment> outputs = new List<Fragment>(_registry.librariesMapCount);
     outputs[0] = mainOutput;
     outputs.setAll(1, deferredOutputs);
 
     Program result =
         new Program(outputs, _task.outputContainsConstantList, _buildLoadMap());
 
     // Resolve the superclass references after we've processed all the classes.
     _classes.forEach((ClassElement element, Class c) {
       if (element.superclass != null) {
         c.setSuperclass(_classes[element.superclass]);
       }
       if (element.isMixinApplication) {
         MixinApplication mixinApplication = c;
         mixinApplication.setMixinClass(_classes[computeMixinClass(element)]);
       }
     });
 
     _markEagerClasses();
 
     return result;
   }
 
   void _markEagerClasses() {
     _markEagerInterceptorClasses();
   }
 
   /// Builds a map from loadId to outputs-to-load.
-  Map<String, List<Output>> _buildLoadMap() {
+  Map<String, List<Fragment>> _buildLoadMap() {
     List<OutputUnit> convertHunks(List<OutputUnit> hunks) {
       return hunks.map((OutputUnit unit) => _outputs[unit])
           .toList(growable: false);
     }
 
-    Map<String, List<Output>> loadMap = <String, List<Output>>{};
+    Map<String, List<Fragment>> loadMap = <String, List<Fragment>>{};
     _compiler.deferredLoadTask.hunksToLoad
         .forEach((String loadId, List<OutputUnit> outputUnits) {
       loadMap[loadId] = outputUnits
           .map((OutputUnit unit) => _outputs[unit])
           .toList(growable: false);
     });
     return loadMap;
   }
 
-  MainOutput _buildMainOutput(Fragment fragment) {
+  MainFragment _buildMainOutput(LibrariesMap librariesMap) {
     // Construct the main output from the libraries and the registered holders.
-    MainOutput result = new MainOutput(
+    MainFragment result = new MainFragment(
         "",  // The empty string is the name for the main output file.
         backend.emitter.staticFunctionAccess(_compiler.mainFunction),
-        _buildLibraries(fragment),
-        _buildStaticNonFinalFields(fragment),
-        _buildStaticLazilyInitializedFields(fragment),
-        _buildConstants(fragment),
+        _buildLibraries(librariesMap),
+        _buildStaticNonFinalFields(librariesMap),
+        _buildStaticLazilyInitializedFields(librariesMap),
+        _buildConstants(librariesMap),
         _registry.holders.toList(growable: false));
-    _outputs[fragment.outputUnit] = result;
+    _outputs[librariesMap.outputUnit] = result;
     return result;
   }
 
-  DeferredOutput _buildDeferredOutput(MainOutput mainOutput,
-                                      Fragment fragment) {
-    DeferredOutput result = new DeferredOutput(
-        backend.deferredPartFileName(fragment.name, addExtension: false),
-                                     fragment.name,
+  DeferredFragment _buildDeferredOutput(MainFragment mainOutput,
+                                      LibrariesMap librariesMap) {
+    DeferredFragment result = new DeferredFragment(
+        backend.deferredPartFileName(librariesMap.name, addExtension: false),
+                                     librariesMap.name,
         mainOutput,
-        _buildLibraries(fragment),
-        _buildStaticNonFinalFields(fragment),
-        _buildStaticLazilyInitializedFields(fragment),
-        _buildConstants(fragment));
-    _outputs[fragment.outputUnit] = result;
+        _buildLibraries(librariesMap),
+        _buildStaticNonFinalFields(librariesMap),
+        _buildStaticLazilyInitializedFields(librariesMap),
+        _buildConstants(librariesMap));
+    _outputs[librariesMap.outputUnit] = result;
     return result;
   }
 
-  List<Constant> _buildConstants(Fragment fragment) {
+  List<Constant> _buildConstants(LibrariesMap librariesMap) {
     List<ConstantValue> constantValues =
-        _task.outputConstantLists[fragment.outputUnit];
+        _task.outputConstantLists[librariesMap.outputUnit];
     if (constantValues == null) return const <Constant>[];
     return constantValues.map((ConstantValue value) => _constants[value])
         .toList(growable: false);
   }
 
-  List<StaticField> _buildStaticNonFinalFields(Fragment fragment) {
+  List<StaticField> _buildStaticNonFinalFields(LibrariesMap librariesMap) {
     // TODO(floitsch): handle static non-final fields correctly with deferred
     // libraries.
-    if (fragment != _registry.mainFragment) return const <StaticField>[];
+    if (librariesMap != _registry.mainLibrariesMap) {
+      return const <StaticField>[];
+    }
     Iterable<VariableElement> staticNonFinalFields =
         backend.constants.getStaticNonFinalFieldsForEmission();
     return Elements.sortedByPosition(staticNonFinalFields)
         .map(_buildStaticField)
         .toList(growable: false);
   }
 
   StaticField _buildStaticField(Element element) {
     JavaScriptConstantCompiler handler = backend.constants;
     ConstantValue initialValue = handler.getInitialValueFor(element).value;
     js.Expression code = _task.emitter.constantReference(initialValue);
     String name = namer.getNameOfGlobalField(element);
     bool isFinal = false;
     bool isLazy = false;
     return new StaticField(element,
                            name, _registry.registerHolder(r'$'), code,
                            isFinal, isLazy);
   }
 
-  List<StaticField> _buildStaticLazilyInitializedFields(Fragment fragment) {
+  List<StaticField> _buildStaticLazilyInitializedFields(
+      LibrariesMap librariesMap) {
     // TODO(floitsch): lazy fields should just be in their respective
     // libraries.
-    if (fragment != _registry.mainFragment) return const <StaticField>[];
+    if (librariesMap != _registry.mainLibrariesMap) {
+      return const <StaticField>[];
+    }
 
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     return Elements.sortedByPosition(lazyFields)
         .map(_buildLazyField)
         .where((field) => field != null)  // Happens when the field was unused.
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(Element element) {
     JavaScriptConstantCompiler handler = backend.constants;
     js.Expression code = backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
     String name = namer.getNameOfGlobalField(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
     return new StaticField(element,
                            name, _registry.registerHolder(r'$'), code,
                            isFinal, isLazy);
   }
 
-  List<Library> _buildLibraries(Fragment fragment) {
-    List<Library> libraries = new List<Library>(fragment.length);
+  List<Library> _buildLibraries(LibrariesMap librariesMap) {
+    List<Library> libraries = new List<Library>(librariesMap.length);
     int count = 0;
-    fragment.forEach((LibraryElement library, List<Element> elements) {
+    librariesMap.forEach((LibraryElement library, List<Element> elements) {
       libraries[count++] = _buildLibrary(library, elements);
     });
     return libraries;
   }
 
   // Note that a library-element may have multiple [Library]s, if it is split
   // into multiple output units.
   Library _buildLibrary(LibraryElement library, List<Element> elements) {
     String uri = library.canonicalUri.toString();
 
@@ skipping 218 matching lines @@
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
       String name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     };
   }
 }