Add FileSystemState.knownFilesSetChanges stream.

pkg/analyzer/lib/src/dart/analysis/file_state.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:convert';
 import 'dart:typed_data';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/defined_names.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
@@ skipping 594 matching lines @@
    * Mapping from a URI to the corresponding [FileState].
    */
   final Map<Uri, FileState> _uriToFile = {};
 
   /**
    * All known file paths.
    */
   final Set<String> knownFilePaths = new Set<String>();
 
   /**
+   * The paths of files that were added to the set of known files since the
+   * last [knownFilesSetChanges] notification.
+   */
+  final Set<String> _addedKnownFiles = new Set<String>();
+
+  /**
+   * If not `null`, this delay will be awaited instead of the default one.
+   */
+  Duration _knownFilesSetChangesDelay;
+
+  /**
+   * The instance of timer that is scheduled to send a new update to the
+   * [knownFilesSetChanges] stream, or `null` if there are no changes to the
+   * set of known files to notify the stream about.
+   */
+  Timer _knownFilesSetChangesTimer;
+
+  /**
+   * The controller for the [knownFilesSetChanges] stream.
+   */
+  final StreamController<KnownFilesSetChange> _knownFilesSetChangesController =
+      new StreamController<KnownFilesSetChange>();
+
+  /**
    * Mapping from a path to the flag whether there is a URI for the path.
    */
   final Map<String, bool> _hasUriForPath = {};
 
   /**
    * Mapping from a path to the corresponding [FileState]s, canonical or not.
    */
   final Map<String, List<FileState>> _pathToFiles = {};
 
   /**
@@ skipping 23 matching lines @@
       this._salt) {
     _testView = new FileSystemStateTestView(this);
   }
 
   /**
    * Return the known files.
    */
   List<FileState> get knownFiles =>
       _pathToFiles.values.map((files) => files.first).toList();
 
+  /**
+   * Return the [Stream] that is periodically notified about changes to the
+   * known files set.
+   */
+  Stream<KnownFilesSetChange> get knownFilesSetChanges =>
+      _knownFilesSetChangesController.stream;
+
   @visibleForTesting
   FileSystemStateTestView get test => _testView;
 
   /**
    * Return the [FileState] instance that correspond to an unresolved URI.
    */
   FileState get unresolvedFile {
     if (_unresolvedFile == null) {
       _unresolvedFile = new FileState._(this, null, null, null);
       _unresolvedFile.refresh();
@@ skipping 105 matching lines @@
     _pathToCanonicalFile.clear();
     _partToLibraries.clear();
   }
 
   void _addFileWithPath(String path, FileState file) {
     var files = _pathToFiles[path];
     if (files == null) {
       knownFilePaths.add(path);
       files = <FileState>[];
       _pathToFiles[path] = files;
+      // Schedule the stream update.
+      _addedKnownFiles.add(path);
+      _scheduleKnownFilesSetChange();
     }
     files.add(file);
   }
+
+  void _scheduleKnownFilesSetChange() {
+    Duration delay = _knownFilesSetChangesDelay ?? new Duration(seconds: 1);
+    _knownFilesSetChangesTimer ??= new Timer(delay, () {
+      Set<String> addedFiles = _addedKnownFiles.toSet();
+      Set<String> removedFiles = new Set<String>();
+      _knownFilesSetChangesController
+          .add(new KnownFilesSetChange(addedFiles, removedFiles));

[Brian Wilkerson, 2017/04/19 20:09:52]

Do we want to only add to the stream if at least one of the added and removed
sets are non-empty?

[scheglov, 2017/04/19 20:21:47]

Yes, the intention is that we send only useful notifications.

Currently this happens implicitly, because we schedule sending notifications
only when a new file is added.

+      _addedKnownFiles.clear();
+      _knownFilesSetChangesTimer = null;
+    });
+  }
 }
 
 @visibleForTesting
 class FileSystemStateTestView {
   final FileSystemState state;
 
   FileSystemStateTestView(this.state);
 
   Set<FileState> get filesWithoutTransitiveFiles {
     return state._uriToFile.values
         .where((f) => f._transitiveFiles == null)
         .toSet();
   }
 
   Set<FileState> get filesWithoutTransitiveSignature {
     return state._uriToFile.values
         .where((f) => f._transitiveSignature == null)
         .toSet();
   }
+
+  void set knownFilesDelay(Duration value) {
+    state._knownFilesSetChangesDelay = value;
+  }
+}
+
+/**
+ * Information about changes to the known file set.
+ */
+class KnownFilesSetChange {
+  final Set<String> added;
+  final Set<String> removed;
+
+  KnownFilesSetChange(this.added, this.removed);
 }
 
 class _FastaElementProxy implements fasta.KernelClassElement {
   @override
   final fasta.KernelInterfaceType rawType = new _FastaInterfaceTypeProxy();
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 class _FastaElementStoreProxy implements fasta.ElementStore {
   final _elements = <fasta.Builder, _FastaElementProxy>{};
 
   @override
   _FastaElementProxy operator [](fasta.Builder builder) =>
       _elements.putIfAbsent(builder, () => new _FastaElementProxy());
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 class _FastaInterfaceTypeProxy implements fasta.KernelInterfaceType {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }