dart2js: report output unit imports to dump-info

pkg/compiler/lib/src/deferred_load.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 deferred_load;
 
 import 'common.dart';
 import 'common/backend_api.dart' show
     Backend;
 import 'common/tasks.dart' show
@@ skipping 60 matching lines @@
 /// OutputUnits are equal if their [imports] are equal.
 class OutputUnit {
   /// The deferred imports that will load this output unit when one of them is
   /// loaded.
   final Setlet<_DeferredImport> imports = new Setlet<_DeferredImport>();
 
   /// `true` if this output unit is for the main output file.
   final bool isMainOutput;
 
   /// A unique name representing this [OutputUnit].
-  /// Based on the set of [imports].
   String name;
 
   OutputUnit({this.isMainOutput: false});
 
   String toString() => "OutputUnit($name)";
 
   bool operator==(OutputUnit other) {
     return imports.length == other.imports.length &&
         imports.containsAll(other.imports);
   }
@@ skipping 33 matching lines @@
 
   /// A mapping from the name of a defer import to all the output units it
   /// depends on in a list of lists to be loaded in the order they appear.
   ///
   /// For example {"lib1": [[lib1_lib2_lib3], [lib1_lib2, lib1_lib3],
   /// [lib1]]} would mean that in order to load "lib1" first the hunk
   /// lib1_lib2_lib2 should be loaded, then the hunks lib1_lib2 and lib1_lib3
   /// can be loaded in parallel. And finally lib1 can be loaded.
   final Map<String, List<OutputUnit>> hunksToLoad =
       new Map<String, List<OutputUnit>>();
-  final Map<_DeferredImport, String> _importDeferName =
+
+  /// A cache of the result of calling `computeImportDeferName` on the keys of
+  /// this map.
+  final Map<_DeferredImport, String> importDeferName =
       <_DeferredImport, String>{};
 
   /// A mapping from elements and constants to their output unit. Query this via
   /// [outputUnitForElement]
   final Map<Element, OutputUnit> _elementToOutputUnit =
       new Map<Element, OutputUnit>();
 
   /// A mapping from constants to their output unit. Query this via
   /// [outputUnitForConstant]
   final Map<ConstantValue, OutputUnit> _constantToOutputUnit =
       new Map<ConstantValue, OutputUnit>();
 
   /// All the imports with a [DeferredLibrary] annotation, mapped to the
   /// [LibraryElement] they import.
   /// The main library is included in this set for convenience.
   final Map<_DeferredImport, LibraryElement> _allDeferredImports =
       new Map<_DeferredImport, LibraryElement>();
 
   /// Because the token-stream is forgotten later in the program, we cache a
   /// description of each deferred import.
-  final Map<_DeferredImport, ImportDescription>_deferredImportDescriptions =
+  final Map<_DeferredImport, ImportDescription> _deferredImportDescriptions =
       <_DeferredImport, ImportDescription>{};
 
   // For each deferred import we want to know exactly what elements have to
   // be loaded.
   Map<_DeferredImport, Set<Element>> _importedDeferredBy = null;
   Map<_DeferredImport, Set<ConstantValue>> _constantsDeferredBy = null;
 
   Set<Element> _mainElements = new Set<Element>();
 
   DeferredLoadTask(Compiler compiler) : super(compiler) {
@@ skipping 28 matching lines @@
     return _constantToOutputUnit[constant];
   }
 
   bool isDeferred(Element element) {
     return outputUnitForElement(element) != mainOutputUnit;
   }
 
   /// Returns the unique name for the deferred import of [prefix].
   String getImportDeferName(Spannable node, PrefixElement prefix) {
     String name =
-        _importDeferName[new _DeclaredDeferredImport(prefix.deferredImport)];
+        importDeferName[new _DeclaredDeferredImport(prefix.deferredImport)];
     if (name == null) {
       reporter.internalError(node, "No deferred name for $prefix.");
     }
     return name;
   }
 
   /// Returns `true` if element [to] is reachable from element [from] without
   /// crossing a deferred import.
   ///
   /// For example, if we have two deferred libraries `A` and `B` that both
@@ skipping 348 matching lines @@
 
   /// Computes a unique string for the name field for each outputUnit.
   ///
   /// Also sets up the [hunksToLoad] mapping.
   void _assignNamesToOutputUnits(Set<OutputUnit> allOutputUnits) {
     Set<String> usedImportNames = new Set<String>();
 
     void computeImportDeferName(_DeferredImport import) {
       String result = import.computeImportDeferName(compiler);
       assert(result != null);
-      _importDeferName[import] = makeUnique(result, usedImportNames);
+      importDeferName[import] = makeUnique(result, usedImportNames);
     }
 
     int counter = 1;
 
     for (_DeferredImport import in _allDeferredImports.keys) {
       computeImportDeferName(import);
     }
 
     for (OutputUnit outputUnit in allOutputUnits) {
       if (outputUnit == mainOutputUnit) {
         outputUnit.name = "main";
       } else {
         outputUnit.name = "$counter";
         ++counter;
       }
     }
 
     List sortedOutputUnits = new List.from(allOutputUnits);
     // Sort the output units in descending order of the number of imports they
     // include.
 
-    // The loading of the output units mut be ordered because a superclass needs
-    // to be initialized before its subclass.
+    // The loading of the output units must be ordered because a superclass
+    // needs to be initialized before its subclass.
     // But a class can only depend on another class in an output unit shared by
     // a strict superset of the imports:
     // By contradiction: Assume a class C in output unit shared by imports in
     // the set S1 = (lib1,.., lib_n) depends on a class D in an output unit
     // shared by S2 such that S2 not a superset of S1. Let lib_s be a library in
-    // S1 not in S2. lib_s must depend on C, and then in turn on D therefore D
+    // S1 not in S2. lib_s must depend on C, and then in turn on D. Therefore D
     // is not in the right output unit.
     sortedOutputUnits.sort((a, b) => b.imports.length - a.imports.length);
 
     // For each deferred import we find out which outputUnits to load.
     for (_DeferredImport import in _allDeferredImports.keys) {
       if (import == _fakeMainImport) continue;
-      hunksToLoad[_importDeferName[import]] = new List<OutputUnit>();
+      hunksToLoad[importDeferName[import]] = new List<OutputUnit>();
       for (OutputUnit outputUnit in sortedOutputUnits) {
         if (outputUnit == mainOutputUnit) continue;
         if (outputUnit.imports.contains(import)) {
-          hunksToLoad[_importDeferName[import]].add(outputUnit);
+          hunksToLoad[importDeferName[import]].add(outputUnit);
         }
       }
     }
   }
 
   void onResolutionComplete(FunctionElement main) {
     if (!isProgramSplit) {
       allOutputUnits.add(mainOutputUnit);
       return;
     }
     if (main == null) return;
     LibraryElement mainLibrary = main.library;
     _importedDeferredBy = new Map<_DeferredImport, Set<Element>>();
     _constantsDeferredBy = new Map<_DeferredImport, Set<ConstantValue>>();
     _importedDeferredBy[_fakeMainImport] = _mainElements;
 
     measureElement(mainLibrary, () {
 
       // Starting from main, traverse the program and find all dependencies.
       _mapDependencies(element: compiler.mainFunction, import: _fakeMainImport);
 
       // Also add "global" dependencies to the main OutputUnit.  These are
-      // things that the backend need but cannot associate with a particular
+      // things that the backend needs but cannot associate with a particular
       // element, for example, startRootIsolate.  This set also contains
       // elements for which we lack precise information.
       for (Element element in compiler.globalDependencies.otherDependencies) {
         _mapDependencies(element: element, import: _fakeMainImport);
       }
 
       // Now check to see if we have to add more elements due to mirrors.
       if (compiler.mirrorsLibrary != null) {
         _addMirrorElements();
       }
@@ skipping 209 matching lines @@
     return null;
   }
 
   /// Returns a json-style map for describing what files that are loaded by a
   /// given deferred import.
   /// The mapping is structured as:
   /// library uri -> {"name": library name, "files": (prefix -> list of files)}
   /// Where
   ///
   /// - <library uri> is the relative uri of the library making a deferred
-  ///   import
-  /// - <library name> is the name of the libary, and "<unnamed>" if it is
+  ///   import.
+  /// - <library name> is the name of the library, and "<unnamed>" if it is
   ///   unnamed.
   /// - <prefix> is the `as` prefix used for a given deferred import.
   /// - <list of files> is a list of the filenames the must be loaded when that
   ///   import is loaded.
   Map<String, Map<String, dynamic>> computeDeferredMap() {
     JavaScriptBackend backend = compiler.backend;
     Map<String, Map<String, dynamic>> mapping =
         new Map<String, Map<String, dynamic>>();
     _deferredImportDescriptions.keys.forEach((_DeferredImport import) {
-      List<OutputUnit> outputUnits = hunksToLoad[_importDeferName[import]];
+      List<OutputUnit> outputUnits = hunksToLoad[importDeferName[import]];
       ImportDescription description = _deferredImportDescriptions[import];
       Map<String, dynamic> libraryMap =
           mapping.putIfAbsent(description.importingUri,
               () => <String, dynamic>{"name": description.importingLibraryName,
                                       "imports": <String, List<String>>{}});
 
-      libraryMap["imports"][description.prefix] = outputUnits.map(
+      libraryMap["imports"][importDeferName[import]] = outputUnits.map(
             (OutputUnit outputUnit) {
           return backend.deferredPartFileName(outputUnit.name);
         }).toList();
     });
     return mapping;
   }
 
   /// Creates a textual representation of the output unit content.
   String dump() {
     Map<OutputUnit, List<String>> elementMap = <OutputUnit, List<String>>{};
@@ skipping 100 matching lines @@
     return result;
   }
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 }