Prepare all unlinked units before linking.

pkg/analyzer_cli/lib/src/build_mode.dart

 // Copyright (c) 2015, 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 analyzer_cli.src.build_mode;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/dart/ast/ast.dart' show CompilationUnit;
@@ skipping 118 matching lines @@
   final AnalysisStats stats;
 
   SummaryDataStore summaryDataStore;
   InternalAnalysisContext context;
   Map<Uri, File> uriToFileMap;
   final List<Source> explicitSources = <Source>[];
   final List<PackageBundle> unlinkedBundles = <PackageBundle>[];
 
   PackageBundleAssembler assembler;
   final Set<Source> processedSources = new Set<Source>();
-  final Map<Uri, UnlinkedUnit> uriToUnit = <Uri, UnlinkedUnit>{};
+  final Map<String, UnlinkedUnit> uriToUnit = <String, UnlinkedUnit>{};
 
   BuildMode(this.resourceProvider, this.options, this.stats);
 
   bool get _shouldOutputSummary =>
       options.buildSummaryOutput != null ||
       options.buildSummaryOutputSemantic != null;
 
   /**
    * Perform package analysis according to the given [options].
    */
@@ skipping 49 matching lines @@
         AnalysisResult analysisResult = context.performAnalysisTask();
         if (!analysisResult.hasMoreWork) {
           break;
         }
       }
     }
 
     // Write summary.
     assembler = new PackageBundleAssembler();
     if (_shouldOutputSummary) {
-      if (options.buildSummaryOnlyUnlinked) {
-        for (var src in explicitSources) {
-          // Note: This adds the unit to the assembler if it needed to be
-          // computed, so we don't need to explicitly do that.
-          _unlinkedUnitForUri('${src.uri}');
-        }
-      } else {
-        Set<String> unlinkedUris =
-            explicitSources.map((Source s) => s.uri.toString()).toSet();
+      // Prepare all unlinked units.
+      for (var src in explicitSources) {
+        _prepareUnlinkedUnit('${src.uri}');
+      }
+
+      // Build and assemble linked libraries.
+      if (!options.buildSummaryOnlyUnlinked) {
+        // Prepare URIs of unlinked units that should be linked.
+        var unlinkedUris = new Set<String>();
         for (var bundle in unlinkedBundles) {
           unlinkedUris.addAll(bundle.unlinkedUnitUris);
         }
-
-        _serializeAstBasedSummary(unlinkedUris);
+        for (var src in explicitSources) {
+          unlinkedUris.add('${src.uri}');
+        }
+        // Perform linking.
+        _computeLinkedLibraries(unlinkedUris);
         assembler.recordDependencies(summaryDataStore);
       }
+
       // Write the whole package bundle.
       PackageBundleBuilder bundle = assembler.assemble();
       if (options.buildSummaryOutput != null) {
         io.File file = new io.File(options.buildSummaryOutput);
         file.writeAsBytesSync(bundle.toBuffer(), mode: io.FileMode.WRITE_ONLY);
       }
       if (options.buildSummaryOutputSemantic != null) {
         bundle.flushInformative();
         io.File file = new io.File(options.buildSummaryOutputSemantic);
         file.writeAsBytesSync(bundle.toBuffer(), mode: io.FileMode.WRITE_ONLY);
       }
     }
 
     if (options.buildSummaryOnly) {
       return ErrorSeverity.NONE;
     } else {
       // Process errors.
       _printErrors(outputPath: options.buildAnalysisOutput);
       return _computeMaxSeverity();
     }
   }
 
+  /**
+   * Compute linked libraries for the given [libraryUris] using the linked
+   * libraries of the [summaryDataStore] and unlinked units in [uriToUnit], and
+   * add them to  the [assembler].
+   */
+  void _computeLinkedLibraries(Set<String> libraryUris) {
+    LinkedLibrary getDependency(String absoluteUri) =>
+        summaryDataStore.linkedMap[absoluteUri];
+
+    UnlinkedUnit getUnit(String absoluteUri) =>
+        summaryDataStore.unlinkedMap[absoluteUri] ?? uriToUnit[absoluteUri];
+
+    Map<String, LinkedLibraryBuilder> linkResult = link(
+        libraryUris,
+        getDependency,
+        getUnit,
+        context.declaredVariables.get,
+        options.strongMode);
+    linkResult.forEach(assembler.addLinkedLibrary);
+  }
+
   ErrorSeverity _computeMaxSeverity() {
     ErrorSeverity maxSeverity = ErrorSeverity.NONE;
     if (!options.buildSuppressExitCode) {
       for (Source source in explicitSources) {
         AnalysisErrorInfo errorInfo = context.getErrors(source);
         for (AnalysisError error in errorInfo.errors) {
           ErrorSeverity processedSeverity = determineProcessedSeverity(
               error, options, context.analysisOptions);
           if (processedSeverity != null) {
             maxSeverity = maxSeverity.max(processedSeverity);
@@ skipping 98 matching lines @@
         return null;
       }
       Uri uri = Uri.parse(sourceFile.substring(0, pipeIndex));
       String path = sourceFile.substring(pipeIndex + 1);
       uriToFileMap[uri] = resourceProvider.getFile(path);
     }
     return uriToFileMap;
   }
 
   /**
+   * Ensure that the [UnlinkedUnit] for [absoluteUri] is available.
+   *
+   * If the unit is in the input [summaryDataStore], do nothing.
+   *
+   * Otherwise compute it and store into the [uriToUnit] and [assembler].
+   */
+  void _prepareUnlinkedUnit(String absoluteUri) {
+    // Maybe an input package contains the source.
+    if (summaryDataStore.unlinkedMap[absoluteUri] != null) {
+      return;
+    }
+    // Parse the source and serialize its AST.
+    Uri uri = Uri.parse(absoluteUri);
+    Source source = context.sourceFactory.forUri2(uri);
+    if (!source.exists()) {
+      // TODO(paulberry): we should report a warning/error because DDC
+      // compilations are unlikely to work.
+      return;
+    }
+    CompilationUnit unit = context.computeResult(source, PARSED_UNIT);
+    UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
+    uriToUnit[absoluteUri] = unlinkedUnit;
+    assembler.addUnlinkedUnit(source, unlinkedUnit);
+  }
+
+  /**
    * Print errors for all explicit sources.  If [outputPath] is supplied, output
    * is sent to a new file at that path.
    */
   void _printErrors({String outputPath}) {
     StringBuffer buffer = new StringBuffer();
     var severityProcessor = (AnalysisError error) =>
         determineProcessedSeverity(error, options, context.analysisOptions);
     ErrorFormatter formatter = options.machineFormat
         ? new MachineErrorFormatter(buffer, options, stats,
             severityProcessor: severityProcessor)
         : new HumanErrorFormatter(buffer, options, stats,
             severityProcessor: severityProcessor);
     for (Source source in explicitSources) {
       AnalysisErrorInfo errorInfo = context.getErrors(source);
       formatter.formatErrors([errorInfo]);
     }
     formatter.flush();
     if (!options.machineFormat) {
       stats.print(buffer);
     }
     if (outputPath == null) {
       StringSink sink = options.machineFormat ? errorSink : outSink;
       sink.write(buffer);
     } else {
       new io.File(outputPath).writeAsStringSync(buffer.toString());
     }
   }
-
-  /**
-   * Serialize the package with the given [sources] into [assembler] using only
-   * their ASTs and [LinkedUnit]s of input packages.
-   */
-  void _serializeAstBasedSummary(Set<String> unlinkedUris) {
-    LinkedLibrary _getDependency(String absoluteUri) =>
-        summaryDataStore.linkedMap[absoluteUri];
-
-    Map<String, LinkedLibraryBuilder> linkResult = link(
-        unlinkedUris,
-        _getDependency,
-        _unlinkedUnitForUri,
-        context.declaredVariables.get,
-        options.strongMode);
-    linkResult.forEach(assembler.addLinkedLibrary);
-  }
-
-  /**
-   * Returns the [UnlinkedUnit] for [absoluteUri], either by computing it or
-   * using the stored one in [uriToUnit].
-   *
-   * If the [UnlinkedUnit] needed to be computed, it will also be added to the
-   * [assembler].
-   */
-  UnlinkedUnit _unlinkedUnitForUri(String absoluteUri) {
-    // Maybe an input package contains the source.
-    {
-      UnlinkedUnit unlinkedUnit = summaryDataStore.unlinkedMap[absoluteUri];
-      if (unlinkedUnit != null) {
-        return unlinkedUnit;
-      }
-    }
-    // Parse the source and serialize its AST.
-    Uri uri = Uri.parse(absoluteUri);
-    Source source = context.sourceFactory.forUri2(uri);
-    if (!source.exists()) {
-      // TODO(paulberry): we should report a warning/error because DDC
-      // compilations are unlikely to work.
-      return null;
-    }
-    return uriToUnit.putIfAbsent(uri, () {
-      CompilationUnit unit = context.computeResult(source, PARSED_UNIT);
-      UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
-      assembler.addUnlinkedUnit(source, unlinkedUnit);
-      return unlinkedUnit;
-    });
-  }
 }
 
 /**
  * Instances of the class [ExplicitSourceResolver] map URIs to files on disk
  * using a fixed mapping provided at construction time.
  */
 class ExplicitSourceResolver extends UriResolver {
   final Map<Uri, File> uriToFileMap;
   final Map<String, Uri> pathToUriMap;
 
@@ skipping 25 matching lines @@
    * Build the inverse mapping of [uriToSourceMap].
    */
   static Map<String, Uri> _computePathToUriMap(Map<Uri, File> uriToSourceMap) {
     Map<String, Uri> pathToUriMap = <String, Uri>{};
     uriToSourceMap.forEach((Uri uri, File file) {
       pathToUriMap[file.path] = uri;
     });
     return pathToUriMap;
   }
 }