Add option for outputting a deferred loading mapping.

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 'constants/expressions.dart';
 import 'constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
@@ skipping 22 matching lines @@
     FunctionElement,
     LibraryElement,
     MetadataAnnotation,
     PrefixElement,
     ScopeContainerElement,
     TypedefElement,
     VoidElement;
 
 import 'util/util.dart' show
     Link, makeUnique;
+import 'util/uri_extras.dart' as uri_extras;
 
 import 'util/setlet.dart' show
     Setlet;
 
 import 'tree/tree.dart' show
     Import,
     LibraryTag,
     LibraryDependency,
     LiteralDartString,
     LiteralString,
@@ skipping 86 matching lines @@
   /// [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<Import, LibraryElement> _allDeferredImports =
       new Map<Import, LibraryElement>();
 
+  /// Because the token-stream is forgotten later in the program, we cache a
+  /// description of each deferred import.
+  final _deferredImportDescriptions = new Map<Import, ImportDescription>();
+
   // For each deferred import we want to know exactly what elements have to
   // be loaded.
   Map<Import, Set<Element>> _importedDeferredBy = null;
   Map<Import, Set<ConstantValue>> _constantsDeferredBy = null;
 
   Set<Element> _mainElements = new Set<Element>();
 
   DeferredLoadTask(Compiler compiler) : super(compiler) {
     mainOutputUnit.imports.add(_fakeMainImport);
   }
@@ skipping 451 matching lines @@
           allOutputUnits.add(representative);
         }
         _constantToOutputUnit[constant] = representative;
       });
 
       // Generate a unique name for each OutputUnit.
       _assignNamesToOutputUnits(allOutputUnits);
     });
   }
 
-  void ensureMetadataResolved(Compiler compiler) {
+  void beforeResolution(Compiler compiler) {
     if (compiler.mainApp == null) return;
     _allDeferredImports[_fakeMainImport] = compiler.mainApp;
     var lastDeferred;
     // When detecting duplicate prefixes of deferred libraries there are 4
     // cases of duplicate prefixes:
     // 1.
     // import "lib.dart" deferred as a;
     // import "lib2.dart" deferred as a;
     // 2.
     // import "lib.dart" deferred as a;
@@ skipping 33 matching lines @@
               }
             }
           }
 
           String prefix = (import.prefix != null)
               ? import.prefix.toString()
               : null;
           // The last import we saw with the same prefix.
           Import previousDeferredImport = prefixDeferredImport[prefix];
           if (import.isDeferred) {
-            _allDeferredImports[import] = library.getLibraryFromTag(import);
+            LibraryElement importedLibrary = library.getLibraryFromTag(import);
+            _allDeferredImports[import] = importedLibrary;
 
             if (prefix == null) {
               compiler.reportError(import,
                   MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX);
             } else {
               prefixDeferredImport[prefix] = import;
+              _deferredImportDescriptions[import] =
+                  new ImportDescription(import, library, compiler);
             }
             isProgramSplit = true;
             lastDeferred = import;
           }
           if (prefix != null) {
             if (previousDeferredImport != null ||
                 (import.isDeferred && usedPrefixes.contains(prefix))) {
               Import failingImport = (previousDeferredImport != null)
                   ? previousDeferredImport
                   : import;
@@ skipping 66 matching lines @@
     if (identifier == null) return null;
     Element maybePrefix = elements[identifier];
     if (maybePrefix != null && maybePrefix.isPrefix) {
       PrefixElement prefixElement = maybePrefix;
       if (prefixElement.isDeferred) {
         return prefixElement;
       }
     }
     return null;
   }
+
+  /// Returns a json-style map for describing what files that are loaded by a
+  /// given deferred import.

[floitsch, 2015/01/05 15:46:19]

Add comment what the keys and values are.

[sigurdm, 2015/01/06 09:02:20]

Done.

+  Map<String, Map<String, List<String>>> getDeferredMap() {

[floitsch, 2015/01/05 15:46:19]

'getX' doesn't say why this is not a getter.
computeDeferredMap is not much better, but makes it clear that the call we
create the map.

[sigurdm, 2015/01/06 09:02:20]

Done.

+    JavaScriptBackend backend = compiler.backend;
+    Map<String, Map<String, List<String>>> mapping =

[floitsch, 2015/01/05 15:46:19]

Now I understand why you didn't add the types...

[sigurdm, 2015/01/06 09:02:20]

First the map had a different structure that could not be typed. Then I forgot
to add them back.
But they are indeed horrid.

+        new Map<String, Map<String, List<String>>>();
+    _deferredImportDescriptions.keys.forEach((ast.Import import) {
+      List<OutputUnit> outputUnits = hunksToLoad[importDeferName[import]];
+      ImportDescription description = _deferredImportDescriptions[import];
+      Map<String, List<String>> fileLists =
+          mapping.putIfAbsent(description.importingUri,
+                              () => new Map<String, List<String>>());
+
+      fileLists[description.prefix] = outputUnits.map(
+          (OutputUnit outputUnit) {
+        return backend.outputFileName("${outputUnit.name}.part.js");

[floitsch, 2015/01/05 15:46:19]

Don't add the extension here.
Ask for the deferredPartFileName on backend.

[sigurdm, 2015/01/06 09:02:20]

Done.

+      }).toList();
+    });
+    return mapping;
+  }
 }
+
+class ImportDescription {
+  /// Relative uri to the importing library.
+  final String importingUri;
+  /// The prefix this import is imported as.
+  final String prefix;
+
+  ImportDescription(Import import,
+                    LibraryElement importingLibrary,
+                    Compiler compiler)
+      : importingUri = uri_extras.relativize(
+          compiler.mainApp.canonicalUri,
+          importingLibrary.canonicalUri, false),
+        prefix = import.prefix.source;
+}