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;
+            _deferredImportDescriptions[import] =
+                new ImportDescription(import, library, compiler);
 
             if (prefix == null) {
               compiler.reportError(import,
                   MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX);
             } else {
               prefixDeferredImport[prefix] = import;
             }
             isProgramSplit = true;
             lastDeferred = import;
           }
@@ skipping 72 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.
+  Map deferredMap() {

[floitsch, 2015/01/05 14:10:38]

has a getter name.
Either make it a getter, or change the name.

[sigurdm, 2015/01/05 15:23:08]

Done.

+    JavaScriptBackend backend = compiler.backend;
+    Map mapping = {};
+    _deferredImportDescriptions.keys.forEach((ast.Import import) {
+      List<OutputUnit> outputUnits = hunksToLoad[importDeferName[import]];
+      ImportDescription description = _deferredImportDescriptions[import];
+      Map a = mapping.putIfAbsent(description.importingUri, () => {});

[floitsch, 2015/01/05 14:10:38]

what's "a" ?
Type the map (both static and dynamic).

[sigurdm, 2015/01/05 15:23:08]

Fixed the name.
Done.

+
+      a[description.prefix] = outputUnits.map(
+          (OutputUnit outputUnit) {
+        return backend.emitter.oldEmitter.deferredPartFileName(outputUnit);

[floitsch, 2015/01/05 14:10:38]

Don't go through "oldEmitter".
The best is probably currently to add a "emitter.deferredPartFileName" to the
emitter task. That said, it could be shared code. (Currently it is duplicated by
copy/paste).

[sigurdm, 2015/01/05 15:23:08]

Moved it to backend.

+      }).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;
+}