Add a flag for caching all analysis results in the driver.

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 220 matching lines @@
   Search _search;
 
   AnalysisDriverTestView _testView;
 
   /**
    * The [FileTracker] used by this driver.
    */
   FileTracker _fileTracker;
 
   /**
+   * When this flag is set to `true`, the set of analyzed files must not change,
+   * and all [AnalysisResult]s are cached infinitely.
+   *
+   * The flag is intended to be used for non-interactive clients, like DDC,
+   * which start a new analysis session, load a set of files, resolve all of
+   * them, process the resolved units, and then throw away that whole session.
+   *
+   * The key problem that this flag is solving is that the driver analyzes the
+   * whole library when the result for a unit of the library is requested. So,
+   * when the client requests sequentially the defining unit, then the first
+   * part, then the second part, the driver has to perform analysis of the
+   * library three times and every time throw away all the units except the one
+   * which was requested. With this flag set to `true`, the driver can analyze
+   * once and cache all the resolved units.
+   */
+  final bool disableChangesAndCacheAllResults;
+
+  /**
+   * The cache to use with [disableChangesAndCacheAllResults].
+   */
+  final Map<String, AnalysisResult> _allCachedResults = {};
+
+  /**
    * Create a new instance of [AnalysisDriver].
    *
    * The given [SourceFactory] is cloned to ensure that it does not contain a
    * reference to a [AnalysisContext] in which it could have been used.
    */
   AnalysisDriver(
       this._scheduler,
       PerformanceLog logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       this.contextRoot,
       SourceFactory sourceFactory,
       this._analysisOptions,
-      {PackageBundle sdkBundle})
+      {PackageBundle sdkBundle,
+      this.disableChangesAndCacheAllResults: false})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
         _sdkBundle = sdkBundle {
     _onResults = _resultController.stream.asBroadcastStream();
     _testView = new AnalysisDriverTestView(this);
     _createFileTracker(logger);
     _scheduler.add(this);
     _search = new Search(this);
   }
 
@@ skipping 186 matching lines @@
    * that state already). Schedules the file contents for [path] to be read
    * into the current file state prior to the next time the analysis state
    * transitions to "idle".
    *
    * Invocation of this method will not prevent a [Future] returned from
    * [getResult] from completing with a result, but the result is not
    * guaranteed to be consistent with the new current file state after this
    * [changeFile] invocation.
    */
   void changeFile(String path) {
+    _throwIfChangesAreNotAllowed();
     _fileTracker.changeFile(path);
     _priorityResults.clear();
   }
 
   /**
    * Some state on which analysis depends has changed, so the driver needs to be
    * re-configured with the new state.
    *
    * At least one of the optional parameters should be provided, but only those
    * that represent state that has actually changed need be provided.
@@ skipping 112 matching lines @@
    * time the analysis state transitions to "idle".
    */
   Future<AnalysisResult> getResult(String path) {
     if (!_fileTracker.fsState.hasUri(path)) {
       return new Future.value();
     }
 
     // Return the cached result.
     {
       AnalysisResult result = _priorityResults[path];
+      if (disableChangesAndCacheAllResults) {
+        result ??= _allCachedResults[path];
+      }
       if (result != null) {
         return new Future.value(result);
       }
     }
 
     // Schedule analysis.
     var completer = new Completer<AnalysisResult>();
     _requestedFiles
         .putIfAbsent(path, () => <Completer<AnalysisResult>>[])
         .add(completer);
@@ skipping 276 matching lines @@
   /**
    * Remove the file with the given [path] from the list of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis of the file might still be produced by the
    * [results] stream. The driver will try to stop producing these results,
    * but does not guarantee this.
    */
   void removeFile(String path) {
+    _throwIfChangesAreNotAllowed();
     _fileTracker.removeFile(path);
     _priorityResults.clear();
   }
 
   /**
    * Handles a notification from the [FileTracker] that there has been a change
    * of state.
    */
   void _changeHook() {
     _priorityResults.clear();
@@ skipping 49 matching lines @@
       if (bytes != null) {
         return _getAnalysisResultFromBytes(file, signature, bytes);
       }
     }
 
     // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $path', () {
       try {
         LibraryContext libraryContext = _createLibraryContext(library);
         try {
+          _testView.numOfAnalyzedLibraries++;
           LibraryAnalyzer analyzer = new LibraryAnalyzer(
               analysisOptions,
               declaredVariables,
               sourceFactory,
               _fileTracker.fsState,
               libraryContext.store,
               library);
           Map<FileState, UnitAnalysisResult> results = analyzer.analyze();
 
           List<int> bytes;
           CompilationUnit resolvedUnit;
           for (FileState unitFile in results.keys) {
             UnitAnalysisResult unitResult = results[unitFile];
             List<int> unitBytes =
                 _serializeResolvedUnit(unitResult.unit, unitResult.errors);
             String unitSignature = _getResolvedUnitSignature(library, unitFile);
             String unitKey = _getResolvedUnitKey(unitSignature);
             _byteStore.put(unitKey, unitBytes);
             if (unitFile == file) {
               bytes = unitBytes;
               resolvedUnit = unitResult.unit;
             }
+            if (disableChangesAndCacheAllResults) {
+              AnalysisResult result = _getAnalysisResultFromBytes(
+                  unitFile, unitSignature, unitBytes,
+                  content: unitFile.content, resolvedUnit: unitResult.unit);
+              _allCachedResults[unitFile.path] = result;
+            }
           }
 
           // Return the result, full or partial.
           _logger.writeln('Computed new analysis result.');
           AnalysisResult result = _getAnalysisResultFromBytes(
               file, signature, bytes,
               content: withUnit ? file.content : null,
               resolvedUnit: withUnit ? resolvedUnit : null);
           if (withUnit && _priorityFiles.contains(path)) {
             _priorityResults[path] = result;
@@ skipping 239 matching lines @@
       String key = 'exception_${time.year}$m$d' '_$h$min$sec' + '_$ms';
 
       _byteStore.put(key, bytes);
       return key;
     } catch (_) {
       return null;
     }
   }
 
   /**
+   * If the driver is used in the read-only mode with infinite cache,
+   * we should not allow invocations that change files.
+   */
+  void _throwIfChangesAreNotAllowed() {
+    if (disableChangesAndCacheAllResults) {
+      throw new StateError('Changing files is not allowed for this driver.');
+    }
+  }
+
+  /**
    * Given the list of [errors] for the [file], update the [file]'s
    * [FileState.hasErrorOrWarning] flag.
    */
   void _updateHasErrorOrWarningFlag(
       FileState file, List<AnalysisError> errors) {
     for (AnalysisError error in errors) {
       ErrorSeverity severity = error.errorCode.errorSeverity;
       if (severity == ErrorSeverity.ERROR ||
           severity == ErrorSeverity.WARNING) {
         file.hasErrorOrWarning = true;
@@ skipping 221 matching lines @@
       return new Future.value();
     }
     return new Future.delayed(Duration.ZERO, () => _pumpEventQueue(times - 1));
   }
 }
 
 @visibleForTesting
 class AnalysisDriverTestView {
   final AnalysisDriver driver;
 
+  int numOfAnalyzedLibraries = 0;
+
   AnalysisDriverTestView(this.driver);
 
   FileTracker get fileTracker => driver._fileTracker;
 
   Map<String, AnalysisResult> get priorityResults => driver._priorityResults;
 }
 
 /**
  * The result of analyzing of a single file.
  *
@@ skipping 515 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }