Keep more analysis results that don't change when a source is changed.

pkg/analyzer/test/src/context/context_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.
 
 library analyzer.test.src.context.context_test;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 2691 matching lines @@
     //   This makes B changed.
     //   b.dart is invalid, because it references B.
     context.setContents(
         a,
         r'''
 class A {
   m2() {}
 }
 class B extends A {}
 ''');
+    _assertValidForChangedLibrary(a);
+    _assertValidForDependentLibrary(b);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
   }
 
   void test_class_private_member() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {
   A();
@@ skipping 26 matching lines @@
   A._privateConstructor2();
 
   foo() {}
 
   int _privateField2;
   _privateMethod2() {}
   int get _privateGetter2 => null;
   void set _privateSetter2(_) {}
 }
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
+    _assertValidAllLibraryUnitResults(b);
     _assertValid(b, LIBRARY_ERRORS_READY);
   }
 
   void test_private_class() {
     Source a = addSource(
         '/a.dart',
         r'''
 class _A {}
 class _B2 {}
 ''');
     Source b = addSource(
         '/b.dart',
         r'''
 import 'a.dart';
 main() {
   new _A();
   new _B();
 }
 ''');
     _performPendingAnalysisTasks();
     // Update a.dart: change _A and _B2
     //   b.dart is valid, because _A, _B, _A2 and _B2 are all private,
     //   so b.dart cannot see them.
     context.setContents(
         a,
         r'''
 class _A2 {}
 class _B {}
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
+    _assertValidAllLibraryUnitResults(b);
     _assertValid(b, LIBRARY_ERRORS_READY);
   }
 
   void test_private_topLevelVariable() {
     Source a = addSource(
         '/a.dart',
         r'''
 int _V = 1;
 ''');
     Source b = addSource(
         '/b.dart',
         r'''
 import 'a.dart';
 main() {
   print(_V);
 }
 ''');
     _performPendingAnalysisTasks();
     // Update a.dart: change _V
     //   b.dart is valid, because _V is private and b.dart cannot see it.
     context.setContents(
         a,
         r'''
 int _V = 2;
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
+    _assertValidAllLibraryUnitResults(b);
     _assertValid(b, LIBRARY_ERRORS_READY);
   }
 
   void test_sequence_class_give_take() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {}
 class B {}
 class C {}
@@ skipping 11 matching lines @@
     expect(context.getErrors(b).errors, hasLength(1));
     // Update a.dart: remove C, add C2.
     //   b.dart is invalid, because it references C2.
     context.setContents(
         a,
         r'''
 class A {}
 class B {}
 class C2 {}
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
-    _assertUnitInvalid(b, RESOLVED_UNIT);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
     // Now b.dart is analyzed and the error is fixed.
     _performPendingAnalysisTasks();
     expect(context.getErrors(b).errors, hasLength(0));
     // Update a.dart: remove C2, add C.
     //   b.dart is invalid, because it references C2.
     context.setContents(
         a,
         r'''
 class A {}
 class B {}
 class C {}
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
     // Now b.dart is analyzed and it again has the error.
     _performPendingAnalysisTasks();
     expect(context.getErrors(b).errors, hasLength(1));
   }
 
   void test_sequence_noChange_thenChange() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {
@@ skipping 22 matching lines @@
     context.setContents(
         a,
         r'''
 class A {
   A();
 }
 class B {
   B();
 }
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
-    _assertValid(b, LIBRARY_ELEMENT);
+    _assertValidForDependentLibrary(b);
+    _assertValidAllLibraryUnitResults(b);
+    _assertValid(b, LIBRARY_ERRORS_READY);
     // The a.dart's unit and element are updated incrementally.
     // They are the same instances as initially.
     // So, all the references from other units are still valid.
     {
       LibrarySpecificUnit target = new LibrarySpecificUnit(a, a);
       expect(analysisCache.getValue(target, RESOLVED_UNIT1), same(unitA));
       expect(unitA.element, same(unitElementA));
       expect(unitElementA.library, same(libraryElementA));
     }
     // Analyze.
@@ skipping 13 matching lines @@
         a,
         r'''
 class A {
   A();
   m() {}
 }
 class B {
   B();
 }
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
-    _assertInvalid(b, LIBRARY_ELEMENT);
+    _assertValidForDependentLibrary(b);
+    _assertInvalid(b, LIBRARY_ERRORS_READY);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
     // The a.dart's unit and element are the same.
     {
       LibrarySpecificUnit target = new LibrarySpecificUnit(a, a);
       expect(analysisCache.getValue(target, RESOLVED_UNIT1), same(unitA));
       expect(unitA.element, same(unitElementA));
       expect(unitElementA.library, same(libraryElementA));
     }
     // Analyze.
     _performPendingAnalysisTasks();
     expect(context.getErrors(a).errors, hasLength(0));
@@ skipping 23 matching lines @@
     entryA.setState(RESOLVED_UNIT, CacheState.FLUSHED);
     entryA.setState(RESOLVED_UNIT1, CacheState.FLUSHED);
     entryA.setState(RESOLVED_UNIT2, CacheState.FLUSHED);
     entryA.setState(RESOLVED_UNIT3, CacheState.FLUSHED);
     context.setContents(
         a,
         r'''
 class A {}
 class B2 {}
 ''');
+    _assertValidAllLibraryUnitResults(b);
     _assertValid(b, LIBRARY_ERRORS_READY);
   }
 
   void test_unusedName_class_add() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {}
 class B {}
 class C {}
@@ skipping 12 matching lines @@
     // The class B is not referenced.
     //   a.dart is invalid.
     //   b.dart is valid.
     context.setContents(
         a,
         r'''
 class A {}
 class B2 {}
 class C {}
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
-    _assertValid(a, LINE_INFO);
-    _assertUnitValid(a, RESOLVED_UNIT1);
     _assertUnitInvalid(a, RESOLVED_UNIT);
+    _assertValidForDependentLibrary(b);
+    _assertValidAllLibraryUnitResults(b);
     _assertValid(b, LIBRARY_ERRORS_READY);
-    _assertUnitValid(b, RESOLVED_UNIT);
   }
 
   void test_usedName_class_name_asHole_inBody() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {}
 class B {}
 class C {}
 ''');
     Source b = addSource(
         '/b.dart',
         r'''
 import 'a.dart';
 main() {
   new A();
   new C2();
 }
 ''');
     _performPendingAnalysisTasks();
     // Update a.dart: remove C, add C2.
     //   b.dart is invalid, because it references C2.
     context.setContents(
         a,
         r'''
 class A {}
 class B {}
 class C2 {}
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
-    _assertInvalidUnits(b, RESOLVED_UNIT2);
-    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT2);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
   }
 
   void test_usedName_class_name_asSuper() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {}
 ''');
     Source b = addSource(
         '/b.dart',
         r'''
 import 'a.dart';
 class B extends A {}
 ''');
     _performPendingAnalysisTasks();
     // Update a.dart: remove A, add A2.
     //   b.dart is invalid, because it references A.
     context.setContents(
         a,
         r'''
 class A2 {}
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
-    _assertInvalidUnits(b, RESOLVED_UNIT2);
-    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT2);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
   }
 
   void test_usedName_class_name_asTypeBound() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {}
 ''');
     Source b = addSource(
         '/b.dart',
         r'''
 import 'a.dart';
 class B<T extends A> {
   T f;
 }
 ''');
     _performPendingAnalysisTasks();
     // Update a.dart: remove A, add A2.
     //   b.dart is invalid, because it references A.
     context.setContents(
         a,
         r'''
 class A2 {}
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
-    _assertInvalidUnits(b, RESOLVED_UNIT2);
-    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT2);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
   }
 
   void test_usedName_class_name_inBody() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {}
 class B {}
 class C {}
 ''');
     Source b = addSource(
         '/b.dart',
         r'''
 import 'a.dart';
 main() {
   new A();
   new C();
 }
 ''');
     _performPendingAnalysisTasks();
     // Update a.dart: remove C, add C2.
     //   b.dart is invalid, because it references C.
     context.setContents(
         a,
         r'''
 class A {}
 class B {}
 class C2 {}
 ''');
+    _assertValidForChangedLibrary(a);
+    _assertValidForDependentLibrary(b);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
-    _assertInvalidUnits(b, RESOLVED_UNIT2);
-    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT2);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
   }
 
   void test_usedName_classMethod_name_inBody() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {
   m() {}
 }
 ''');
     Source b = addSource(
         '/b.dart',
         r'''
 import 'a.dart';
 main() {
   A a = new A();
   a.m();
 }
 ''');
     _performPendingAnalysisTasks();
     // Update a.dart: remove C.m, add C.m2.
     //   b.dart is invalid, because it references c.m.
     context.setContents(
         a,
         r'''
 class A {
   m2() {}
 }
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+    _assertValidForDependentLibrary(b);
+    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT4);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
-    _assertInvalidUnits(b, RESOLVED_UNIT2);
-    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT2);
   }
 
   void test_usedName_indirect_classMethod_name_inBody() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {
   m() {}
 }
 ''');
@@ skipping 16 matching lines @@
     // Update a.dart: remove C.m, add C.m2.
     //   b.dart is invalid, because B extends A.
     //   c.dart is invalid, because 'main' references B.
     context.setContents(
         a,
         r'''
 class A {
   m2() {}
 }
 ''');
+    _assertValidForChangedLibrary(a);
     _assertInvalid(a, LIBRARY_ERRORS_READY);
+
+    _assertValidForDependentLibrary(b);
+    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT4);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
     _assertInvalid(b, LIBRARY_ERRORS_READY);
+
+    _assertValidForDependentLibrary(c);
+    _assertInvalidLibraryElements(c, LIBRARY_ELEMENT5);
+    _assertInvalidUnits(c, RESOLVED_UNIT4);
     _assertInvalid(c, LIBRARY_ERRORS_READY);
-    _assertInvalidUnits(b, RESOLVED_UNIT2);
-    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT2);
-    _assertInvalidUnits(c, RESOLVED_UNIT4);
-    _assertInvalidLibraryElements(c, LIBRARY_ELEMENT5);
   }
 
   void test_usedName_indirect_classMethod_returnType_inBody() {
     Source a = addSource(
         '/a.dart',
         r'''
 class A {
   int m() {
     return 1;
   }
@@ skipping 21 matching lines @@
     context.setContents(
         a,
         r'''
 class A {
   double m() {
     return 1.2;
   }
 }
 ''');
     _assertInvalid(a, LIBRARY_ERRORS_READY);
-    _assertInvalid(b, LIBRARY_ERRORS_READY);
-    _assertInvalid(c, LIBRARY_ERRORS_READY);
+
     // TODO(scheglov) In theory b.dart is not affected, because it does not
     // call A.m, does not override it, etc.
-    _assertInvalidUnits(b, RESOLVED_UNIT2);
-    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT2);
+    _assertValidForDependentLibrary(b);
+    _assertInvalidLibraryElements(b, LIBRARY_ELEMENT4);
+    _assertInvalidUnits(b, RESOLVED_UNIT4);
+    _assertInvalid(b, LIBRARY_ERRORS_READY);
+
+    _assertValidForDependentLibrary(c);
+    _assertInvalidLibraryElements(c, LIBRARY_ELEMENT5);
     _assertInvalidUnits(c, RESOLVED_UNIT4);
-    _assertInvalidLibraryElements(c, LIBRARY_ELEMENT5);
+    _assertInvalid(c, LIBRARY_ERRORS_READY);
   }
 
   void _assertInvalid(AnalysisTarget target, ResultDescriptor descriptor) {
     CacheState actual = analysisCache.getState(target, descriptor);
     if (actual != CacheState.INVALID) {
       fail("cache state of $target $descriptor: wanted INVALID, got: $actual");
     }
   }
 
   /**
@@ skipping 29 matching lines @@
         new LibrarySpecificUnit(librarySource, unitSource), descriptor);
   }
 
   void _assertUnitValid(Source unitSource, ResultDescriptor descriptor,
       {Source librarySource}) {
     librarySource ??= unitSource;
     _assertValid(
         new LibrarySpecificUnit(librarySource, unitSource), descriptor);
   }
 
+  void _assertUnitValidTaskResults(Source unitSource, TaskDescriptor descriptor,
+      {Source librarySource}) {
+    librarySource ??= unitSource;
+    for (ResultDescriptor result in descriptor.results) {
+      _assertUnitValid(unitSource, result, librarySource: librarySource);
+    }
+  }
+
   void _assertValid(AnalysisTarget target, ResultDescriptor descriptor) {
     CacheState state = analysisCache.getState(target, descriptor);
-    expect(state, CacheState.VALID, reason: '$descriptor in $target');
+    expect(state, isIn([CacheState.VALID, CacheState.FLUSHED]),
+        reason: '$descriptor in $target');
+  }
+
+  void _assertValidAllLibraryUnitResults(Source source, {Source library}) {
+    for (ResultDescriptor<LibraryElement> result in LIBRARY_ELEMENT_RESULTS) {
+      _assertValid(source, result);
+    }
+    library ??= source;
+    LibrarySpecificUnit target = new LibrarySpecificUnit(library, source);
+    for (ResultDescriptor<CompilationUnit> result in RESOLVED_UNIT_RESULTS) {
+      _assertValid(target, result);
+    }
+  }
+
+  void _assertValidForAnyLibrary(Source source) {
+    // Source results.
+    _assertValidTaskResults(source, ScanDartTask.DESCRIPTOR);
+    // Library results.
+    _assertValidTaskResults(source, BuildLibraryElementTask.DESCRIPTOR);
+    _assertValidTaskResults(source, BuildDirectiveElementsTask.DESCRIPTOR);
+    _assertValidTaskResults(source, BuildSourceExportClosureTask.DESCRIPTOR);
+    _assertValidTaskResults(source, ReadyLibraryElement2Task.DESCRIPTOR);
+    // Unit results.
+    _assertUnitValidTaskResults(
+        source, BuildCompilationUnitElementTask.DESCRIPTOR);
+    _assertUnitValidTaskResults(
+        source, ResolveDirectiveElementsTask.DESCRIPTOR);
+    _assertUnitValidTaskResults(source, BuildEnumMemberElementsTask.DESCRIPTOR);
+    _assertUnitValidTaskResults(source, ComputeLibraryCycleTask.DESCRIPTOR);
+  }
+
+  void _assertValidForChangedLibrary(Source source) {
+    _assertValidForAnyLibrary(source);
+  }
+
+  void _assertValidForDependentLibrary(Source source) {
+    _assertValidForAnyLibrary(source);
+    // Library results.
+    _assertValidTaskResults(source, BuildPublicNamespaceTask.DESCRIPTOR);
+  }
+
+  void _assertValidTaskResults(AnalysisTarget target, TaskDescriptor task) {
+    for (ResultDescriptor result in task.results) {
+      _assertValid(target, result);
+    }
   }
 
   void _performPendingAnalysisTasks([int maxTasks = 512]) {
     for (int i = 0; context.performAnalysisTask().hasMoreWork; i++) {
       if (i > maxTasks) {
         fail('Analysis did not terminate.');
       }
     }
   }
 }
@@ skipping 98 matching lines @@
    * Initialize the visitor.
    */
   _ElementGatherer();
 
   @override
   void visitElement(Element element) {
     elements[element] = element;
     super.visitElement(element);
   }
 }