Add the 'status' stream and transitions.

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:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 148 matching lines @@
   /**
    * Mapping from library URIs to the dependency signature of the library.
    */
   final _dependencySignatureMap = <Uri, String>{};
 
   /**
    * The monitor that is signalled when there is work to do.
    */
   final _Monitor _hasWork = new _Monitor();
 
+  /**
+   * The controller for the [status] stream.
+   */
+  final _statusController = new StreamController<AnalysisStatus>();
+
+  /**
+   * The last status sent to the [status] stream.
+   */
+  AnalysisStatus _currentStatus = AnalysisStatus.IDLE;
+
   AnalysisDriver(this._logger, this._resourceProvider, this._byteStore,
       this._contentCache, this._sourceFactory, this._analysisOptions) {
     _sdkBundle = _sourceFactory.dartSdk.getLinkedBundle();
   }
 
   /**
    * 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.clear();
     _priorityFiles.addAll(priorityPaths);
+    _transitionToAnalyzing();
     _hasWork.notify();
   }
 
   /**
    * Return the [Stream] that produces [AnalysisResult]s for added files.
    *
    * Analysis starts when the client starts listening to the stream, and stops
    * when the client cancels the subscription.
    *
    * When the client starts listening, the analysis state transitions to
@@ skipping 11 matching lines @@
    *
    * Results might be produced even for files that have never been added
    * using [addFile], for example when [getResult] was called for a file.
    */
   Stream<AnalysisResult> get results async* {
     try {
       PerformanceLogSection analysisSection = null;
       while (true) {
         await _hasWork.signal;
 
-        // TODO(scheglov) implement state transitioning
         if (analysisSection == null) {
           analysisSection = _logger.enter('Analyzing');
         }
 
         // Verify all changed files one at a time.
         if (_changedFiles.isNotEmpty) {
           String path = _removeFirst(_changedFiles);
           _verifyApiSignatureOfChangedFile(path);
           // Repeat the processing loop.
           _hasWork.notify();
@@ skipping 37 matching lines @@
           AnalysisResult result = _computeAnalysisResult(path, withUnit: false);
           yield result;
           // Repeat the processing loop.
           _hasWork.notify();
           continue;
         }
 
         // There is nothing to do.
         analysisSection.exit();
         analysisSection = null;
+        _transitionToIdle();
       }
     } finally {
       print('The stream was cancelled.');
     }
   }
 
   /**
+   * Return the stream that produces [AnalysisStatus] events.
+   */
+  Stream<AnalysisStatus> get status => _statusController.stream;
+
+  /**
    * 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) {
     _explicitFiles.add(path);
     _filesToAnalyze.add(path);
+    _transitionToAnalyzing();
     _hasWork.notify();
   }
 
   /**
    * 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);
     _filesToAnalyze.add(path);
+    _transitionToAnalyzing();
     _hasWork.notify();
   }
 
   /**
    * Return the [Future] that completes with a [AnalysisResult] for the file
    * with the given [path].
    *
    * 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".
    */
   Future<AnalysisResult> getResult(String path) {
     var completer = new Completer<AnalysisResult>();
     _requestedFiles
         .putIfAbsent(path, () => <Completer<AnalysisResult>>[])
         .add(completer);
+    _transitionToAnalyzing();
     _hasWork.notify();
     return completer.future;
   }
 
   /**
    * 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
@@ skipping 266 matching lines @@
   /**
    * Return the [Source] for the given [path] in [_sourceFactory].
    */
   Source _sourceForPath(String path) {
     Source fileSource = _resourceProvider.getFile(path).createSource();
     Uri uri = _sourceFactory.restoreUri(fileSource);
     return _resourceProvider.getFile(path).createSource(uri);
   }
 
   /**
+   * Send a notifications to the [status] stream that the driver started
+   * analyzing.
+   */
+  void _transitionToAnalyzing() {
+    if (_currentStatus != AnalysisStatus.ANALYZING) {
+      _currentStatus = AnalysisStatus.ANALYZING;
+      _statusController.add(AnalysisStatus.ANALYZING);
+    }
+  }
+
+  /**
+   * Send a notifications to the [status] stream that the driver is idle.
+   */
+  void _transitionToIdle() {
+    if (_currentStatus != AnalysisStatus.IDLE) {
+      _currentStatus = AnalysisStatus.IDLE;
+      _statusController.add(AnalysisStatus.IDLE);
+    }
+  }
+
+  /**
    * Verify the API signature for the file with the given [path], and decide
    * which linked libraries should be invalidated, and files reanalyzed.
    *
    * TODO(scheglov) I see that adding a local var changes (full) API signature.
    */
   void _verifyApiSignatureOfChangedFile(String path) {
     _logger.run('Verify API signature of $path', () {
       String oldSignature = _fileApiSignatureMap[path];
       // Compute the new API signature.
       // _File.forResolution() also updates the content hash in the cache.
@@ skipping 64 matching lines @@
   /**
    * The full list of computed analysis errors, both syntactic and semantic.
    */
   final List<AnalysisError> errors;
 
   AnalysisResult(this.path, this.uri, this.content, this.contentHash, this.unit,
       this.errors);
 }
 
 /**
+ * The status of [AnalysisDriver]
+ */
+class AnalysisStatus {
+  static const IDLE = const AnalysisStatus._(false);
+  static const ANALYZING = const AnalysisStatus._(true);
+
+  final bool _analyzing;
+
+  const AnalysisStatus._(this._analyzing);
+
+  /**
+   * Return `true` is the driver is analyzing.
+   */
+  bool get isAnalyzing => _analyzing;
+
+  /**
+   * Return `true` is the driver is idle.
+   */
+  bool get isIdle => !_analyzing;
+}
+
+/**
  * This class is used to gather and print performance information.
  */
 class PerformanceLog {
   final StringSink sink;
   int _level = 0;
 
   PerformanceLog(this.sink);
 
   /**
    * Enter a new execution section, which starts at one point of code, runs
@@ skipping 395 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }