Streamline AnalysisDriver status tracking.

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/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 199 matching lines @@
    * 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>();
 
   /**
    * The instance of the [Search] helper.
    */
   Search _search;
 
@@ skipping 82 matching lines @@
    * 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) {
     _priorityResults.keys
         .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.
    *
    * Analysis starts when the [AnalysisDriverScheduler] is started and the
    * driver is added to it. The analysis state transitions to "analyzing" and
@@ skipping 18 matching lines @@
    * Return the search support for the driver.
    */
   Search get search => _search;
 
   /**
    * Return the source factory used to resolve URIs to paths and restore URIs
    * from file paths.
    */
   SourceFactory get sourceFactory => _sourceFactory;
 
-  /**
-   * Return the stream that produces [AnalysisStatus] events.
-   */
-  Stream<AnalysisStatus> get status => _statusSupport.stream;
-
   @visibleForTesting
   AnalysisDriverTestView get test => _testView;
 
   /**
    * Return the priority of work that the driver needs to perform.
    */
   AnalysisDriverPriority get _workPriority {
     if (_requestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
@@ skipping 18 matching lines @@
     }
     if (_filesToAnalyze.isNotEmpty) {
       return AnalysisDriverPriority.general;
     }
     if (_changedFiles.isNotEmpty) {
       return AnalysisDriverPriority.general;
     }
     if (_requestedParts.isNotEmpty || _partsToAnalyze.isNotEmpty) {
       return AnalysisDriverPriority.general;
     }
-    _statusSupport.transitionToIdle();
     return AnalysisDriverPriority.nothing;
   }
 
   /**
    * 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 (!_fsState.hasUri(path)) {
       return;
     }
     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) {
     _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
    * that represent state that has actually changed need be provided.
    */
   void configure(
       {AnalysisOptions analysisOptions, SourceFactory sourceFactory}) {
     if (analysisOptions != null) {
       _analysisOptions = analysisOptions;
     }
     if (sourceFactory != null) {
       _sourceFactory = sourceFactory;
     }
     _fillSalt();
     _fsState = new FileSystemState(_logger, _byteStore, _contentOverlay,
         _resourceProvider, _sourceFactory, _analysisOptions, _salt);
     _filesToAnalyze.addAll(_addedFiles);
-    _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
   }
 
   /**
    * Notify the driver that the client is going to stop using it.
    */
   void dispose() {
     _scheduler._remove(this);
   }
 
@@ skipping 27 matching lines @@
         analysisResult.errors);
   }
 
   /**
    * Return a [Future] that completes with the list of added files that
    * reference the given external [name].
    */
   Future<List<String>> getFilesReferencingName(String name) {
     var task = new _FilesReferencingNameTask(this, name);
     _referencingNameTasks.add(task);
-    _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
     return task.completer.future;
   }
 
   /**
    * Return a [Future] that completes with the [AnalysisDriverUnitIndex] for
    * the file with the given [path], or with `null` if the file cannot be
    * analyzed.
    */
   Future<AnalysisDriverUnitIndex> getIndex(String path) {
     if (!_fsState.hasUri(path)) {
       return new Future.value();
     }
     var completer = new Completer<AnalysisDriverUnitIndex>();
     _indexRequestedFiles
         .putIfAbsent(path, () => <Completer<AnalysisDriverUnitIndex>>[])
         .add(completer);
-    _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
     return completer.future;
   }
 
   /**
    * Return a [Future] that completes with a [AnalysisResult] for the Dart
    * file with the given [path]. If the file is not a Dart file or cannot
    * be analyzed, the [Future] completes with `null`.
    *
    * The [path] must be absolute and normalized.
@@ skipping 19 matching lines @@
       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 the [SourceKind] for the Dart
    * file with the given [path]. If the file is not a Dart file or cannot
    * be analyzed, the [Future] completes with `null`.
    *
    * The [path] must be absolute and normalized.
    */
   Future<SourceKind> getSourceKind(String path) async {
     if (AnalysisEngine.isDartFileName(path)) {
       FileState file = _fsState.getFileForPath(path);
       return file.isPart ? SourceKind.PART : SourceKind.LIBRARY;
     }
     return null;
   }
 
   /**
    * 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);
-    _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
     return task.completer.future;
   }
 
   /**
    * Return a [Future] that completes with the [CompilationUnitElement] for the
    * file with the given [path], or with `null` if the file cannot be analyzed.
    */
   Future<CompilationUnitElement> getUnitElement(String path) {
     if (!_fsState.hasUri(path)) {
       return new Future.value();
     }
     var completer = new Completer<CompilationUnitElement>();
     _unitElementRequestedFiles
         .putIfAbsent(path, () => <Completer<CompilationUnitElement>>[])
         .add(completer);
-    _statusSupport.transitionToAnalyzing();
     _scheduler._notify(this);
     return completer.future;
   }
 
   /**
    * Return a [Future] that completes with a [ParseResult] for the file
    * with the given [path].
    *
    * The [path] must be absolute and normalized.
    *
@@ skipping 19 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 a future that will be completed the next time the status is idle.
-   *
-   * If the status is currently idle, the returned future will be signaled
-   * immediately.
-   */
-  Future<Null> waitForIdle() => _statusSupport.waitForIdle();
-
-  /**
    * 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`.
    *
    * Return `null` if the file is a part of an unknown library, so cannot be
    * analyzed yet. But [asIsIfPartWithoutLibrary] is `true`, then the file is
    * analyzed anyway, even without a library.
    */
@@ skipping 530 matching lines @@
    */
   void start() {
     if (_started) {
       throw new StateError('The scheduler has already been started.');
     }
     _started = true;
     _run();
   }
 
   /**
+   * Return a future that will be completed the next time the status is idle.
+   *
+   * If the status is currently idle, the returned future will be signaled
+   * immediately.
+   */
+  Future<Null> waitForIdle() => _statusSupport.waitForIdle();
+
+  /**
    * Add the given [driver] and schedule it to perform its work.
    */
   void _add(AnalysisDriver driver) {
     _drivers.add(driver);
     _hasWork.notify();
   }
 
   /**
    * Notify that there is a change to the [driver], it it might need to
    * perform some work.
    */
   void _notify(AnalysisDriver driver) {
     _hasWork.notify();
+    _statusSupport.preTransitionToAnalyzing();
   }
 
   /**
    * Remove the given [driver] from the scheduler, so that it will not be
    * asked to perform any new work.
    */
   void _remove(AnalysisDriver driver) {
     _drivers.remove(driver);
     _hasWork.notify();
   }
@@ skipping 18 matching lines @@
       if (_hasFilesToAnalyze) {
         _statusSupport.transitionToAnalyzing();
         analysisSection ??= _logger.enter('Analyzing');
       }
 
       // Find the driver with the highest priority.
       AnalysisDriver bestDriver;
       AnalysisDriverPriority bestPriority = AnalysisDriverPriority.nothing;
       for (AnalysisDriver driver in _drivers) {
         AnalysisDriverPriority priority = driver._workPriority;
-        if (bestPriority == null || priority.index > bestPriority.index) {
+        if (priority.index > bestPriority.index) {
           bestDriver = driver;
           bestPriority = priority;
         }
       }
 
       // Transition to idle if no files to analyze.
       if (!_hasFilesToAnalyze) {
         _statusSupport.transitionToIdle();
         analysisSection?.exit();
         analysisSection = null;
@@ skipping 431 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }