Cache results for priority files 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/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart' show CompilationUnitElement;
@@ skipping 187 matching lines @@
    * The set of part files that are currently scheduled for analysis.
    */
   final _partsToAnalyze = new LinkedHashSet<String>();
 
   /**
    * The controller for the [results] stream.
    */
   final _resultController = new StreamController<AnalysisResult>();
 
   /**
+   * Cached results for [_priorityFiles].
+   */
+  final Map<String, AnalysisResult> _priorityResults = {};
+
+  /**
    * The instance of the status helper.
    */
   final StatusSupport _statusSupport = new StatusSupport();
 
   /**
    * The controller for the [exceptions] stream.
    */
   final StreamController<ExceptionResult> _exceptionController =
       new StreamController<ExceptionResult>();
 
@@ skipping 81 matching lines @@
   /**
    * Set the list of files that the driver should try to analyze sooner.
    *
    * Every path in the list must be absolute and normalized.
    *
    * The driver will produce the results through the [results] stream. The
    * exact order in which results are produced is not defined, neither
    * between priority files, nor between priority and non-priority files.
    */
   void set priorityFiles(List<String> priorityPaths) {
+    _priorityFiles
+        .toSet()
+        .difference(priorityPaths.toSet())
+        .forEach(_priorityResults.remove);
     _priorityFiles.clear();
     _priorityFiles.addAll(priorityPaths);
     _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
   }
 
   /**
    * Return the [Stream] that produces [AnalysisResult]s for added files.
    *
    * Note that the stream supports only one single subscriber.
@@ skipping 79 matching lines @@
    * Add the file with the given [path] to the set of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis are eventually produced by the [results] stream.
    */
   void addFile(String path) {
     if (AnalysisEngine.isDartFileName(path)) {
       _addedFiles.add(path);
       _filesToAnalyze.add(path);
+      _priorityResults.clear();
     }
     _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
   }
 
   /**
    * The file with the given [path] might have changed - updated, added or
    * removed. Or not, we don't know. Or it might have, but then changed back.
    *
    * The [path] must be absolute and normalized.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
    * Causes the analysis state to transition to "analyzing" (if it is not in
    * 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) {
     if (AnalysisEngine.isDartFileName(path)) {
       _changedFiles.add(path);
       if (_addedFiles.contains(path)) {
         _filesToAnalyze.add(path);
       }
+      _priorityResults.clear();
     }
     _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
   }
 
   /**
    * 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
@@ skipping 61 matching lines @@
 
   /**
    * Return a [Future] that completes with a [AnalysisResult] for the Dart
    * file with the given [path]. If the file is not a Dart file, the [Future]
    * completes with `null`.
    *
    * The [path] must be absolute and normalized.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
-   * Causes the analysis state to transition to "analyzing" (if it is not in
-   * that state already), the driver will read the file and produce the analysis
-   * result for it, which is consistent with the current file state (including
-   * the new state of the file), prior to the next time the analysis state
-   * transitions to "idle".
+   * If the driver has the cached analysis result for the file, it is returned.
+   *
+   * Otherwise causes the analysis state to transition to "analyzing" (if it is
+   * not in that state already), the driver will read the file and produce the
+   * analysis result for it, which is consistent with the current file state
+   * (including the new state of the file), prior to the next time the analysis
+   * state transitions to "idle".
    */
   Future<AnalysisResult> getResult(String path) {
-    if (AnalysisEngine.isDartFileName(path)) {
-      var completer = new Completer<AnalysisResult>();
-      _requestedFiles
-          .putIfAbsent(path, () => <Completer<AnalysisResult>>[])
-          .add(completer);
-      _statusSupport.transitionToAnalyzing();
-      _scheduler._notify(this);
-      return completer.future;
+    if (!AnalysisEngine.isDartFileName(path)) {
+      return new Future.value();
     }
-    return new Future.value();
+
+    // Return the cached result.
+    {
+      AnalysisResult result = _priorityResults[path];
+      if (result != null) {
+        return new Future.value(result);
+      }
+    }
+
+    // Schedule analysis.
+    var completer = new Completer<AnalysisResult>();
+    _requestedFiles
+        .putIfAbsent(path, () => <Completer<AnalysisResult>>[])
+        .add(completer);
+    _statusSupport.transitionToAnalyzing();
+    _scheduler._notify(this);
+    return completer.future;
   }
 
   /**
    * Return a [Future] that completes with top-level declarations with the
    * given [name] in all known libraries.
    */
   Future<List<TopLevelDeclarationInSource>> getTopLevelNameDeclarations(
       String name) {
     var task = new _TopLevelNameDeclarationsTask(this, name);
     _topLevelNameDeclarationsTasks.add(task);
@@ skipping 46 matching lines @@
    *
    * 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) {
     _addedFiles.remove(path);
     _filesToAnalyze.remove(path);
     _fsState.removeFile(path);
     _filesToAnalyze.addAll(_addedFiles);
+    _priorityResults.clear();
     _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
   }
 
   /**
    * Return the cached or newly computed analysis result of the file with the
    * given [path].
    *
    * The result will have the fully resolved unit and will always be newly
    * compute only if [withUnit] is `true`.
@@ skipping 77 matching lines @@
                           correction: error.correction))
                       .toList(),
                   index: index)
               .toBuffer();
           String key = _getResolvedUnitKey(libraryFile, file);
           _byteStore.put(key, bytes);
         }
 
         // Return the result, full or partial.
         _logger.writeln('Computed new analysis result.');
-        return _getAnalysisResultFromBytes(file, bytes,
+        AnalysisResult result = _getAnalysisResultFromBytes(file, bytes,
             content: withUnit ? file.content : null,
             withErrors: _addedFiles.contains(path),
             resolvedUnit: withUnit ? resolvedUnit : null);
+        if (withUnit && _priorityFiles.contains(path)) {
+          _priorityResults[path] = result;
+        }
+        return result;
       } finally {
         analysisContext.dispose();
       }
     });
   }
 
   AnalysisDriverUnitIndex _computeIndex(String path) {
     AnalysisResult analysisResult = _computeAnalysisResult(path,
         withUnit: false, asIsIfPartWithoutLibrary: true);
     return analysisResult._index;
@@ skipping 556 matching lines @@
   }
 }
 
 @visibleForTesting
 class AnalysisDriverTestView {
   final AnalysisDriver driver;
 
   AnalysisDriverTestView(this.driver);
 
   Set<String> get filesToAnalyze => driver._filesToAnalyze;
+
+  Map<String, AnalysisResult> get priorityResults => driver._priorityResults;
 }
 
 /**
  * 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 331 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }