add source changed event stream

pkg/analyzer/test/generated/engine_test.dart

Index: pkg/analyzer/test/generated/engine_test.dart
diff --git a/pkg/analyzer/test/generated/engine_test.dart b/pkg/analyzer/test/generated/engine_test.dart
index 04fc0d2c77002e8c223b0d0bb760255e5aad9e55..abe57a40b2212c2972ab629772fdc5765035122d 100644
--- a/pkg/analyzer/test/generated/engine_test.dart
+++ b/pkg/analyzer/test/generated/engine_test.dart
@@ -7,6 +7,7 @@
 
 library engine.engine_test;
 
+import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
@@ -30,6 +31,7 @@ import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/task_dart.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
+import 'package:watcher/src/utils.dart';
 
 import '../reflective_tests.dart';
 import 'all_the_rest.dart';
@@ -224,10 +226,66 @@ class AnalysisContextImplTest extends EngineTestCase {
     super.tearDown();
   }
 
-  void test_applyChanges_add() {
+  Future test_applyChanges_add() {
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
-    Source source = _addSource("/test.dart", "main() {}");
+    Source source =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet = new ChangeSet();
+    changeSet.addedSource(source);
+    _context.applyChanges(changeSet);
+    expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    return pumpEventQueue().then((_) {
+      listener.assertChangeSet(changeSet);
+      listener.assertNoMoreEvents();
+    });
+  }
+
+  Future test_applyChanges_change() {
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
+    expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
+    Source source =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet1 = new ChangeSet();
+    changeSet1.addedSource(source);
+    _context.applyChanges(changeSet1);
+    expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    Source source2 =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    ChangeSet changeSet2 = new ChangeSet();
+    changeSet2.addedSource(source2);
+    changeSet2.changedSource(source);
+    _context.applyChanges(changeSet2);
+    return pumpEventQueue().then((_) {
+      listener.assertChangeSet(changeSet1);
+      listener.assertChangeSet(changeSet2);
+      listener.assertNoMoreEvents();
+    });
+  }
+
+  Future test_applyChanges_change_content() {
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
+    expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
+    Source source =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet1 = new ChangeSet();
+    changeSet1.addedSource(source);
+    _context.applyChanges(changeSet1);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    Source source2 =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    ChangeSet changeSet2 = new ChangeSet();
+    changeSet2.addedSource(source2);
+    changeSet2.changedContent(source, 'library test;');
+    _context.applyChanges(changeSet2);
+    return pumpEventQueue().then((_) {
+      listener.assertChangeSet(changeSet1);
+      listener.assertChangeSet(changeSet2);
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_applyChanges_change_flush_element() {
@@ -243,24 +301,30 @@ int aa = 0;''');
     expect(_context.getLibraryElement(librarySource), isNull);
   }
 
-  void test_applyChanges_change_multiple() {
+  Future test_applyChanges_change_multiple() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", r'''
+    String libraryContents1 = r'''
 library lib;
 part 'part.dart';
-int a = 0;''');
-    Source partSource = _addSource("/part.dart", r'''
+int a = 0;''';
+    Source librarySource = _addSource("/lib.dart", libraryContents1);
+    String partContents1 = r'''
 part of lib;
-int b = a;''');
+int b = a;''';
+    Source partSource = _addSource("/part.dart", partContents1);
     _context.computeLibraryElement(librarySource);
-    _context.setContents(librarySource, r'''
+    String libraryContents2 = r'''
 library lib;
 part 'part.dart';
-int aa = 0;''');
-    _context.setContents(partSource, r'''
+int aa = 0;''';
+    _context.setContents(librarySource, libraryContents2);
+    String partContents2 = r'''
 part of lib;
-int b = aa;''');
+int b = aa;''';
+    _context.setContents(partSource, partContents2);
     _context.computeLibraryElement(librarySource);
     CompilationUnit libraryUnit =
         _context.resolveCompilationUnit2(librarySource, librarySource);
@@ -276,6 +340,46 @@ int b = aa;''');
     expect(
         (useElement as PropertyAccessorElement).variable,
         same(declarationElement));
+    return pumpEventQueue().then((_) {
+      listener.assertChanges(added: [librarySource]);
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents1
+      });
+      listener.assertChanges(added: [partSource]);
+      listener.assertChanges(changedContents: {
+        partSource: partContents1
+      });
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents2
+      });
+      listener.assertChanges(changedContents: {
+        partSource: partContents2
+      });
+      listener.assertNoMoreEvents();
+    });
+  }
+
+  Future test_applyChanges_change_range() {
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
+    expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
+    Source source =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    ChangeSet changeSet1 = new ChangeSet();
+    changeSet1.addedSource(source);
+    _context.applyChanges(changeSet1);
+    expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
+    Source source2 =
+        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    ChangeSet changeSet2 = new ChangeSet();
+    changeSet2.addedSource(source2);
+    changeSet2.changedRange(source, 'library test;', 0, 0, 13);
+    _context.applyChanges(changeSet2);
+    return pumpEventQueue().then((_) {
+      listener.assertChangeSet(changeSet1);
+      listener.assertChangeSet(changeSet2);
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_applyChanges_empty() {
@@ -298,13 +402,17 @@ int b = aa;''');
     expect(_context.sourcesNeedingProcessing, hasLength(0));
   }
 
-  void test_applyChanges_remove() {
+  Future test_applyChanges_remove() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source libA = _addSource("/libA.dart", r'''
+    String libAContents = r'''
 library libA;
-import 'libB.dart';''');
-    Source libB = _addSource("/libB.dart", "library libB;");
+import 'libB.dart';''';
+    Source libA = _addSource("/libA.dart", libAContents);
+    String libBContents = "library libB;";
+    Source libB = _addSource("/libB.dart", libBContents);
     LibraryElement libAElement = _context.computeLibraryElement(libA);
     List<LibraryElement> importedLibraries = libAElement.importedLibraries;
     expect(importedLibraries, hasLength(2));
@@ -319,26 +427,58 @@ import 'libB.dart';''');
     libAElement = _context.computeLibraryElement(libA);
     importedLibraries = libAElement.importedLibraries;
     expect(importedLibraries, hasLength(1));
+    return pumpEventQueue().then((_) {
+      listener.assertChanges(added: [libA]);
+      listener.assertChanges(changedContents: {
+        libA: libAContents
+      });
+      listener.assertChanges(added: [libB]);
+      listener.assertChanges(changedContents: {
+        libB: libBContents
+      });
+      listener.assertChanges(changedContents: {
+        libB: null
+      });
+      listener.assertChanges(removedSources: [libB]);
+      listener.assertNoMoreEvents();
+    });
   }
 
-  void test_applyChanges_removeContainer() {
+  Future test_applyChanges_removeContainer() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source libA = _addSource("/libA.dart", r'''
+    String libAContents = r'''
 library libA;
-import 'libB.dart';''');
-    Source libB = _addSource("/libB.dart", "library libB;");
+import 'libB.dart';''';
+    Source libA = _addSource("/libA.dart", libAContents);
+    String libBContents = "library libB;";
+    Source libB = _addSource("/libB.dart", libBContents);
     _context.computeLibraryElement(libA);
     _context.computeErrors(libA);
     _context.computeErrors(libB);
     expect(_context.sourcesNeedingProcessing, hasLength(0));
     ChangeSet changeSet = new ChangeSet();
-    changeSet.removedContainer(
-        new _AnalysisContextImplTest_test_applyChanges_removeContainer(libB));
+    SourceContainer removedContainer =
+        new _AnalysisContextImplTest_test_applyChanges_removeContainer(libB);
+    changeSet.removedContainer(removedContainer);
     _context.applyChanges(changeSet);
     List<Source> sources = _context.sourcesNeedingProcessing;
     expect(sources, hasLength(1));
     expect(sources[0], same(libA));
+    return pumpEventQueue().then((_) {
+      listener.assertChanges(added: [libA]);
+      listener.assertChanges(changedContents: {
+        libA: libAContents
+      });
+      listener.assertChanges(added: [libB]);
+      listener.assertChanges(changedContents: {
+        libB: libBContents
+      });
+      listener.assertChanges(removedContainers: [removedContainer]);
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_computeDocumentationComment_block() {
@@ -1625,19 +1765,22 @@ void g() { f(null); }''');
     _context.analysisPriorityOrder = sources;
   }
 
-  void test_setChangedContents_libraryWithPart() {
+  Future test_setChangedContents_libraryWithPart() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.incremental = true;
     _context = AnalysisContextFactory.contextWithCoreAndOptions(options);
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
     String oldCode = r'''
 library lib;
 part 'part.dart';
 int a = 0;''';
     Source librarySource = _addSource("/lib.dart", oldCode);
-    Source partSource = _addSource("/part.dart", r'''
+    String partContents = r'''
 part of lib;
-int b = a;''');
+int b = a;''';
+    Source partSource = _addSource("/part.dart", partContents);
     LibraryElement element = _context.computeLibraryElement(librarySource);
     CompilationUnit unit =
         _context.getResolvedCompilationUnit(librarySource, element);
@@ -1658,6 +1801,20 @@ int ya = 0;''';
         _context.getResolvedCompilationUnit2(partSource, librarySource),
         isNull);
     expect(incrementalCache.newContents, newCode);
+    return pumpEventQueue().then((_) {
+      listener.assertChanges(added: [librarySource]);
+      listener.assertChanges(changedContents: {
+        librarySource: oldCode
+      });
+      listener.assertChanges(added: [partSource]);
+      listener.assertChanges(changedContents: {
+        partSource: partContents
+      });
+      listener.assertChanges(changedRanges: {
+        librarySource: new ChangeSet_ContentChange(newCode, offset, 0, 1)
+      });
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_setChangedContents_notResolved() {
@@ -1680,16 +1837,20 @@ int ya = 0;''';
     expect(_getIncrementalAnalysisCache(_context), isNull);
   }
 
-  void test_setContents_libraryWithPart() {
+  Future test_setContents_libraryWithPart() {
     _context = AnalysisContextFactory.contextWithCore();
+    SourcesChangedListener listener = new SourcesChangedListener();
+    _context.onSourcesChanged.listen(listener.onData);
     _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", r'''
+    String libraryContents1 = r'''
 library lib;
 part 'part.dart';
-int a = 0;''');
-    Source partSource = _addSource("/part.dart", r'''
+int a = 0;''';
+    Source librarySource = _addSource("/lib.dart", libraryContents1);
+    String partContents1 = r'''
 part of lib;
-int b = a;''');
+int b = a;''';
+    Source partSource = _addSource("/part.dart", partContents1);
     _context.computeLibraryElement(librarySource);
     IncrementalAnalysisCache incrementalCache = new IncrementalAnalysisCache(
         librarySource,
@@ -1702,14 +1863,29 @@ int b = a;''');
         0);
     _setIncrementalAnalysisCache(_context, incrementalCache);
     expect(_getIncrementalAnalysisCache(_context), same(incrementalCache));
-    _context.setContents(librarySource, r'''
+    String libraryContents2 = r'''
 library lib;
 part 'part.dart';
-int aa = 0;''');
+int aa = 0;''';
+    _context.setContents(librarySource, libraryContents2);
     expect(
         _context.getResolvedCompilationUnit2(partSource, librarySource),
         isNull);
     expect(_getIncrementalAnalysisCache(_context), isNull);
+    return pumpEventQueue().then((_) {
+      listener.assertChanges(added: [librarySource]);
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents1
+      });
+      listener.assertChanges(added: [partSource]);
+      listener.assertChanges(changedContents: {
+        partSource: partContents1
+      });
+      listener.assertChanges(changedContents: {
+        librarySource: libraryContents2
+      });
+      listener.assertNoMoreEvents();
+    });
   }
 
   void test_setContents_null() {
@@ -6010,6 +6186,76 @@ class SdkCachePartitionTest extends EngineTestCase {
 }
 
 
+class SourcesChangedListener {
+  static const Map<Source, String> EMPTY_CONTENTS_MAP = const {};
+  static const Map<Source, ChangeSet_ContentChange> EMPTY_RANGE_MAP = const {};
+  static const List<SourceContainer> EMPTY_CONTAINER_LIST = const [];
+
+  List<ChangeSet> actualChangeSets = [];
+
+  void assertChanges({List<Source> added: Source.EMPTY_ARRAY,
+      List<Source> changedSources: Source.EMPTY_ARRAY, Map<Source,
+      String> changedContents: EMPTY_CONTENTS_MAP, Map<Source,
+      ChangeSet_ContentChange> changedRanges: EMPTY_RANGE_MAP,
+      List<Source> removedSources: Source.EMPTY_ARRAY,
+      List<SourceContainer> removedContainers: EMPTY_CONTAINER_LIST}) {
+    if (actualChangeSets.isEmpty) {
+      fail('Expected event but found none');
+    }
+    ChangeSet actual = actualChangeSets.removeAt(0);
+    expect(actual.addedSources, added, reason: 'addedSources do not match');
+    expect(
+        actual.changedSources,
+        changedSources,
+        reason: 'changedSources do not match');
+    expect(
+        actual.changedContents,
+        changedContents,
+        reason: 'changedContents do no match');
+
+    HashMap<Source, ChangeSet_ContentChange> actualChangedRanges =
+        actual.changedRanges;
+    Map<Source, ChangeSet_ContentChange> expectedChangedRanges = changedRanges;
+    _expectEqualChangedRanges(actualChangedRanges, expectedChangedRanges);
+
+    expect(actual.deletedSources, []);
+    expect(actual.removedContainers, removedContainers);
+    expect(
+        actual.removedSources,
+        removedSources,
+        reason: 'removedSources do not match');
+  }
+
+  void assertChangeSet(ChangeSet expected) {
+    if (actualChangeSets.isEmpty) {
+      fail('Expected event but found none');
+    }
+    ChangeSet actual = actualChangeSets.removeAt(0);
+    expect(actual, expected);
+  }
+
+  void assertNoMoreEvents() {
+    expect(actualChangeSets, []);
+  }
+
+  void onData(ChangeSet event) {
+    actualChangeSets.add(event);
+  }
+
+  void _expectEqualChangedRanges(Map<Source, ChangeSet_ContentChange> actual,
+      Map<Source, ChangeSet_ContentChange> expected) {
+    expect(actual, hasLength(expected.length));
+    expected.forEach((Source source, ChangeSet_ContentChange expectedChange) {
+      ChangeSet_ContentChange actualChange = actual[source];
+      expect(actualChange.contents, expectedChange.contents);
+      expect(actualChange.offset, expectedChange.offset);
+      expect(actualChange.oldLength, expectedChange.oldLength);
+      expect(actualChange.newLength, expectedChange.newLength);
+    });
+  }
+}
+
+
 /**
  * Instances of the class `TestAnalysisContext` implement an analysis context in which every
  * method will cause a test to fail when invoked.
@@ -6059,6 +6305,11 @@ class TestAnalysisContext implements InternalAnalysisContext {
     return null;
   }
   @override
+  Stream<ChangeSet> get onSourcesChanged {
+    fail("Unexpected invocation of onSourcesChanged");
+    return null;
+  }
+  @override
   List<Source> get prioritySources {
     fail("Unexpected invocation of getPrioritySources");
     return null;