Split core file tracking functionality from 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/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart' show CompilationUnitElement;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
+import 'package:analyzer/src/dart/analysis/file_tracker.dart';
 import 'package:analyzer/src/dart/analysis/index.dart';
 import 'package:analyzer/src/dart/analysis/library_context.dart';
 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/services/lint.dart';
 import 'package:analyzer/src/summary/api_signature.dart';
@@ skipping 55 matching lines @@
    */
   final String name;
 
   /**
    * The scheduler that schedules analysis work in this, and possibly other
    * analysis drivers.
    */
   final AnalysisDriverScheduler _scheduler;
 
   /**
-   * The logger to write performed operations and performance to.
-   */
-  final PerformanceLog _logger;
-
-  /**
    * The resource provider for working with files.
    */
   final ResourceProvider _resourceProvider;
 
   /**
    * The byte storage to get and put serialized data.
    *
    * It can be shared with other [AnalysisDriver]s.
    */
   final ByteStore _byteStore;
@@ skipping 24 matching lines @@
    * The declared environment variables.
    */
   final DeclaredVariables declaredVariables = new DeclaredVariables();
 
   /**
    * The salt to mix into all hashes used as keys for serialized data.
    */
   final Uint32List _salt = new Uint32List(1 + AnalysisOptions.signatureLength);
 
   /**
-   * The current file system state.
-   */
-  FileSystemState _fsState;
-
-  /**
-   * The set of added files.
-   */
-  final _addedFiles = new LinkedHashSet<String>();
-
-  /**
    * The set of priority files, that should be analyzed sooner.
    */
   final _priorityFiles = new LinkedHashSet<String>();
 
   /**
    * The mapping from the files for which analysis was requested using
    * [getResult] to the [Completer]s to report the result.
    */
   final _requestedFiles = <String, List<Completer<AnalysisResult>>>{};
 
@@ skipping 20 matching lines @@
       <String, List<Completer<AnalysisDriverUnitIndex>>>{};
 
   /**
    * The mapping from the files for which the index was requested using
    * [getIndex] to the [Completer]s to report the result.
    */
   final _unitElementRequestedFiles =
       <String, List<Completer<CompilationUnitElement>>>{};
 
   /**
-   * The set of files were reported as changed through [changeFile] and not
-   * checked for actual changes yet.
-   */
-  final _changedFiles = new LinkedHashSet<String>();
-
-  /**
-   * The set of files that are currently scheduled for analysis.
-   */
-  final _filesToAnalyze = new LinkedHashSet<String>();
-
-  /**
    * The mapping from the files for which analysis was requested using
    * [getResult], and which were found to be parts without known libraries,
    * to the [Completer]s to report the result.
    */
   final _requestedParts = <String, List<Completer<AnalysisResult>>>{};
 
   /**
    * The set of part files that are currently scheduled for analysis.
    */
   final _partsToAnalyze = new LinkedHashSet<String>();
@@ skipping 15 matching lines @@
       new StreamController<ExceptionResult>();
 
   /**
    * The instance of the [Search] helper.
    */
   Search _search;
 
   AnalysisDriverTestView _testView;
 
   /**
+   * The [FileTracker] used by this driver.
+   */
+  FileTracker _fileTracker;
+
+  /**
    * 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,
-      this._logger,
+      PerformanceLog logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       this.name,
       SourceFactory sourceFactory,
       this._analysisOptions,
       {PackageBundle sdkBundle})
       : _sourceFactory = sourceFactory.clone(),
         _sdkBundle = sdkBundle {
     _testView = new AnalysisDriverTestView(this);
-    _fillSalt();
-    _fsState = new FileSystemState(_logger, _byteStore, _contentOverlay,
-        _resourceProvider, sourceFactory, _analysisOptions, _salt);
+    _createFileTracker(logger);
     _scheduler._add(this);
     _search = new Search(this);
   }
 
   /**
    * Return the set of files explicitly added to analysis using [addFile].
    */
-  Set<String> get addedFiles => _addedFiles;
+  Set<String> get addedFiles => _fileTracker.addedFiles;
 
   /**
    * Return the analysis options used to control analysis.
    */
   AnalysisOptions get analysisOptions => _analysisOptions;
 
   /**
    * Return the stream that produces [ExceptionResult]s.
    */
   Stream<ExceptionResult> get exceptions => _exceptionController.stream;
 
   /**
    * The current file system state.
    */
-  FileSystemState get fsState => _fsState;
+  FileSystemState get fsState => _fileTracker.fsState;
 
   /**
    * Return `true` if the driver has a file to analyze.
    */
   bool get hasFilesToAnalyze {
-    return _changedFiles.isNotEmpty ||
+    return _fileTracker.hasChangedFiles ||
         _requestedFiles.isNotEmpty ||
         _requestedParts.isNotEmpty ||
-        _filesToAnalyze.isNotEmpty ||
+        _fileTracker.hasPendingFiles ||
         _partsToAnalyze.isNotEmpty;
   }
 
   /**
    * Return the set of files that are known at this moment. This set does not
    * always include all added files or all implicitly used file. If a file has
    * not been processed yet, it might be missing.
    */
-  Set<String> get knownFiles => _fsState.knownFilePaths;
+  Set<String> get knownFiles => _fileTracker.fsState.knownFilePaths;
 
   /**
    * Return the number of files scheduled for analysis.
    */
-  int get numberOfFilesToAnalyze => _filesToAnalyze.length;
+  int get numberOfFilesToAnalyze => _fileTracker.numberOfPendingFiles;
 
   /**
    * Return the list of files that the driver should try to analyze sooner.
    */
   List<String> get priorityFiles => _priorityFiles.toList(growable: false);
 
   /**
    * 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) {
     _priorityResults.keys
         .toSet()
         .difference(priorityPaths.toSet())
         .forEach(_priorityResults.remove);
     _priorityFiles.clear();
     _priorityFiles.addAll(priorityPaths);
-    _scheduler._notify(this);
+    _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
    * an analysis result is produced for every added file prior to the next time
@@ skipping 42 matching lines @@
       return AnalysisDriverPriority.interactive;
     }
     if (_unitElementRequestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_topLevelNameDeclarationsTasks.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_priorityFiles.isNotEmpty) {
       for (String path in _priorityFiles) {
-        if (_filesToAnalyze.contains(path)) {
+        if (_fileTracker.isFilePending(path)) {
           return AnalysisDriverPriority.priority;
         }
       }
     }
-    if (_filesToAnalyze.isNotEmpty) {
+    if (_fileTracker.hasPendingFiles) {
       return AnalysisDriverPriority.general;
     }
-    if (_changedFiles.isNotEmpty) {
+    if (_fileTracker.hasChangedFiles) {
       return AnalysisDriverPriority.general;
     }
     if (_requestedParts.isNotEmpty || _partsToAnalyze.isNotEmpty) {
       return AnalysisDriverPriority.general;
     }
     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)) {
+    if (!_fileTracker.fsState.hasUri(path)) {
       return;
     }
     if (AnalysisEngine.isDartFileName(path)) {
-      _addedFiles.add(path);
-      _filesToAnalyze.add(path);
-      _priorityResults.clear();
+      _fileTracker.addFile(path);
     }
-    _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);
-    }
+    _fileTracker.changeFile(path);
     _priorityResults.clear();
-    _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);
-    _scheduler._notify(this);
+    var addedFiles = _fileTracker.addedFiles;

[scheglov, 2017/02/02 21:52:17]

Type?

[Paul Berry, 2017/02/02 22:22:19]

Done.

+    _createFileTracker(_fileTracker.logger);
+    _fileTracker.addFiles(addedFiles);
   }
 
   /**
    * Notify the driver that the client is going to stop using it.
    */
   void dispose() {
     _scheduler._remove(this);
   }
 
   /**
@@ skipping 26 matching lines @@
         analysisResult.errors);
   }
 
   /**
    * Return a [Future] that completes with the list of added files that
    * define a class member with the given [name].
    */
   Future<List<String>> getFilesDefiningClassMemberName(String name) {
     var task = new _FilesDefiningClassMemberNameTask(this, name);
     _definingClassMemberNameTasks.add(task);
-    _scheduler._notify(this);
+    _scheduler.notify(this);
     return task.completer.future;
   }
 
   /**
    * 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);
-    _scheduler._notify(this);
+    _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)) {
+    if (!_fileTracker.fsState.hasUri(path)) {
       return new Future.value();
     }
     var completer = new Completer<AnalysisDriverUnitIndex>();
     _indexRequestedFiles
         .putIfAbsent(path, () => <Completer<AnalysisDriverUnitIndex>>[])
         .add(completer);
-    _scheduler._notify(this);
+    _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.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
    * 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 (!_fsState.hasUri(path)) {
+    if (!_fileTracker.fsState.hasUri(path)) {
       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);
-    _scheduler._notify(this);
+    _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);
+      FileState file = _fileTracker.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);
-    _scheduler._notify(this);
+    _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)) {
+    if (!_fileTracker.fsState.hasUri(path)) {
       return new Future.value();
     }
     var completer = new Completer<CompilationUnitElement>();
     _unitElementRequestedFiles
         .putIfAbsent(path, () => <Completer<CompilationUnitElement>>[])
         .add(completer);
-    _scheduler._notify(this);
+    _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.
    *
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
    * The parsing is performed in the method itself, and the result is not
    * produced through the [results] stream (just because it is not a fully
    * resolved unit).
    */
   Future<ParseResult> parseFile(String path) async {
-    FileState file = _verifyApiSignature(path);
+    FileState file = _fileTracker.verifyApiSignature(path);
     RecordingErrorListener listener = new RecordingErrorListener();
     CompilationUnit unit = file.parse(listener);
     return new ParseResult(file.path, file.uri, file.content, file.contentHash,
         unit.lineInfo, unit, listener.errors);
   }
 
   /**
    * 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) {
-    _addedFiles.remove(path);
-    _filesToAnalyze.remove(path);
-    _fsState.removeFile(path);
-    _filesToAnalyze.addAll(_addedFiles);
+    _fileTracker.removeFile(path);
     _priorityResults.clear();
-    _scheduler._notify(this);
   }
 
   /**
+   * Handles a notification from the [FileTracker] that there has been a change
+   * of state.
+   */
+  void _changeHook() {
+    _priorityResults.clear();
+    _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`.
    *
    * 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.
    */
   AnalysisResult _computeAnalysisResult(String path,
       {bool withUnit: false, bool asIsIfPartWithoutLibrary: false}) {
     /**
      * If the [file] is a library, return the [file] itself.
      * If the [file] is a part, return a library it is known to be a part of.
      * If there is no such library, return `null`.
      */
     FileState getLibraryFile(FileState file) {
       FileState libraryFile = file.isPart ? file.library : file;
       if (libraryFile == null && asIsIfPartWithoutLibrary) {
         libraryFile = file;
       }
       return libraryFile;
     }
 
     // If we don't need the fully resolved unit, check for the cached result.
     if (!withUnit) {
-      FileState file = _fsState.getFileForPath(path);
+      FileState file = _fileTracker.fsState.getFileForPath(path);
 
       // Prepare the library file - the file itself, or the known library.
       FileState libraryFile = getLibraryFile(file);
       if (libraryFile == null) {
         return null;
       }
 
       // Check for the cached result.
       String key = _getResolvedUnitKey(libraryFile, file);
       List<int> bytes = _byteStore.get(key);
       if (bytes != null) {
         return _getAnalysisResultFromBytes(file, bytes);
       }
     }
 
     // We need the fully resolved unit, or the result is not cached.
-    return _logger.run('Compute analysis result for $path', () {
-      FileState file = _verifyApiSignature(path);
+    return _fileTracker.logger.run('Compute analysis result for $path', () {

[scheglov, 2017/02/02 21:52:17]

Accessing logger from _fileTracker seems a bit cumbersome.
Why not keep a reference in the driver?

[Paul Berry, 2017/02/02 22:22:19]

Done.

+      FileState file = _fileTracker.verifyApiSignature(path);
 
       // Prepare the library file - the file itself, or the known library.
       FileState libraryFile = getLibraryFile(file);
       if (libraryFile == null) {
         return null;
       }
 
       try {
         LibraryContext libraryContext = _createLibraryContext(libraryFile);
         try {
@@ skipping 15 matching lines @@
                             message: error.message,
                             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.');
+          _fileTracker.logger.writeln('Computed new analysis result.');
           AnalysisResult result = _getAnalysisResultFromBytes(file, bytes,
               content: withUnit ? file.content : null,
-              withErrors: _addedFiles.contains(path),
+              withErrors: _fileTracker.addedFiles.contains(path),
               resolvedUnit: withUnit ? resolvedUnit : null);
           if (withUnit && _priorityFiles.contains(path)) {
             _priorityResults[path] = result;
           }
           return result;
         } finally {
           libraryContext.dispose();
         }
       } catch (exception, stackTrace) {
         String contextKey =
             _storeExceptionContext(path, libraryFile, exception, stackTrace);
         throw new _ExceptionState(exception, stackTrace, contextKey);
       }
     });
   }
 
   AnalysisDriverUnitIndex _computeIndex(String path) {
     AnalysisResult analysisResult = _computeAnalysisResult(path,
         withUnit: false, asIsIfPartWithoutLibrary: true);
     return analysisResult._index;
   }
 
   CompilationUnitElement _computeUnitElement(String path) {
-    FileState file = _fsState.getFileForPath(path);
+    FileState file = _fileTracker.fsState.getFileForPath(path);
     FileState libraryFile = file.library ?? file;
 
     // Create the AnalysisContext to resynthesize elements in.
     LibraryContext libraryContext = _createLibraryContext(libraryFile);
 
     // Resynthesize the CompilationUnitElement in the context.
     try {
       return libraryContext.computeUnitElement(libraryFile.source, file.source);
     } finally {
       libraryContext.dispose();
     }
   }
 
   /**
+   * 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);
+  }
+
+  /**
    * Return the context in which the [library] should be analyzed.
    */
   LibraryContext _createLibraryContext(FileState library) =>
       new LibraryContext.forSingleLibrary(
           library,
-          _logger,
+          _fileTracker.logger,
           _sdkBundle,
           _byteStore,
           _analysisOptions,
           declaredVariables,
           _sourceFactory,
-          _fsState);
+          _fileTracker);
 
   /**
    * 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 72 matching lines @@
         }
       }
     }
     return null;
   }
 
   /**
    * Perform a single chunk of work and produce [results].
    */
   Future<Null> _performWork() async {
-    // Verify all changed files one at a time.
-    if (_changedFiles.isNotEmpty) {
-      String path = _removeFirst(_changedFiles);
-      // If the file has not been accessed yet, we either will eventually read
-      // it later while analyzing one of the added files, or don't need it.
-      if (_fsState.knownFilePaths.contains(path)) {
-        _verifyApiSignature(path);
-      }
+    if (_fileTracker.verifyChangedFilesIfNeeded()) {
       return;
     }
 
     // Analyze a requested file.
     if (_requestedFiles.isNotEmpty) {
       String path = _requestedFiles.keys.first;
       try {
         AnalysisResult result = _computeAnalysisResult(path, withUnit: true);
         // If a part without a library, delay its analysis.
         if (result == null) {
           _requestedParts
               .putIfAbsent(path, () => [])
               .addAll(_requestedFiles.remove(path));
           return;
         }
         // Notify the completers.
         _requestedFiles.remove(path).forEach((completer) {
           completer.complete(result);
         });
         // Remove from to be analyzed and produce it now.
-        _filesToAnalyze.remove(path);
         _resultController.add(result);
       } catch (exception, stackTrace) {
-        _filesToAnalyze.remove(path);
         _requestedFiles.remove(path).forEach((completer) {
           completer.completeError(exception, stackTrace);
         });
+      } finally {
+        _fileTracker.fileWasAnalyzed(path);

[scheglov, 2017/02/02 21:52:17]

This code will be executed even if result == null, when we have a part without a
library.

[Paul Berry, 2017/02/02 22:22:19]

Ah, I see.  Good catch.  Fixed.

       }
       return;
     }
 
     // Process an index request.
     if (_indexRequestedFiles.isNotEmpty) {
       String path = _indexRequestedFiles.keys.first;
       AnalysisDriverUnitIndex index = _computeIndex(path);
       _indexRequestedFiles.remove(path).forEach((completer) {
         completer.complete(index);
@@ skipping 38 matching lines @@
       bool isDone = await task.perform();
       if (isDone) {
         _topLevelNameDeclarationsTasks.remove(task);
       }
       return;
     }
 
     // Analyze a priority file.
     if (_priorityFiles.isNotEmpty) {
       for (String path in _priorityFiles) {
-        if (_filesToAnalyze.remove(path)) {
+        if (_fileTracker.isFilePending(path)) {
           try {
             AnalysisResult result =
                 _computeAnalysisResult(path, withUnit: true);
             if (result == null) {
               _partsToAnalyze.add(path);
             } else {
               _resultController.add(result);
             }
           } catch (exception, stackTrace) {
             _reportException(path, exception, stackTrace);
+          } finally {
+            _fileTracker.fileWasAnalyzed(path);
           }
           return;
         }
       }
     }
 
-    // Analyze a general file.
-    if (_filesToAnalyze.isNotEmpty) {
-      String path = _removeFirst(_filesToAnalyze);
+    if (_fileTracker.hasPendingFiles) {
+      // Analyze a general file.
+      String path = _fileTracker.anyPendingFile;
       try {
         AnalysisResult result = _computeAnalysisResult(path, withUnit: false);
         if (result == null) {
           _partsToAnalyze.add(path);
         } else {
           _resultController.add(result);
         }
       } catch (exception, stackTrace) {
         _reportException(path, exception, stackTrace);
+      } finally {
+        _fileTracker.fileWasAnalyzed(path);
       }
       return;
     }
 
     // Analyze a requested part file.
     if (_requestedParts.isNotEmpty) {
       String path = _requestedParts.keys.first;
       try {
         AnalysisResult result = _computeAnalysisResult(path,
             withUnit: true, asIsIfPartWithoutLibrary: true);
         // Notify the completers.
         _requestedParts.remove(path).forEach((completer) {
           completer.complete(result);
         });
         // Remove from to be analyzed and produce it now.
         _partsToAnalyze.remove(path);
         _resultController.add(result);
       } catch (exception, stackTrace) {
         _partsToAnalyze.remove(path);
         _requestedParts.remove(path).forEach((completer) {
           completer.completeError(exception, stackTrace);
         });
       }
       return;
     }
 
     // Analyze a general part.
     if (_partsToAnalyze.isNotEmpty) {
-      String path = _removeFirst(_partsToAnalyze);
+      String path = _partsToAnalyze.first;
+      _partsToAnalyze.remove(path);
       try {
         AnalysisResult result = _computeAnalysisResult(path,
             withUnit: _priorityFiles.contains(path),
             asIsIfPartWithoutLibrary: true);
         _resultController.add(result);
       } catch (exception, stackTrace) {
         _reportException(path, exception, stackTrace);
       }
       return;
     }
@@ skipping 52 matching lines @@
       String sec = _twoDigits(time.second);
       String ms = _threeDigits(time.millisecond);
       String key = 'exception_${time.year}$m$d' '_$h$min$sec' + '_$ms';
 
       _byteStore.put(key, bytes);
       return key;
     } catch (_) {
       return null;
     }
   }
-
-  /**
-   * Verify the API signature for the file with the given [path], and decide
-   * which linked libraries should be invalidated, and files reanalyzed.
-   */
-  FileState _verifyApiSignature(String path) {
-    return _logger.run('Verify API signature of $path', () {
-      bool anyApiChanged = false;
-      List<FileState> files = _fsState.getFilesForPath(path);
-      for (FileState file in files) {
-        bool apiChanged = file.refresh();
-        if (apiChanged) {
-          anyApiChanged = true;
-        }
-      }
-      if (anyApiChanged) {
-        _logger.writeln('API signatures mismatch found for $path');
-        // TODO(scheglov) schedule analysis of only affected files
-        _filesToAnalyze.addAll(_addedFiles);
-      }
-      return files[0];
-    });
-  }
-
-  /**
-   * Remove and return the first item in the given [set].
-   */
-  static Object/*=T*/ _removeFirst/*<T>*/(LinkedHashSet<Object/*=T*/ > set) {
-    Object/*=T*/ element = set.first;
-    set.remove(element);
-    return element;
-  }
 }
 
 /**
  * Priorities of [AnalysisDriver] work. The farther a priority to the beginning
  * of the list, the earlier the corresponding [AnalysisDriver] should be asked
  * to perform work.
  */
 enum AnalysisDriverPriority { nothing, general, priority, interactive }
 
 /**
@@ skipping 47 matching lines @@
   bool get _hasFilesToAnalyze {
     for (AnalysisDriver driver in _drivers) {
       if (driver.hasFilesToAnalyze) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * 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();
+  }
+
+  /**
    * Start the scheduler, so that any [AnalysisDriver] created before or
    * after will be asked to perform work.
    */
   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();
   }
 
   /**
    * Run infinitely analysis cycle, selecting the drivers with the highest
@@ skipping 59 matching lines @@
     return new Future.delayed(Duration.ZERO, () => _pumpEventQueue(times - 1));
   }
 }
 
 @visibleForTesting
 class AnalysisDriverTestView {
   final AnalysisDriver driver;
 
   AnalysisDriverTestView(this.driver);
 
-  Set<String> get filesToAnalyze => driver._filesToAnalyze;
+  FileTracker get fileTracker => driver._fileTracker;
 
   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
@@ skipping 317 matching lines @@
       }
 
       // If no more files to check, complete and done.
       if (filesToCheck.isEmpty) {
         completer.complete(definingFiles);
         return true;
       }
 
       // Check the next file.
       String path = filesToCheck.removeLast();
-      FileState file = driver._fsState.getFileForPath(path);
+      FileState file = driver._fileTracker.fsState.getFileForPath(path);
       if (file.definedClassMemberNames.contains(name)) {
         definingFiles.add(path);
       }
       checkedFiles.add(path);
     }
 
     // We're not done yet.
     return false;
   }
 }
@@ skipping 36 matching lines @@
       }
 
       // If no more files to check, complete and done.
       if (filesToCheck.isEmpty) {
         completer.complete(referencingFiles);
         return true;
       }
 
       // Check the next file.
       String path = filesToCheck.removeLast();
-      FileState file = driver._fsState.getFileForPath(path);
+      FileState file = driver._fileTracker.fsState.getFileForPath(path);
       if (file.referencedNames.contains(name)) {
         referencingFiles.add(path);
       }
       checkedFiles.add(path);
     }
 
     // We're not done yet.
     return false;
   }
 }
@@ skipping 29 matching lines @@
 
     // If no more files to check, complete and done.
     if (filesToCheck.isEmpty) {
       completer.complete(libraryDeclarations);
       return true;
     }
 
     // Check the next file.
     String path = filesToCheck.removeLast();
     if (checkedFiles.add(path)) {
-      FileState file = driver._fsState.getFileForPath(path);
+      FileState file = driver._fileTracker.fsState.getFileForPath(path);
       if (!file.isPart) {
         bool isExported = false;
         TopLevelDeclaration declaration = file.topLevelDeclarations[name];
         for (FileState part in file.partedFiles) {
           declaration ??= part.topLevelDeclarations[name];
         }
         if (declaration == null) {
           declaration = file.exportedTopLevelDeclarations[name];
           isExported = true;
         }
         if (declaration != null) {
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }