Add --build-summary-only-unlinked flag, which makes the output summary be an unlinked summary inste…

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:core';
 import 'dart:io' as io;
 
 import 'package:analyzer/dart/ast/ast.dart' show CompilationUnit;
@@ skipping 181 matching lines @@
         AnalysisResult analysisResult = context.performAnalysisTask();
         if (!analysisResult.hasMoreWork) {
           break;
         }
       }
     }
 
     // Write summary.
     assembler = new PackageBundleAssembler();
     if (_shouldOutputSummary) {
-      _serializeAstBasedSummary(explicitSources);
+      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 {
+        _serializeAstBasedSummary(explicitSources);
+        assembler.recordDependencies(summaryDataStore);
+      }
       // Write the whole package bundle.
-      assembler.recordDependencies(summaryDataStore);
       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);
       }
@@ skipping 128 matching lines @@
    * Serialize the package with the given [sources] into [assembler] using only
    * their ASTs and [LinkedUnit]s of input packages.
    */
   void _serializeAstBasedSummary(List<Source> sources) {
     Set<String> sourceUris =
         sources.map((Source s) => s.uri.toString()).toSet();
 
     LinkedLibrary _getDependency(String absoluteUri) =>
         summaryDataStore.linkedMap[absoluteUri];
 
-    UnlinkedUnit _getUnit(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;
-      });
-    }
-
     Map<String, LinkedLibraryBuilder> linkResult = link(
         sourceUris,
         _getDependency,
-        _getUnit,
+        _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

[jakemac, 2017/04/04 16:44:46]

I don't really like this behavior, but I don't see a good way around it right
now.

Longer term it seems like maybe the assembler should expose the existing map of
uri->UnlinkedUnit, or it should handle deduping things automatically?

[Paul Berry, 2017/04/04 18:30:30]

Actually what I would prefer is if we just computed all the unlinked summaries
up front and manually added them to uriToUnit; then this function would just
look up the computed summary and return it.

However it might not be that easy--the current implementation has a side effect
that if a file is present in an input package, it won't be re-summarized, even
if it is explicitly listed as an input.  IIRC, there are some people relying on
that functionality.

In any case, it's definitely something to address in a future CL :)

[jakemac, 2017/04/04 19:21:06]

Acknowledged.

+   * [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;
   }
 }