Add support for external summaries bundle in AnalysisDriver.

pkg/analyzer/lib/src/dart/analysis/driver.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:typed_data';
 
 import 'package:analyzer/context/context_root.dart';
 import 'package:analyzer/context/declared_variables.dart';
@@ skipping 12 matching lines @@
 import 'package:analyzer/src/dart/analysis/search.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/dart/analysis/top_level_declaration.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, AnalysisOptions;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/lint/registry.dart' as linter;
 import 'package:analyzer/src/summary/api_signature.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
+import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:meta/meta.dart';
 
 /**
  * This class computes [AnalysisResult]s for Dart files.
  *
  * Let the set of "explicitly analyzed files" denote the set of paths that have
  * been passed to [addFile] but not subsequently passed to [removeFile]. Let
  * the "current analysis results" denote the map from the set of explicitly
  * analyzed files to the most recent [AnalysisResult] delivered to [results]
  * for each file. Let the "current file state" represent a map from file path
@@ skipping 55 matching lines @@
   final ResourceProvider _resourceProvider;
 
   /**
    * The byte storage to get and put serialized data.
    *
    * It can be shared with other [AnalysisDriver]s.
    */
   final ByteStore _byteStore;
 
   /**
+   * The optional store with externally provided unlinked and corresponding
+   * linked summaries. These summaries are always added to the store for any
+   * file analysis.
+   */
+  final SummaryDataStore _externalSummaries;
+
+  /**
    * This [ContentCache] is consulted for a file content before reading
    * the content from the file.
    */
   final FileContentOverlay _contentOverlay;
 
   /**
    * The analysis options to analyze with.
    */
   AnalysisOptions _analysisOptions;
 
@@ skipping 151 matching lines @@
   AnalysisDriver(
       this._scheduler,
       PerformanceLog logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       this.contextRoot,
       SourceFactory sourceFactory,
       this._analysisOptions,
       {PackageBundle sdkBundle,
-      this.disableChangesAndCacheAllResults: false})
+      this.disableChangesAndCacheAllResults: false,
+      SummaryDataStore externalSummaries})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
-        _sdkBundle = sdkBundle {
+        _sdkBundle = sdkBundle,
+        _externalSummaries = externalSummaries {
     _onResults = _resultController.stream.asBroadcastStream();
     _testView = new AnalysisDriverTestView(this);
     _createFileTracker(logger);
     _scheduler.add(this);
     _search = new Search(this);
   }
 
   /**
    * Return the set of files explicitly added to analysis using [addFile].
    */
@@ skipping 775 matching lines @@
   }
 
   /**
    * Creates a new [FileTracker] object and stores it in [_fileTracker].
    *
    * This is used both on initial construction and whenever the configuration
    * changes.
    */
   void _createFileTracker(PerformanceLog logger) {
     _fillSalt();
-    _fileTracker = new FileTracker(logger, _byteStore, _contentOverlay,
-        _resourceProvider, sourceFactory, _analysisOptions, _salt, _changeHook);
+    _fileTracker = new FileTracker(
+        logger,
+        _byteStore,
+        _contentOverlay,
+        _resourceProvider,
+        sourceFactory,
+        _analysisOptions,
+        _salt,
+        _externalSummaries,
+        _changeHook);
   }
 
   /**
    * Return the context in which the [library] should be analyzed.
    */
   LibraryContext _createLibraryContext(FileState library) =>
       new LibraryContext.forSingleLibrary(
           library,
           _logger,
           _sdkBundle,
           _byteStore,
           _analysisOptions,
           declaredVariables,
           _sourceFactory,
-          _fileTracker);
+          _externalSummaries,
+          fsState);
 
   /**
    * Fill [_salt] with data.
    */
   void _fillSalt() {
     _salt[0] = DATA_VERSION;
     List<int> crossContextOptions = _analysisOptions.signature;
     assert(crossContextOptions.length == AnalysisOptions.signatureLength);
     for (int i = 0; i < crossContextOptions.length; i++) {
       _salt[i + 1] = crossContextOptions[i];
@@ skipping 418 matching lines @@
 class AnalysisDriverTestView {
   final AnalysisDriver driver;
 
   int numOfAnalyzedLibraries = 0;
 
   AnalysisDriverTestView(this.driver);
 
   FileTracker get fileTracker => driver._fileTracker;
 
   Map<String, AnalysisResult> get priorityResults => driver._priorityResults;
+
+  SummaryDataStore getSummaryStore(String libraryPath) {
+    FileState library = driver.fsState.getFileForPath(libraryPath);
+    LibraryContext libraryContext = driver._createLibraryContext(library);
+    try {
+      return libraryContext.store;
+    } finally {
+      libraryContext.dispose();
+    }
+  }
 }
 
 /**
  * The result of analyzing of a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], the
  * resolved [unit] correspond to each other. All referenced elements, even
  * external ones, are also self-consistent. But none of the results is
  * guaranteed to be consistent with the state of the files.
  *
@@ skipping 510 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }