Add PubSummaryManager.computeUnlinkedForFolder() for Flutter.

pkg/analyzer/lib/src/summary/pub_summary.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core' hide Resource;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 10 matching lines @@
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart'
     show ResynthesizerResultProvider, SummaryDataStore;
 import 'package:analyzer/src/summary/summarize_ast.dart'
     show serializeAstUnlinked;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     show PackageBundleAssembler;
 import 'package:analyzer/src/util/fast_uri.dart';
+import 'package:meta/meta.dart';
 import 'package:path/path.dart' as pathos;
 
 /**
  * Unlinked and linked information about a [PubPackage].
  */
 class LinkedPubPackage {
   final PubPackage package;
   final PackageBundle unlinked;
   final PackageBundle linked;
 
@@ skipping 182 matching lines @@
         assembler.addLinkedLibrary(uri, library);
       });
       List<int> bytes = assembler.assemble().toBuffer();
       return new PackageBundle.fromBuffer(bytes);
     } on FileSystemException {
       return null;
     }
   }
 
   /**
+   * Complete when the unlinked bundles for the package with the given [name]
+   * and the [libFolder] are computed and written to the files.
+   *
+   * This method is intended to be used for generating unlinked bundles for
+   * the `Flutter` packages.
+   */
+  Future<Null> computeUnlinkedForFolder(String name, Folder libFolder) async {
+    PubPackage package = new PubPackage(name, libFolder);
+    _scheduleUnlinked(package);
+    await onUnlinkedComplete;
+  }
+
+  /**
    * Return the list of linked [LinkedPubPackage]s that can be provided at this
    * time for a subset of the packages used by the given [context].  If
    * information about some of the used packages is not available yet, schedule
    * its computation, so that it might be available later for other contexts
    * referencing the same packages.
    */
   List<LinkedPubPackage> getLinkedBundles(AnalysisContext context) {
 //    Stopwatch timer = new Stopwatch()..start();
 
     PackageBundle sdkBundle = context.sourceFactory.dartSdk.getLinkedBundle();
@@ skipping 81 matching lines @@
 //        ' in ${timer.elapsedMilliseconds} ms');
 
     // Done.
     return linkedPackages;
   }
 
   /**
    * Return all available unlinked [PackageBundle]s for the given [context],
    * maybe an empty map, but not `null`.
    */
+  @visibleForTesting
   Map<PubPackage, PackageBundle> getUnlinkedBundles(AnalysisContext context) {
     bool strong = context.analysisOptions.strongMode;
     Map<PubPackage, PackageBundle> unlinkedBundles =
         new HashMap<PubPackage, PackageBundle>();
     Map<String, List<Folder>> packageMap = context.sourceFactory.packageMap;
     if (packageMap != null) {
       packageMap.forEach((String packageName, List<Folder> libFolders) {
         if (libFolders.length == 1) {
           Folder libFolder = libFolders.first;
           PubPackage package = new PubPackage(packageName, libFolder);
@@ skipping 132 matching lines @@
         unlinkedBundleMap[package] = bundle;
         // TODO(scheglov) if not in the pub cache, check for consistency
         return bundle;
       } on FileSystemException {
         // Ignore file system exceptions.
       }
     }
     // Schedule computation in the background, if in the pub cache.
     if (isPathInPubCache(pathContext, package.folder.path)) {
       if (seenPackages.add(package)) {
-        if (packagesToComputeUnlinked.isEmpty) {
-          _scheduleNextUnlinked();
-        }
-        packagesToComputeUnlinked.add(package);
+        _scheduleUnlinked(package);
       }
     }
     // The bundle is for available.
     return null;
   }
 
   /**
    * Parse the given [source] into AST.
    */
   CompilationUnit _parse(Source source, bool strong) {
@@ skipping 44 matching lines @@
    * Schedule delayed computation of the next package unlinked bundle from the
    * set of [packagesToComputeUnlinked].  We delay each computation because we
    * want operations in analysis server to proceed, and computing bundles of
    * packages is a background task.
    */
   void _scheduleNextUnlinked() {
     new Future.delayed(new Duration(milliseconds: 10), _computeNextUnlinked);
   }
 
   /**
+   * Schedule computing unlinked bundles for the given [package].
+   */
+  void _scheduleUnlinked(PubPackage package) {
+    if (packagesToComputeUnlinked.isEmpty) {
+      _scheduleNextUnlinked();
+    }
+    packagesToComputeUnlinked.add(package);
+  }
+
+  /**
    * Atomically write the given [bytes] into the file in the [folder].
    */
   void _writeAtomic(Folder folder, String fileName, List<int> bytes) {
     String filePath = folder.getChildAssumingFile(fileName).path;
     File tempFile = folder.getChildAssumingFile(tempFileName);
     tempFile.writeAsBytesSync(bytes);
     tempFile.renameSync(filePath);
   }
 
   /**
@@ skipping 216 matching lines @@
       store.addBundle(null, node.linked);
     }
   }
 }
 
 /**
  * This exception is thrown during linking as a signal that linking of the
  * current bundle cannot be performed, e.g. when a dependency cannot be found.
  */
 class _LinkException {}