Return complete closure bundles from IncrementalCache.

pkg/analyzer/lib/src/summary/incremental_cache.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:convert' show UTF8;
 import 'dart:core' hide Resource;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 85 matching lines @@
    * Opaque data that reflects the current configuration, such as the [context]
    * options, and is mixed into the hashes.
    */
   final List<int> configSalt;
 
   final Map<Source, CacheSourceContent> _sourceContentMap =
       <Source, CacheSourceContent>{};
   final Map<Source, List<Source>> _libraryClosureMap = <Source, List<Source>>{};
   final Map<Source, List<int>> _sourceContentHashMap = <Source, List<int>>{};
 
+  /**
+   * Mapping from a library closure key to its [PackageBundle].
+   */
+  final Map<String, PackageBundle> _bundleMap = <String, PackageBundle>{};
+
   IncrementalCache(this.storage, this.context, this.configSalt);
 
   /**
    * Clear internal caches so that we read from file system again.
    */
   void clearInternalCaches() {
     _sourceContentMap.clear();
     _libraryClosureMap.clear();
     _sourceContentHashMap.clear();
+    _bundleMap.clear();
   }
 
   /**
+   * Return all summaries that are required to provide results about the library
+   * with the given [librarySource] from its summary.  It includes all of the
+   * bundles in the import/export closure of the library.  If any of the
+   * bundles are not in the cache, then `null` is returned.  If any of the
+   * [LibraryBundleWithId]s were already returned as a part of the closure of
+   * another library, they are still included - it is up to the client to
+   * decide whether a bundle should be used or not, but it is easy to do
+   * using [LibraryBundleWithId.id].
+   */
+  List<LibraryBundleWithId> getLibraryClosureBundles(Source librarySource) {
+    try {
+      List<Source> closureSources = _getLibraryClosure(librarySource);
+      List<LibraryBundleWithId> closureBundles = <LibraryBundleWithId>[];
+      for (Source source in closureSources) {
+        if (source.isInSystemLibrary) {
+          continue;
+        }
+        String key = _getLibraryBundleKey(source);
+        PackageBundle bundle = _getLibraryBundle(key);
+        if (bundle == null) {
+          return null;
+        }
+        closureBundles.add(new LibraryBundleWithId(source, key, bundle));
+      }
+      return closureBundles;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
    * Return the kind of the given [source], or `null` if unknown.
    */
   SourceKind getSourceKind(Source source) {
     try {
       CacheSourceContent contentSource = _getCacheSourceContent(source);
       if (contentSource != null) {
         if (contentSource.kind == CacheSourceKind.library) {
           return SourceKind.LIBRARY;
         }
         if (contentSource.kind == CacheSourceKind.part) {
           return SourceKind.PART;
         }
       }
     } catch (e) {}
     return null;
   }
 
   /**
-   * Write information about the [library] into the cache.
+   * Write information about the [libraryElement] into the cache.
    */
-  void putLibrary(LibraryElement library) {
-    _writeCacheSourceContents(library);
-    List<int> hash = _getLibraryClosureHash(library.source);
-    String hashStr = CryptoUtils.bytesToHex(hash);
+  void putLibrary(LibraryElement libraryElement) {
+    _writeCacheSourceContents(libraryElement);
+    String key = _getLibraryBundleKey(libraryElement.source);
     PackageBundleAssembler assembler = new PackageBundleAssembler();
-    assembler.serializeLibraryElement(library);
+    assembler.serializeLibraryElement(libraryElement);
     List<int> bytes = assembler.assemble().toBuffer();
-    storage.put('$hashStr.sum', bytes);
+    storage.put(key, bytes);
   }
 
   /**
-   * Read the [PackageBundle] for the library with the given [source] from
-   * the cache. The returned bundle will correspond to the state when the set
-   * of direct and indirect dependencies is resolved in the [context]. Return
-   * `null` if such bundle does not exist.
-   */
-  PackageBundle readBundle(Source source) {
-    try {
-      List<int> hash = _getLibraryClosureHash(source);
-      String hashStr = CryptoUtils.bytesToHex(hash);
-      List<int> bytes = storage.get('$hashStr.sum');
-      if (bytes == null) {
-        return null;
-      }
-      return new PackageBundle.fromBuffer(bytes);
-    } catch (e) {
-      return null;
-    }
-  }
-
-  /**
    * Fill the whole source closure of the library with the given
    * [librarySource]. It includes defining units and parts of the library and
    * all its directly or indirectly imported or exported libraries.
    */
   void _appendLibraryClosure(Set<Source> closure, Source librarySource) {
     if (closure.add(librarySource)) {
       CacheSourceContent contentSource = _getCacheSourceContent(librarySource);
       if (contentSource == null) {
         throw new StateError('No structure for $librarySource');
       }
@@ skipping 41 matching lines @@
   /**
    * Return the key of the content based [source] information.
    */
   String _getCacheSourceContentKey(Source source) {
     List<int> hash = _getSourceContentHash(source);
     String hashStr = CryptoUtils.bytesToHex(hash);
     return '$hashStr.content';
   }
 
   /**
+   * Get the bundle for the given key.
+   */
+  PackageBundle _getLibraryBundle(String key) {
+    PackageBundle bundle = _bundleMap[key];
+    if (bundle == null) {
+      List<int> bytes = storage.get(key);
+      if (bytes == null) {
+        return null;
+      }
+      bundle = new PackageBundle.fromBuffer(bytes);
+      _bundleMap[key] = bundle;
+    }
+    return bundle;
+  }
+
+  /**
+   * Return the key of the bundle of the [librarySource].
+   */
+  String _getLibraryBundleKey(Source librarySource) {
+    List<int> hash = _getLibraryClosureHash(librarySource);
+    String hashStr = CryptoUtils.bytesToHex(hash);
+    return '$hashStr.summary';
+  }
+
+  /**
    * Return the whole source closure of the library with the given
    * [librarySource]. It includes defining units and parts of the library and
    * of all its directly or indirectly imported or exported libraries.
    */
   List<Source> _getLibraryClosure(Source librarySource) {
     return _libraryClosureMap.putIfAbsent(librarySource, () {
       Set<Source> closure = new Set<Source>();
       _appendLibraryClosure(closure, librarySource);
       return closure.toList();
     });
@@ skipping 83 matching lines @@
     // Write the library.
     _writeCacheSourceContent(
         librarySource,
         new CacheSourceContentBuilder(
             kind: CacheSourceKind.library,
             importedUris: importUris,
             exportedUris: exportUris,
             partUris: partUris));
   }
 }
+
+/**
+ * The bundle for a source in the context.
+ */
+class LibraryBundleWithId {
+  /**
+   * The source of the library this bundle is for.
+   */
+  final Source source;
+
+  /**
+   * The unique ID of the [bundle] of the [source] in the context.
+   */
+  final String id;
+
+  /**
+   * The payload bundle.
+   */
+  final PackageBundle bundle;
+
+  LibraryBundleWithId(this.source, this.id, this.bundle);
+}