First end-to-end capability in analyzer2dart.

sdk/lib/_internal/compiler/implementation/dart_backend/outputter.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 dart_backend;
 
 typedef bool IsSafeToRemoveTypeDeclarations(
     Map<ClassElement, Iterable<Element>> classMembers);
 typedef void ElementCallback<E>(E element);
 typedef void ElementPostProcessFunction(
     AstElement element, ElementAst elementAst,
     ElementCallback<TypedefElement> typedefCallback,
     ElementCallback<ClassElement> classCallback);
 typedef ElementAst ComputeElementAstFunction(AstElement element);
 typedef bool ElementFilter(Element element);
+typedef List<Element> ElementSorter(Iterable<Element> elements);
 
 /// Output engine for dart2dart that is shared between the dart2js and the
 /// analyzer implementations of dart2dart.
 class DartOutputter {
   final DiagnosticListener listener;
   final CompilerOutputProvider outputProvider;
   final bool forceStripTypes;
 
   // TODO(antonm): make available from command-line options.
   final bool outputAst = false;
   final bool enableMinification;
 
   /// If `true`, libraries are generated into separate files.
   final bool multiFile;
 
   /// Internal structures accessible for tests and logging.
   // TODO(johnniwinther): Clean this up.
   PlaceholderRenamer renamer;
   MainOutputGenerator output;
   LibraryInfo libraryInfo;
   ElementInfo elementInfo;
 
   // TODO(johnniwinther): Support recompilation.
   DartOutputter(this.listener, this.outputProvider,
                 {bool this.forceStripTypes: false,
                  bool this.enableMinification: false,
                  bool this.multiFile: false});
 
   String assembleProgram({
-      MirrorRenamer mirrorRenamer,
+      MirrorRenamer mirrorRenamer: const MirrorRenamer(),
       Iterable<LibraryElement> libraries,
       Iterable<Element> instantiatedClasses,
       Iterable<Element> resolvedElements,
-      Iterable<ClassElement> usedTypeLiterals,
-      LibraryElement mainLibrary,
+      Iterable<ClassElement> usedTypeLiterals: const <ClassElement>[],
       FunctionElement mainFunction,
       Uri outputUri,
       ElementPostProcessFunction postProcessElementAst,
       ComputeElementAstFunction computeElementAst,
       ElementFilter shouldOutput,
-      IsSafeToRemoveTypeDeclarations isSafeToRemoveTypeDeclarations}) {
+      IsSafeToRemoveTypeDeclarations isSafeToRemoveTypeDeclarations,
+      ElementSorter sortElements}) {
+
+    assert(invariant(NO_LOCATION_SPANNABLE, libraries != null,
+        message: "'libraries' must be non-null."));
+    assert(invariant(NO_LOCATION_SPANNABLE, instantiatedClasses != null,
+        message: "'instantiatedClasses' must be non-null."));
+    assert(invariant(NO_LOCATION_SPANNABLE, resolvedElements != null,
+        message: "'resolvedElements' must be non-null."));
+    assert(invariant(NO_LOCATION_SPANNABLE, mainFunction != null,
+        message: "'mainFunction' must be non-null."));
+    assert(invariant(NO_LOCATION_SPANNABLE, computeElementAst != null,
+        message: "'computeElementAst' must be non-null."));
+    assert(invariant(NO_LOCATION_SPANNABLE, shouldOutput != null,
+        message: "'shouldOutput' must be non-null."));
+    assert(invariant(NO_LOCATION_SPANNABLE,
+        isSafeToRemoveTypeDeclarations != null,
+        message: "'isSafeToRemoveTypeDeclarations' must be non-null."));
+
+    if (sortElements == null) {
+      // Ensure deterministic output order.
+      sortElements = (Iterable<Element> elements) {
+        List<Element> list = elements.toList();
+        list.sort((Element a, Element b) => a.name.compareTo(b.name));
+        return list;
+      };
+    }
 
     libraryInfo = LibraryInfo.processLibraries(libraries, resolvedElements);
 
     elementInfo = ElementInfoProcessor.createElementInfo(
         instantiatedClasses,
         resolvedElements,
         usedTypeLiterals,
         postProcessElementAst: postProcessElementAst,
         parseElementAst: computeElementAst,
-        shouldOutput: shouldOutput);
+        shouldOutput: shouldOutput,
+        sortElements: sortElements);
 
     PlaceholderCollector collector = collectPlaceholders(
         listener,
         mirrorRenamer,
         mainFunction,
         libraryInfo,
         elementInfo);
 
     renamer = createRenamer(
         collector,
         libraryInfo,
         elementInfo,
         enableMinification: enableMinification,
         forceStripTypes: forceStripTypes,
         isSafeToRemoveTypeDeclarations: isSafeToRemoveTypeDeclarations);
 
     String assembledCode;
     if (outputAst) {
       assembledCode = astOutput(listener, elementInfo);
     } else {
       output = new MainOutputGenerator();
       assembledCode = output.generateCode(
           libraryInfo,
           elementInfo,
           collector,
           renamer,
-          mainLibrary,
+          mainFunction,
           outputUri,
           outputProvider,
           mirrorRenamer,
           multiFile: multiFile,
           forceStripTypes: forceStripTypes,
           enableMinification: enableMinification);
     }
     return assembledCode;
   }
 
@@ skipping 36 matching lines @@
 
     PlaceholderRenamer placeholderRenamer = new PlaceholderRenamer(
         libraryInfo.fixedMemberNames, libraryInfo.reexportingLibraries,
         cutDeclarationTypes: shouldCutDeclarationTypes,
         enableMinification: enableMinification);
 
     placeholderRenamer.computeRenames(collector);
     return placeholderRenamer;
   }
 
-  static String astOutput(Compiler compiler,
+  static String astOutput(DiagnosticListener listener,
                           ElementInfo elementInfo) {
     // TODO(antonm): Ideally XML should be a separate backend.
     // TODO(antonm): obey renames and minification, at least as an option.
     StringBuffer sb = new StringBuffer();
     outputElement(element) {
-      sb.write(element.parseNode(compiler).toDebugString());
+      sb.write(element.parseNode(listener).toDebugString());
     }
 
     // Emit XML for AST instead of the program.
     for (Element topLevel in elementInfo.topLevelElements) {
       if (topLevel.isClass &&
           !elementInfo.emitNoMembersFor.contains(topLevel)) {
         // TODO(antonm): add some class info.
         elementInfo.classMembers[topLevel].forEach(outputElement);
       } else {
         outputElement(topLevel);
@@ skipping 114 matching lines @@
       {this.postProcessElementAst,
        this.parseElementAst,
        this.shouldOutput});
 
   static ElementInfo createElementInfo(
       Iterable<ClassElement> instantiatedClasses,
       Iterable<AstElement> resolvedElements,
       Iterable<ClassElement> usedTypeLiterals,
       {ElementPostProcessFunction postProcessElementAst,
        ComputeElementAstFunction parseElementAst,
-       ElementFilter shouldOutput}) {
+       ElementFilter shouldOutput,
+       ElementSorter sortElements}) {
     ElementInfoProcessor processor = new ElementInfoProcessor(
         postProcessElementAst: postProcessElementAst,
         parseElementAst: parseElementAst,
         shouldOutput: shouldOutput);
     return processor.process(
-        instantiatedClasses, resolvedElements, usedTypeLiterals);
+        instantiatedClasses, resolvedElements, usedTypeLiterals,
+        sortElements: sortElements);
   }
 
   ElementInfo process(Iterable<ClassElement> instantiatedClasses,
                       Iterable<AstElement> resolvedElements,
-                      Iterable<ClassElement> usedTypeLiterals) {
+                      Iterable<ClassElement> usedTypeLiterals,
+                      {ElementSorter sortElements}) {
     // Build all top level elements to emit and necessary class members.
     instantiatedClasses.where(shouldOutput).forEach(addClass);
     resolvedElements.where(shouldOutput).forEach(addMember);
     usedTypeLiterals.forEach((ClassElement element) {
       if (shouldOutput(element)) {
         if (!topLevelElements.contains(element)) {
           // The class is only referenced by type literals.
           emitNoMembersFor.add(element);
         }
         addClass(element);
       }
     });
 
     // Sort elements.
     List<Element> sortedTopLevels = sortElements(topLevelElements);
     Map<ClassElement, List<Element>> sortedClassMembers =
         new Map<ClassElement, List<Element>>();
     classMembers.forEach((classElement, members) {
       sortedClassMembers[classElement] = sortElements(members);
     });
 
     return new ElementInfo(
         elementAsts, sortedTopLevels, sortedClassMembers, emitNoMembersFor);
   }
 
   void processElement(Element element, ElementAst elementAst) {
-    postProcessElementAst(element, elementAst,
-                          newTypedefElementCallback,
-                          newClassElementCallback);
+    if (postProcessElementAst != null) {
+      postProcessElementAst(element, elementAst,
+                            newTypedefElementCallback,
+                            newClassElementCallback);
+    }
     elementAsts[element] = elementAst;
   }
 
   void addTopLevel(AstElement element, ElementAst elementAst) {
     if (topLevelElements.contains(element)) return;
     topLevelElements.add(element);
     processElement(element, elementAst);
   }
 
   void addClass(ClassElement classElement) {
@@ skipping 34 matching lines @@
 class MainOutputGenerator {
   final Map<ClassNode, List<Node>> memberNodes =
        new Map<ClassNode, List<Node>>();
   final List<Node> topLevelNodes = <Node>[];
 
   String generateCode(
       LibraryInfo libraryInfo,
       ElementInfo elementInfo,
       PlaceholderCollector collector,
       PlaceholderRenamer placeholderRenamer,
-      LibraryElement mainApp,
+      FunctionElement mainFunction,
       Uri outputUri,
       CompilerOutputProvider outputProvider,
       MirrorRenamer mirrorRenamer,
       {bool multiFile: false,
        bool forceStripTypes: false,
        bool enableMinification: false}) {
     for (Element element in elementInfo.topLevelElements) {
       topLevelNodes.add(elementInfo.elementAsts[element].ast);
       if (element.isClass && !element.isMixinApplication) {
         final members = <Node>[];
@@ skipping 21 matching lines @@
     if (multiFile) {
       // TODO(sigurdm): Factor handling of library-paths out from emitting.
       String mainName = 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 libraryInfo.userLibraries) {
-        if (library == mainApp) {
+        if (library == mainFunction.library) {
           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)}";
         }
@@ skipping 52 matching lines @@
       for(LibraryElement outputLibrary in libraryInfo.userLibraries) {
         // TODO(sigurdm): Make the unparser output directly into the buffer
         // instead of caching in `.result`.
         String code = unparsers[outputLibrary].result;
         totalSize += code.length;
         outputProvider(outputPaths[outputLibrary], "dart")
              ..add(code)
              ..close();
       }
       // TODO(sigurdm): We should get rid of compiler.assembledCode.
-      assembledCode = unparsers[mainApp].result;
+      assembledCode = unparsers[mainFunction.library].result;
     } else {
       assembledCode = mainUnparser.result;
       outputProvider("", "dart")
            ..add(assembledCode)
            ..close();
 
       totalSize = assembledCode.length;
     }
 
     return assembledCode;
   }
 }