Add hook for listening to implicitly analyzed files

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'dart:async';
@@ skipping 190 matching lines @@
             JavaSystem.currentTimeMillis();
           }
         }
         _partitions[i].put(source, entry);
         return;
       }
     }
   }
 
   /**
-   * Remove all information related to the given [source] from this cache.
+   * Remove all information related to the given [source] from this cache and
+   * return the entry associated with the source.

[Paul Berry, 2015/07/15 19:50:01]

Document when we would return `null` here too.

[Brian Wilkerson, 2015/07/15 21:23:37]

Done

    */
-  void remove(Source source) {
+  SourceEntry remove(Source source) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
         if (_TRACE_CHANGES) {
           try {
             AnalysisEngine.instance.logger.logInformation(
                 "Removed the cache entry for ${source.fullName}'.");
           } catch (exception) {
             // Ignored
             JavaSystem.currentTimeMillis();
           }
         }
-        _partitions[i].remove(source);
-        return;
+        return _partitions[i].remove(source);
       }
     }
+    return null;
   }
 
   /**
    * Record that the AST associated with the given [source] was just removed
    * from the cache.
    */
   void removedAst(Source source) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
@@ skipping 95 matching lines @@
    * that needs to be analyzed is not contained in the list, then it will be
    * treated as if it were at the end of the list. If the list is empty (or
    * `null`) then no sources will be given priority over other sources.
    *
    * Changes made to the list after this method returns will <b>not</b> be
    * reflected in the priority order.
    */
   void set analysisPriorityOrder(List<Source> sources);
 
   /**
+   * The stream that is notified when a source either starts or stops being
+   * analyzed implicitly.
+   */
+  Stream<AnalyzedSourcesEvent> get analyzedSources;

[Paul Berry, 2015/07/15 19:50:01]

Similarly, consider renaming this to "implicitlyAnalyzedSources".

[Brian Wilkerson, 2015/07/15 21:23:37]

I struggled a bit with the name. I suppose what you're proposing is a little
better than what I ended up with, but
(a) both sound like they should be returning a List<Source> rather than a
Stream, and
(b) the real name of this getter probably wants to be something like
onImplicitlyAnalyzedSourcesChanged, which is a bit long even for me.

Interested to hear what you think.

+
+  /**
    * Return the set of declared variables used when computing constant values.
    */
   DeclaredVariables get declaredVariables;
 
   /**
    * Return a list containing all of the sources known to this context that
    * represent HTML files. The contents of the list can be incomplete.
    */
   List<Source> get htmlSources;
 
@@ skipping 672 matching lines @@
    * The [Stopwatch] of the current "perform tasks cycle".
    */
   Stopwatch _performAnalysisTaskStopwatch;
 
   /**
    * The controller for sending [SourcesChangedEvent]s.
    */
   StreamController<SourcesChangedEvent> _onSourcesChangedController;
 
   /**
+   * A subscription for a stream of events indicating when files are (and are
+   * not) being implicitly analyzed.
+   */
+  StreamController<AnalyzedSourcesEvent> _analyzedSourcesController;
+
+  /**
    * The listeners that are to be notified when various analysis results are
    * produced in this context.
    */
   List<AnalysisListener> _listeners = new List<AnalysisListener>();
 
   /**
    * The most recently incrementally resolved source, or `null` when it was
    * already validated, or the most recent change was not incrementally resolved.
    */
   Source incrementalResolutionValidation_lastUnitSource;
@@ skipping 30 matching lines @@
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _privatePartition = new UniversalCachePartition(this,
         AnalysisOptionsImpl.DEFAULT_CACHE_SIZE,
         new AnalysisContextImpl_ContextRetentionPolicy(this));
     _cache = createCacheFromSourceFactory(null);
     _onSourcesChangedController =
         new StreamController<SourcesChangedEvent>.broadcast();
+    _analyzedSourcesController =
+        new StreamController<AnalyzedSourcesEvent>.broadcast();
   }
 
   @override
   AnalysisCache get analysisCache => _cache;
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
@@ skipping 71 matching lines @@
       for (var source in _priorityOrder) {
         SourceEntry entry = _getReadableSourceEntry(source);
         if (entry == null) {
           _createSourceEntry(source, false);
         }
       }
     }
   }
 
   @override
+  Stream<AnalyzedSourcesEvent> get analyzedSources =>
+      _analyzedSourcesController.stream;
+
+  @override
   set contentCache(ContentCache value) {
     _contentCache = value;
   }
 
   @override
   DeclaredVariables get declaredVariables => _declaredVariables;
 
   @override
   List<AnalysisTarget> get explicitTargets {
     List<AnalysisTarget> targets = <AnalysisTarget>[];
@@ skipping 1215 matching lines @@
         // during resolution.
         //
         if (thrownException == null) {
           var message = "In recordResolveDartLibraryCycleTaskResults, "
               "resolvedLibraries was null and there was no thrown exception";
           unitEntry.recordResolutionError(
               new CaughtException(new AnalysisException(message), null));
         } else {
           unitEntry.recordResolutionError(thrownException);
         }
-        _cache.remove(unitSource);
+        _removeFromCache(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
         return unitEntry;
       }
       Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
       RecordingErrorListener errorListener = resolver.errorListener;
       for (ResolvableLibrary library in resolvedLibraries) {
         Source librarySource = library.librarySource;
         for (Source source in library.compilationUnitSources) {
@@ skipping 52 matching lines @@
         // during resolution.
         //
         if (thrownException == null) {
           String message = "In recordResolveDartLibraryTaskResults, "
               "resolvedLibraries was null and there was no thrown exception";
           unitEntry.recordResolutionError(
               new CaughtException(new AnalysisException(message), null));
         } else {
           unitEntry.recordResolutionError(thrownException);
         }
-        _cache.remove(unitSource);
+        _removeFromCache(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
         return unitEntry;
       }
       Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
       RecordingErrorListener errorListener = resolver.errorListener;
       for (Library library in resolvedLibraries) {
         Source librarySource = library.librarySource;
         for (Source source in library.compilationUnitSources) {
           CompilationUnit unit = library.getAST(source);
           List<AnalysisError> errors = errorListener.getErrorsForSource(source);
           LineInfo lineInfo = getLineInfo(source);
           DartEntry dartEntry = _cache.get(source);
           if (thrownException == null) {
             dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
             dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
             dartEntry.setValueInLibrary(
                 DartEntry.RESOLVED_UNIT, librarySource, unit);
             dartEntry.setValueInLibrary(
                 DartEntry.RESOLUTION_ERRORS, librarySource, errors);
             if (source == librarySource) {
               _recordElementData(
                   dartEntry, library.libraryElement, librarySource, htmlSource);
             }
             _cache.storedAst(source);
           } else {
             dartEntry.recordResolutionErrorInLibrary(
                 librarySource, thrownException);
-            _cache.remove(source);
+            _removeFromCache(source);
           }
           if (source != librarySource) {
             _workManager.add(source, SourcePriority.PRIORITY_PART);
           }
           ChangeNoticeImpl notice = getNotice(source);
           notice.resolvedDartUnit = unit;
           notice.setErrors(dartEntry.allErrors, lineInfo);
         }
       }
     }
@@ skipping 81 matching lines @@
       }
     }
     int count = changedSources.length;
     for (int i = 0; i < count; i++) {
       _sourceChanged(changedSources[i]);
     }
     int removalCount = 0;
     for (Source source in missingSources) {
       if (getLibrariesContaining(source).isEmpty &&
           getLibrariesDependingOn(source).isEmpty) {
-        _cache.remove(source);
+        _removeFromCache(source);
         removalCount++;
       }
     }
     int consistencyCheckEnd = JavaSystem.nanoTime();
     if (changedSources.length > 0 || missingSources.length > 0) {
       StringBuffer buffer = new StringBuffer();
       buffer.write("Consistency check took ");
       buffer.write((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
       buffer.writeln(" ms and found");
       buffer.write("  ");
@@ skipping 749 matching lines @@
    * Create a source entry for the given [source]. Return the source entry that
    * was created, or `null` if the source should not be tracked by this context.
    */
   SourceEntry _createSourceEntry(Source source, bool explicitlyAdded) {
     String name = source.shortName;
     if (AnalysisEngine.isHtmlFileName(name)) {
       HtmlEntry htmlEntry = new HtmlEntry();
       htmlEntry.modificationTime = getModificationStamp(source);
       htmlEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, htmlEntry);
+      if (!explicitlyAdded) {
+        _analyzedSourcesController.add(new AnalyzedSourcesEvent(source, true));
+      }
       return htmlEntry;
     } else {
       DartEntry dartEntry = new DartEntry();
       dartEntry.modificationTime = getModificationStamp(source);
       dartEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, dartEntry);
+      if (!explicitlyAdded) {
+        _analyzedSourcesController.add(new AnalyzedSourcesEvent(source, true));
+      }
       return dartEntry;
     }
   }
 
   /**
    * Return a list containing all of the change notices that are waiting to be
    * returned. If there are no notices, then return either `null` or an empty
    * list, depending on the value of [nullIfEmpty].
    */
   List<ChangeNotice> _getChangeNotices(bool nullIfEmpty) {
@@ skipping 697 matching lines @@
   bool _isTooBigHtmlSourceEntry(Source source, SourceEntry sourceEntry) =>
       false;
 
   /**
    * Log the given debugging [message].
    */
   void _logInformation(String message) {
     AnalysisEngine.instance.logger.logInformation(message);
   }
 
+  /**
+   * Notify all of the analysis listeners that a task is about to be performed.
+   */
+  void _notifyAboutToPerformTask(String taskDescription) {
+    int count = _listeners.length;
+    for (int i = 0; i < count; i++) {
+      _listeners[i].aboutToPerformTask(this, taskDescription);
+    }
+  }
+
 //  /**
 //   * Notify all of the analysis listeners that the given source is no longer included in the set of
 //   * sources that are being analyzed.
 //   *
 //   * @param source the source that is no longer being analyzed
 //   */
 //  void _notifyExcludedSource(Source source) {
 //    int count = _listeners.length;
 //    for (int i = 0; i < count; i++) {
 //      _listeners[i].excludedSource(this, source);
@@ skipping 59 matching lines @@
 //   * @param unit the result of resolving the source
 //   */
 //  void _notifyResolvedHtml(Source source, ht.HtmlUnit unit) {
 //    int count = _listeners.length;
 //    for (int i = 0; i < count; i++) {
 //      _listeners[i].resolvedHtml(this, source, unit);
 //    }
 //  }
 
   /**
-   * Notify all of the analysis listeners that a task is about to be performed.
-   */
-  void _notifyAboutToPerformTask(String taskDescription) {
-    int count = _listeners.length;
-    for (int i = 0; i < count; i++) {
-      _listeners[i].aboutToPerformTask(this, taskDescription);
-    }
-  }
-
-  /**
    * Notify all of the analysis listeners that the errors associated with the
    * given [source] has been updated to the given [errors].
    */
   void _notifyErrors(
       Source source, List<AnalysisError> errors, LineInfo lineInfo) {
     int count = _listeners.length;
     for (int i = 0; i < count; i++) {
       _listeners[i].computedErrors(this, source, errors, lineInfo);
     }
   }
@@ skipping 352 matching lines @@
     LineInfo lineInfo = task.lineInfo;
     dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
     dartEntry.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
     dartEntry.setValue(DartEntry.SCAN_ERRORS, task.errors);
     _cache.storedAst(source);
     ChangeNoticeImpl notice = getNotice(source);
     notice.setErrors(dartEntry.allErrors, lineInfo);
     return dartEntry;
   }
 
+  void _removeFromCache(Source source) {
+    SourceEntry entry = _cache.remove(source);
+    if (entry != null && entry.explicitlyAdded) {
+      _analyzedSourcesController.add(new AnalyzedSourcesEvent(source, false));
+    }
+  }
+
   /**
    * Remove the given [librarySource] from the list of containing libraries for
    * all of the parts referenced by the given [dartEntry].
    */
   void _removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
       DartEntry partEntry = _getReadableDartEntry(partSource);
       if (partEntry != null && !identical(partEntry, dartEntry)) {
         partEntry.removeContainingLibrary(librarySource);
         if (partEntry.containingLibraries.length == 0 && !exists(partSource)) {
-          _cache.remove(partSource);
+          _removeFromCache(partSource);
         }
       }
     }
   }
 
   /**
    * Remove the given libraries that are keys in the given map from the list of
    * containing libraries for each of the parts in the corresponding value.
    */
   void _removeFromPartsUsingMap(HashMap<Source, List<Source>> oldPartMap) {
     oldPartMap.forEach((Source librarySource, List<Source> oldParts) {
       for (int i = 0; i < oldParts.length; i++) {
         Source partSource = oldParts[i];
         if (partSource != librarySource) {
           DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null) {
             partEntry.removeContainingLibrary(librarySource);
             if (partEntry.containingLibraries.length == 0 &&
                 !exists(partSource)) {
-              _cache.remove(partSource);
+              _removeFromCache(partSource);
             }
           }
         }
       }
     });
   }
 
   /**
    * Remove the given [source] from the priority order if it is in the list.
    */
@@ skipping 96 matching lines @@
         libraries.add(librarySource);
         for (Source dependentLibrary
             in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         _invalidateLibraryResolution(librarySource);
       }
     }
-    _cache.remove(source);
+    _removeFromCache(source);
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * TODO(scheglov) A hackish, limited incremental resolution implementation.
    */
   bool _tryPoorMansIncrementalResolution(Source unitSource, String newCode) {
     return PerformanceStatistics.incrementalAnalysis.makeCurrentWhile(() {
       incrementalResolutionValidation_lastUnitSource = null;
@@ skipping 1855 matching lines @@
   E visitResolveHtmlTask(ResolveHtmlTask task);
 
   /**
    * Visit the given [task], returning the result of the visit. This method will
    * throw an AnalysisException if the visitor throws an exception.
    */
   E visitScanDartTask(ScanDartTask task);
 }
 
 /**
+ * An event indicating when a source either starts or stops being implicitly
+ * analyzed.
+ */
+class AnalyzedSourcesEvent {
+  /**
+   * The source whose status has changed.
+   */
+  final Source source;
+
+  /**
+   * A flag indicating whether the source is now being analyzed.
+   */
+  final bool isAnalyzed;
+
+  /**
+   * Initialize a newly created event to indicate that the given [source] has
+   * changed it status to match the [isAnalyzed] flag.
+   */
+  AnalyzedSourcesEvent(this.source, this.isAnalyzed);
+
+  @override
+  String toString() =>
+      '${isAnalyzed ? '' : 'not '}analyzing ${source.fullName}';
+}
+
+/**
  * A `CachedResult` is a single analysis result that is stored in a
  * [SourceEntry].
  */
 class CachedResult<E> {
   /**
    * The state of the cached value.
    */
   CacheState state;
 
   /**
@@ skipping 138 matching lines @@
 
   /**
    * Associate the given [entry] with the given [source].
    */
   void put(Source source, SourceEntry entry) {
     entry.fixExceptionState();
     _sourceMap[source] = entry;
   }
 
   /**
-   * Remove all information related to the given [source] from this cache.
+   * Remove all information related to the given [source] from this partition
+   * and return the entry associated with the source.

[Paul Berry, 2015/07/15 19:50:01]

Document when we might return `null`.

[Brian Wilkerson, 2015/07/15 21:23:37]

Done

    */
-  void remove(Source source) {
+  SourceEntry remove(Source source) {
     _recentlyUsed.remove(source);
-    _sourceMap.remove(source);
+    return _sourceMap.remove(source);
   }
 
   /**
    * Record that the AST associated with the given [source] was just removed
    * from the cache.
    */
   void removedAst(Source source) {
     _recentlyUsed.remove(source);
   }
 
@@ skipping 5070 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }