Add option for outputting a deferred loading mapping.

pkg/compiler/lib/src/js_emitter/old_emitter/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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 1442 matching lines @@
           } 
         }''',
         {"constructorName": constructorName,
          "constructorNameString": js.string(constructorName),
          "hasIsolateSupport": hasIsolateSupport,
          "fieldNamesArray": fieldNamesArray}));
 
     cspPrecompiledConstructorNamesFor(outputUnit).add(js('#', constructorName));
   }
 
-  /// Extracts the output name of the compiler's outputUri.
-  String deferredPartFileName(OutputUnit outputUnit,
-                              {bool addExtension: true}) {
-    String outPath = compiler.outputUri != null
-        ? compiler.outputUri.path
-        : "out";
-    String outName = outPath.substring(outPath.lastIndexOf('/') + 1);
-    String extension = addExtension ? ".part.js" : "";
-    if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
-      return "$outName$extension";
-    } else {
-      String name = outputUnit.name;
-      return "${outName}_$name$extension";
-    }
-  }
-
   void emitLibraries(Iterable<LibraryElement> libraries) {
     if (libraries.isEmpty) return;
 
     // TODO(karlklose): document what kinds of fields this loop adds to the
     // library class builder.
     for (LibraryElement element in libraries) {
       LibraryElement library = element;
       ClassBuilder builder = new ClassBuilder(library, namer);
       if (classEmitter.emitFields(library, builder, emitStatics: true)) {
         jsAst.ObjectInitializer initializer = builder.toObjectInitializer();
@@ skipping 237 matching lines @@
     }
 
     // Constants in checked mode call into RTI code to set type information
     // which may need getInterceptor (and one-shot interceptor) methods, so
     // we have to make sure that [emitGetInterceptorMethods] and
     // [emitOneShotInterceptors] have been called.
     emitCompileTimeConstants(mainBuffer, mainOutputUnit);
 
     emitDeferredBoilerPlate(mainBuffer, deferredLoadHashes);
 
+    if (compiler.deferredMapUri != null) {
+      outputDeferredMap();
+    }
+
     // Static field initializations require the classes and compile-time
     // constants to be set up.
     emitStaticNonFinalFieldInitializations(mainBuffer, mainOutputUnit);
     interceptorEmitter.emitInterceptedNames(mainBuffer);
     interceptorEmitter.emitMapTypeToInterceptor(mainBuffer);
     emitLazilyInitializedStaticFields(mainBuffer);
 
     mainBuffer.writeln();
     mainBuffer.write(nativeBuffer);
 
@@ skipping 340 matching lines @@
     Map<String, List<String>> deferredLibraryUris =
         new Map<String, List<String>>();
     Map<String, List<String>> deferredLibraryHashes =
         new Map<String, List<String>>();
     compiler.deferredLoadTask.hunksToLoad.forEach(
                   (String loadId, List<OutputUnit>outputUnits) {
       List<String> uris = new List<String>();
       List<String> hashes = new List<String>();
       deferredLibraryHashes[loadId] = new List<String>();
       for (OutputUnit outputUnit in outputUnits) {
-        uris.add(deferredPartFileName(outputUnit));
+        uris.add(backend.deferredPartFileName(outputUnit.name));
         hashes.add(deferredLoadHashes[outputUnit]);
       }
 
       deferredLibraryUris[loadId] = uris;
       deferredLibraryHashes[loadId] = hashes;
     });
 
     void emitMapping(String name, Map<String, List<String>> mapping) {
       List<jsAst.Property> properties = new List<jsAst.Property>();
       mapping.forEach((String key, List<String> values) {
@@ skipping 98 matching lines @@
       }
 
       // Make a unique hash of the code (before the sourcemaps are added)
       // This will be used to retrieve the initializing function from the global
       // variable.
       String hash = hashOfString(outputBuffer.getText());
 
       outputBuffer.write('${deferredInitializers}["$hash"]$_=$_'
                          '${deferredInitializers}.current$N');
 
-      String partPrefix = deferredPartFileName(outputUnit, addExtension: false);
+      String partPrefix =
+          backend.deferredPartFileName(outputUnit.name, addExtension: false);
       if (generateSourceMap) {
         Uri mapUri, partUri;
         Uri sourceMapUri = compiler.sourceMapUri;
         Uri outputUri = compiler.outputUri;
 
         String partName = "$partPrefix.part";
 
         if (sourceMapUri != null) {
           String mapFileName = partName + ".js.map";
           List<String> mapSegments = sourceMapUri.pathSegments.toList();
@@ skipping 37 matching lines @@
     SourceFile compiledFile = new StringSourceFile(null, code);
     SourceMapBuilder sourceMapBuilder =
             new SourceMapBuilder(sourceMapUri, fileUri, compiledFile);
     buffer.forEachSourceLocation(sourceMapBuilder.addMapping);
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
+  void outputDeferredMap() {
+    Map<String, dynamic> mapping = new Map<String, dynamic>();
+    // Json does not support comments, so we embed the explanation in the
+    // data.
+    mapping["_comment"] = "This mapping shows which compiled `.js` files are "
+        "needed for a given deferred library import.";
+    mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
+    compiler.outputProvider(compiler.deferredMapUri.path, 'deferred_map')
+        ..add(const JsonEncoder.withIndent("  ").convert(mapping))
+        ..close();
+  }
+
   void invalidateCaches() {
     if (!compiler.hasIncrementalSupport) return;
     if (cachedElements.isEmpty) return;
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }