Add hook for listening to implicitly analyzed files

pkg/analyzer/test/src/context/cache_test.dart

 // Copyright (c) 2015, 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.
 
 library test.src.task.driver_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show
         AnalysisContext,
@@ skipping 158 matching lines @@
     entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
     entry3.setValue(result3, 333, []);
     expect(entry1.getState(result1), CacheState.VALID);
     expect(entry2.getState(result2), CacheState.VALID);
     expect(entry3.getState(result3), CacheState.VALID);
     expect(entry1.getValue(result1), 111);
     expect(entry2.getValue(result2), 222);
     expect(entry3.getValue(result3), 333);
     // remove entry1, invalidate result2 and remove empty entry2
-    cache.remove(target1);
+    expect(cache.remove(target1), entry1);
     expect(cache.get(target1), isNull);
     expect(cache.get(target2), isNull);
     expect(cache.get(target3), entry3);
     expect(entry3.getState(result3), CacheState.VALID);
   }
 
   void test_remove_invalidateResults_sameTarget() {
     AnalysisTarget target = new TestSource('/a.dart');
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     ResultDescriptor result1 = new ResultDescriptor('result1', -1);
     ResultDescriptor result2 = new ResultDescriptor('result2', -2);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
     expect(entry.getState(result1), CacheState.VALID);
     expect(entry.getState(result2), CacheState.VALID);
     expect(entry.getValue(result1), 111);
     expect(entry.getValue(result2), 222);
     // remove target, invalidate result2
-    cache.remove(target);
+    expect(cache.remove(target), entry);
     expect(cache.get(target), isNull);
     expect(entry.getState(result2), CacheState.INVALID);
   }
 
   void test_size() {
     int size = 4;
     for (int i = 0; i < size; i++) {
       AnalysisTarget target = new TestSource("/test$i.dart");
       cache.put(new CacheEntry(target));
     }
@@ skipping 727 matching lines @@
   }
 
   void test_put_noFlush() {
     CachePartition partition = createPartition();
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     partition.put(entry);
     expect(partition.get(target), entry);
   }
 
-  void test_remove() {
+  void test_remove_absent() {
+    CachePartition partition = createPartition();
+    AnalysisTarget target = new TestSource();
+    expect(partition.get(target), isNull);
+    expect(partition.remove(target), isNull);
+    expect(partition.get(target), isNull);
+  }
+
+  void test_remove_present() {
     CachePartition partition = createPartition();
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     partition.put(entry);
     expect(partition.get(target), entry);
-    partition.remove(target);
+    expect(partition.remove(target), entry);
     expect(partition.get(target), isNull);
   }
 }
 
 @reflectiveTest
 class ResultDataTest extends EngineTestCase {
   test_creation() {
     String value = 'value';
     ResultData data = new ResultData(new ResultDescriptor('test', value));
     expect(data, isNotNull);
@@ skipping 32 matching lines @@
     expect(partition.isResponsibleFor(target), isTrue);
   }
 }
 
 @reflectiveTest
 class UniversalCachePartitionTest extends CachePartitionTest {
   CachePartition createPartition() {
     return new UniversalCachePartition(null);
   }
 
+  void test_contains() {
+    UniversalCachePartition partition = new UniversalCachePartition(null);
+    TestSource source = new TestSource();
+    expect(partition.isResponsibleFor(source), isTrue);
+  }
+
   test_dispose() {
     InternalAnalysisContext context = new _InternalAnalysisContextMock();
     CachePartition partition1 = new UniversalCachePartition(context);
     CachePartition partition2 = new UniversalCachePartition(context);
     AnalysisCache cache = new AnalysisCache([partition1, partition2]);
     when(context.analysisCache).thenReturn(cache);
     // configure
     // prepare entries
     ResultDescriptor descriptor1 = new ResultDescriptor('result1', -1);
     ResultDescriptor descriptor2 = new ResultDescriptor('result2', -2);
@@ skipping 10 matching lines @@
     // target2 is listed as dependent in target1
     expect(
         entry1.getResultData(descriptor1).dependentResults, contains(result2));
     // dispose
     partition2.dispose();
     expect(partition1.get(target1), same(entry1));
     expect(partition2.get(target2), isNull);
     // result2 is removed from result1
     expect(entry1.getResultData(descriptor1).dependentResults, isEmpty);
   }
-
-  void test_contains() {
-    UniversalCachePartition partition = new UniversalCachePartition(null);
-    TestSource source = new TestSource();
-    expect(partition.isResponsibleFor(source), isTrue);
-  }
 }
 
 class _InternalAnalysisContextMock extends TypedMock
     implements InternalAnalysisContext {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 class _TestAnalysisTarget implements AnalysisTarget {
   @override
   Source get source => null;
 }