Allow dart2dart to output one file per library.

sdk/lib/_internal/compiler/implementation/dart_backend/backend.dart

 // Copyright (c) 2012, 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 dart_backend;
 
 // TODO(ahe): This class is simply wrong.  This backend should use
 // elements when it can, not AST nodes.  Perhaps a [Map<Element,
 // TreeElements>] is what is needed.
 class ElementAst {
   final Node ast;
   final TreeElements treeElements;
 
   ElementAst(AstElement element)
       : this.internal(element.resolvedAst.node, element.resolvedAst.elements);
 
   ElementAst.internal(this.ast, this.treeElements);
 }
 
 class DartBackend extends Backend {
   final List<CompilerTask> tasks;
   final bool forceStripTypes;
   final bool stripAsserts;
   // TODO(antonm): make available from command-line options.
   final bool outputAst = false;
   final Map<ClassNode, List<Node>> memberNodes;
 
+  /// If `true`, libraries are generated into separate files.
+  final bool multiFile;
+
   PlaceholderRenamer placeholderRenamer;
 
   // TODO(zarah) Maybe change this to a command-line option.
   // Right now, it is set by the tests.
   bool useMirrorHelperLibrary = false;
 
   /// Initialized if the useMirrorHelperLibrary field is set.
   MirrorRenamer mirrorRenamer;
 
   /// Initialized when dart:mirrors is loaded if the useMirrorHelperLibrary
@@ skipping 57 matching lines @@
         ClassElement element = type.element;
         // Check all supertypes.
         if (element.allSupertypes != null) {
           element.allSupertypes.forEach(workQueue.add);
         }
       }
     }
     return true;
   }
 
-  DartBackend(Compiler compiler, List<String> strips)
+  DartBackend(Compiler compiler, List<String> strips, {this.multiFile})
       : tasks = <CompilerTask>[],
         memberNodes = new Map<ClassNode, List<Node>>(),
         forceStripTypes = strips.indexOf('types') != -1,
         stripAsserts = strips.indexOf('asserts') != -1,
         constantCompilerTask  = new DartConstantTask(compiler),
         super(compiler) {
     resolutionCallbacks = new DartResolutionCallbacks(this);
   }
 
   bool classNeedsRti(ClassElement cls) => false;
@@ skipping 106 matching lines @@
     }
 
     final elementAsts = new Map<Element, ElementAst>();
 
     ElementAst parse(AstElement element) {
       if (!compiler.irBuilder.hasIr(element)) {
         return new ElementAst(element);
       } else {
         cps_ir.FunctionDefinition function = compiler.irBuilder.getIr(element);
         // Transformations on the CPS IR.
-        compiler.tracer.traceCompilation(element.name, null, compiler); 
+        compiler.tracer.traceCompilation(element.name, null, compiler);
         new ConstantPropagator(compiler, constantSystem).rewrite(function);
         compiler.tracer.traceGraph("Sparse constant propagation", function);
         new RedundantPhiEliminator().rewrite(function);
         compiler.tracer.traceGraph("Redundant phi elimination", function);
         new ShrinkingReducer().rewrite(function);
         compiler.tracer.traceGraph("Shrinking reductions", function);
         // Do not rewrite the IR after variable allocation.  Allocation
         // makes decisions based on an approximation of IR variable live
         // ranges that can be invalidated by transforming the IR.
         new cps_ir.RegisterAllocator().visit(function);
@@ skipping 16 matching lines @@
         compiler.tracer.traceGraph('Unshadow parameters', definition);
 
         TreeElementMapping treeElements = new TreeElementMapping(element);
         backend_ast.Node backendAst =
             backend_ast_emitter.emit(definition);
         Node frontend_ast = backend2frontend.emit(treeElements, backendAst);
         return new ElementAst.internal(frontend_ast, treeElements);
       }
     }
 
+    List<LibraryElement> userLibraries =
+        compiler.libraryLoader.libraries.where(isUserLibrary).toList();
+
     Set<Element> topLevelElements = new Set<Element>();
     Map<ClassElement, Set<Element>> classMembers =
         new Map<ClassElement, Set<Element>>();
 
     // Build all top level elements to emit and necessary class members.
     var newTypedefElementCallback, newClassElementCallback;
 
     void processElement(Element element, ElementAst elementAst) {
       ReferencedElementCollector collector =
           new ReferencedElementCollector(compiler,
@@ skipping 168 matching lines @@
         }
         memberNodes[elementAsts[element].ast] = members;
       }
     }
 
     if (useMirrorHelperLibrary) {
       mirrorRenamer.addRenames(placeholderRenamer.renames,
                                topLevelNodes, collector);
     }
 
-    final EmitterUnparser unparser =
-        new EmitterUnparser(placeholderRenamer.renames,
-                            stripTypes: forceStripTypes,
-                            minify: compiler.enableMinification);
-    for (LibraryElement library in placeholderRenamer.platformImports) {
-      if (library.isPlatformLibrary && !library.isInternalLibrary) {
-        unparser.unparseImportTag(library.canonicalUri.toString());
+    Map<LibraryElement, String> outputPaths = new Map<LibraryElement, String>();
+    Map<LibraryElement, EmitterUnparser> unparsers =
+        new Map<LibraryElement, EmitterUnparser>();
+
+    // The single unparser used if we collect all the output in one file.
+    EmitterUnparser mainUnparser = multiFile
+        ? null
+        : new EmitterUnparser(placeholderRenamer.renames,
+            stripTypes: forceStripTypes,
+            minify: compiler.enableMinification);
+
+    if (multiFile) {
+      // TODO(sigurdm): Factor handling of library-paths out from emitting.
+      String mainName = compiler.outputUri.pathSegments.last;
+      String mainBaseName = mainName.endsWith(".dart")
+          ? mainName.substring(0, mainName.length - 5)
+          : mainName;
+      // Map each library to a path based on the uri of the original
+      // library and [compiler.outputUri].
+      Set<String> usedLibraryPaths = new Set<String>();
+      for (LibraryElement library in userLibraries) {
+        if (library == compiler.mainApp) {
+          outputPaths[library] = mainBaseName;
+        } else {
+          List<String> names =
+              library.canonicalUri.pathSegments.last.split(".");
+          if (names.last == "dart") {
+            names = names.sublist(0, names.length - 1);
+          }
+          outputPaths[library] =
+              "$mainBaseName.${makeUnique(names.join("."), usedLibraryPaths)}";
+        }
+      }
+
+      /// Rewrites imports/exports to refer to the paths given in [outputPaths].
+      for(LibraryElement outputLibrary in userLibraries) {
+        EmitterUnparser unparser = new EmitterUnparser(
+            placeholderRenamer.renames,
+            stripTypes: forceStripTypes,
+            minify: compiler.enableMinification);
+        unparsers[outputLibrary] = unparser;
+        LibraryName libraryName = outputLibrary.libraryTag;
+        if (libraryName != null) {
+          unparser.visitLibraryName(libraryName);
+        }
+        for (LibraryTag tag in outputLibrary.tags) {
+          if (tag is! LibraryDependency) continue;
+          LibraryDependency dependency = tag;
+          LibraryElement libraryElement =
+              outputLibrary.getLibraryFromTag(dependency);
+          String uri = outputPaths.containsKey(libraryElement)
+              ? "${outputPaths[libraryElement]}.dart"
+              : libraryElement.canonicalUri.toString();
+          if (dependency is Import) {
+            unparser.unparseImportTag(uri);
+          } else {
+            unparser.unparseExportTag(uri);
+          }
+        }
+      }
+    } else {
+      for(LibraryElement library in placeholderRenamer.platformImports) {
+        if (library.isPlatformLibrary && !library.isInternalLibrary) {
+          mainUnparser.unparseImportTag(library.canonicalUri.toString());
+        }
       }
     }
+
     for (int i = 0; i < sortedTopLevels.length; i++) {
       Element element = sortedTopLevels[i];
       Node node = topLevelNodes[i];
+      Unparser unparser = multiFile ? unparsers[element.library] : mainUnparser;
       if (node is ClassNode) {
         // TODO(smok): Filter out default constructors here.
         unparser.unparseClassWithBody(node, memberNodes[node]);
       } else {
         unparser.unparse(node);
       }
       unparser.newline();
     }
 
-    compiler.assembledCode = unparser.result;
-    compiler.outputProvider("", "dart")
-         ..add(compiler.assembledCode)
-         ..close();
+    int totalSize = 0;
+    if (multiFile) {
+      for(LibraryElement outputLibrary in userLibraries) {
+        // TODO(sigurdm): Make the unparser output directly into the buffer instead
+        // of caching in `.result`.
+        String code = unparsers[outputLibrary].result;
+        totalSize += code.length;
+        compiler.outputProvider(outputPaths[outputLibrary], "dart")
+             ..add(code)
+             ..close();
+      }
+      // TODO(sigurdm): We should get rid of compiler.assembledCode.
+      compiler.assembledCode = unparsers[compiler.mainApp].result;
+    } else {
+      compiler.assembledCode = mainUnparser.result;
+      compiler.outputProvider("", "dart")
+           ..add(compiler.assembledCode)
+           ..close();
+
+      totalSize = compiler.assembledCode.length;
+    }
+
     // Output verbose info about size ratio of resulting bundle to all
     // referenced non-platform sources.
-    logResultBundleSizeInfo(topLevelElements);
+    logResultBundleSizeInfo(topLevelElements, totalSize);
   }
 
-  void logResultBundleSizeInfo(Set<Element> topLevelElements) {
+  void logResultBundleSizeInfo(Set<Element> topLevelElements,
+                               int totalOutputSize) {
     Iterable<LibraryElement> referencedLibraries =
         compiler.libraryLoader.libraries.where(isUserLibrary);
     // Sum total size of scripts in each referenced library.
     int nonPlatformSize = 0;
     for (LibraryElement lib in referencedLibraries) {
       for (CompilationUnitElement compilationUnit in lib.compilationUnits) {
         nonPlatformSize += compilationUnit.script.file.length;
       }
     }
-    int percentage = compiler.assembledCode.length * 100 ~/ nonPlatformSize;
+    int percentage = totalOutputSize * 100 ~/ nonPlatformSize;
     log('Total used non-platform files size: ${nonPlatformSize} bytes, '
-        'bundle size: ${compiler.assembledCode.length} bytes (${percentage}%)');
+        'Output total size: $totalOutputSize bytes (${percentage}%)');
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 
   Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
     // All platform classes must be resolved to ensure that their member names
     // are preserved.
     loadedLibraries.values.forEach((LibraryElement library) {
       if (library.isPlatformLibrary) {
         library.forEachLocalMember((Element element) {
@@ skipping 186 matching lines @@
   }
 
   Constant compileMetadata(MetadataAnnotation metadata,
                            Node node,
                            TreeElements elements) {
     return measure(() {
       return constantCompiler.compileMetadata(metadata, node, elements);
     });
   }
 }