Add hook for listening to implicitly analyzed files

pkg/analyzer/test/generated/engine_test.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.engine_test;
 
 import 'dart:async';
@@ skipping 227 matching lines @@
     _context.analysisOptions = options;
   }
 
   @override
   void tearDown() {
     _context = null;
     _sourceFactory = null;
     super.tearDown();
   }
 
+  Future test_analyzedSources_added() async {
+    AnalyzedSourcesListener listener = new AnalyzedSourcesListener();
+    _context.analyzedSources.listen(listener.onData);
+    //
+    // Create a file that references an file that is not explicitly being
+    // analyzed and fully analyze it. Ensure that the listener is told about
+    // the implicitly analyzed file.
+    //
+    Source sourceA = _addSource('/a.dart', "library a; import 'b.dart';");
+    Source sourceB = _createSource('/b.dart', "library b;");
+    _context.computeErrors(sourceA);
+    await pumpEventQueue();
+    listener.expectAnalyzed(sourceB);
+  }
+
   Future test_applyChanges_add() {
     SourcesChangedListener listener = new SourcesChangedListener();
     _context.onSourcesChanged.listen(listener.onData);
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
     Source source =
         new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     _context.applyChanges(changeSet);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
@@ skipping 1886 matching lines @@
     fail("performAnalysisTask failed to terminate after analyzing all sources");
   }
 
   void _changeSource(TestSource source, String contents) {
     source.setContents(contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedSource(source);
     _context.applyChanges(changeSet);
   }
 
+  Source _createSource(String fileName, String contents) {
+    Source source = new FileBasedSource(FileUtilities2.createFile(fileName));
+    _context.setContents(source, contents);
+    return source;
+  }
+
   /**
    * Search the given compilation unit for a class with the given name. Return the class with the
    * given name, or `null` if the class cannot be found.
    *
    * @param unit the compilation unit being searched
    * @param className the name of the class being searched for
    * @return the class with the given name
    */
   ClassElement _findClass(CompilationUnitElement unit, String className) {
     for (ClassElement classElement in unit.types) {
@@ skipping 172 matching lines @@
 
 @reflectiveTest
 class AnalysisTaskTest extends EngineTestCase {
   void test_perform_exception() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     AnalysisTask task = new AnalysisTask_test_perform_exception(context);
     task.perform(new TestTaskVisitor<Object>());
   }
 }
 
+/**
+ * A listener used to gather the [AnalyzedSourcesEvent]s that are produced
+ * during analysis.
+ */
+class AnalyzedSourcesListener {
+  /**
+   * The events that have been gathered.
+   */
+  List<AnalyzedSourcesEvent> actualEvents = <AnalyzedSourcesEvent>[];
+
+  /**
+   * The sources that are being implicitly analyzed.
+   */
+  List<Source> analyzedSources = <Source>[];
+
+  /**
+   * Assert that the given source is currently being implicitly analyzed.
+   */
+  void expectAnalyzed(Source source) {
+    expect(analyzedSources, contains(source));
+  }
+
+  /**
+   * Assert that the given source is not currently being implicitly analyzed.
+   */
+  void expectNotAnalyzed(Source source) {
+    expect(analyzedSources, isNot(contains(source)));
+  }
+
+  /**
+   * Record that the given event was produced.
+   */
+  void onData(AnalyzedSourcesEvent event) {
+    actualEvents.add(event);
+    if (event.isAnalyzed) {
+      analyzedSources.add(event.source);
+    } else {
+      analyzedSources.remove(event.source);
+    }
+  }
+}
+
 class CompilationUnitMock extends TypedMock implements CompilationUnit {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 @reflectiveTest
 class DartEntryTest extends EngineTestCase {
   void test_allErrors() {
     Source source = new TestSource();
     DartEntry entry = new DartEntry();
     expect(entry.allErrors, hasLength(0));
@@ skipping 3086 matching lines @@
   }
   @override
   void set analysisOptions(AnalysisOptions options) {
     fail("Unexpected invocation of setAnalysisOptions");
   }
   @override
   void set analysisPriorityOrder(List<Source> sources) {
     fail("Unexpected invocation of setAnalysisPriorityOrder");
   }
   @override
+  Stream<AnalyzedSourcesEvent> get analyzedSources {
+    fail("Unexpected invocation of analyzedSources");
+    return null;
+  }
+  @override
   set contentCache(ContentCache value) {
     fail("Unexpected invocation of setContentCache");
   }
   @override
   DeclaredVariables get declaredVariables {
     fail("Unexpected invocation of getDeclaredVariables");
     return null;
   }
   @override
   List<AnalysisTarget> get explicitTargets {
@@ skipping 42 matching lines @@
   @override
   Stream<SourcesChangedEvent> get onSourcesChanged {
     fail("Unexpected invocation of onSourcesChanged");
     return null;
   }
   @override
   List<Source> get prioritySources {
     fail("Unexpected invocation of getPrioritySources");
     return null;
   }
+
   @override
   List<AnalysisTarget> get priorityTargets {
     fail("Unexpected invocation of visitCacheItems");
     return null;
   }
 
   @override
   CachePartition get privateAnalysisCachePartition {
     fail("Unexpected invocation of privateAnalysisCachePartition");
     return null;
   }
 
   @override
   ResolverVisitorFactory get resolverVisitorFactory {
     fail("Unexpected invocation of getResolverVisitorFactory");
     return null;
   }
-
   @override
   SourceFactory get sourceFactory {
     fail("Unexpected invocation of getSourceFactory");
     return null;
   }
   @override
   void set sourceFactory(SourceFactory factory) {
     fail("Unexpected invocation of setSourceFactory");
   }
   @override
@@ skipping 241 matching lines @@
   @override
   Document parseHtmlDocument(Source source) {
     fail("Unexpected invocation of parseHtmlDocument");
     return null;
   }
   @override
   ht.HtmlUnit parseHtmlUnit(Source source) {
     fail("Unexpected invocation of parseHtmlUnit");
     return null;
   }
+
   @override
   AnalysisResult performAnalysisTask() {
     fail("Unexpected invocation of performAnalysisTask");
     return null;
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     fail("Unexpected invocation of recordLibraryElements");
   }
@@ skipping 22 matching lines @@
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     fail("Unexpected invocation of resolveHtmlUnit");
     return null;
   }
 
   @override
   void setChangedContents(Source source, String contents, int offset,
       int oldLength, int newLength) {
     fail("Unexpected invocation of setChangedContents");
   }
-
   @override
   void setContents(Source source, String contents) {
     fail("Unexpected invocation of setContents");
   }
+
   @override
   bool shouldErrorsBeAnalyzed(Source source, Object entry) {
     fail("Unexpected invocation of shouldErrorsBeAnalyzed");
     return false;
   }
 
   @override
   void test_flushAstStructures(Source source) {
     fail("Unexpected invocation of test_flushAstStructures");
   }
@@ skipping 813 matching lines @@
   @override
   bool exists() => true;
 }
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize
     implements CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }