Validate cache results in incremental resolution tests.

pkg/analyzer/test/generated/incremental_resolver_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.generated.incremental_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
@@ skipping 3593 matching lines @@
   }
 
   void test_computeConstants() {
     _resolveUnit(r'''
 int f() => 0;
 main() {
   const x = f();
   print(x + 1);
 }
 ''');
-    _updateAndValidate(r'''
+    _updateAndValidate(
+        r'''
 int f() => 0;
 main() {
   const x = f();
   print(x + 2);
 }
-''');
+''',
+        expectCachePostConstantsValid: false);
   }
 
   void test_dartDoc_beforeField() {
     _resolveUnit(r'''
 class A {
   /**
    * A field [field] of type [int] in class [A].
    */
   int field;
 }
@@ skipping 568 matching lines @@
   const B();
 }
 
 main() {
   print(123);
   A.b;
 }
 ''');
   }
 
+  void test_hasElementAfter_defaultParameter() {
+    _resolveUnit(r'''
+main() {
+  print(1);
+}
+otherFunction([p = 0]) {}
+''');
+    _updateAndValidate(r'''
+main() {
+  print(2);
+}
+otherFunction([p = 0]) {}
+''');
+  }
+
   void test_inBody_expression() {
     _resolveUnit(r'''
 class A {
   m() {
     print(1);
   }
 }
 ''');
     _updateAndValidate(r'''
 class A {
@@ skipping 324 matching lines @@
     List<AnalysisError> errors = analysisContext.getErrors(source).errors;
     expect(errors, isEmpty);
   }
 
   void test_updateConstantInitializer() {
     _resolveUnit(r'''
 main() {
   const v = const [Unknown];
 }
 ''');
-    _updateAndValidate(r'''
+    _updateAndValidate(
+        r'''
 main() {
    const v = const [Unknown];
 }
-''');
+''',
+        expectCachePostConstantsValid: false);
   }
 
   void test_updateErrors_addNew_hint1() {
     _resolveUnit(r'''
 int main() {
   return 42;
 }
 ''');
     _updateAndValidate(r'''
 int main() {
@@ skipping 253 matching lines @@
     {
       ClassElement typeA = oldUnitElement.getType('A');
       expect(oldUnitElement.getElementAt(typeA.nameOffset), typeA);
     }
     {
       ClassElement typeB = oldUnitElement.getType('B');
       expect(oldUnitElement.getElementAt(typeB.nameOffset), typeB);
     }
   }
 
+  void _assertCacheResults({bool expectCachePostConstantsValid: true}) {
+    _assertCacheSourceResult(PARSED_UNIT);
+    _assertCacheSourceResult(PARSE_ERRORS);
+    _assertCacheSourceResult(LIBRARY_ELEMENT1);
+    _assertCacheSourceResult(LIBRARY_ELEMENT2);
+    _assertCacheSourceResult(LIBRARY_ELEMENT3);
+    _assertCacheSourceResult(LIBRARY_ELEMENT4);
+    _assertCacheSourceResult(LIBRARY_ELEMENT5);
+    _assertCacheSourceResult(LIBRARY_ELEMENT6);
+    _assertCacheSourceResult(LIBRARY_ELEMENT7);
+    _assertCacheSourceResult(LIBRARY_ELEMENT8);
+    if (expectCachePostConstantsValid) {
+      _assertCacheSourceResult(LIBRARY_ELEMENT);
+    }
+    _assertCacheUnitResult(RESOLVED_UNIT1);
+    _assertCacheUnitResult(RESOLVED_UNIT2);
+    _assertCacheUnitResult(RESOLVED_UNIT3);
+    _assertCacheUnitResult(RESOLVED_UNIT4);
+    _assertCacheUnitResult(RESOLVED_UNIT5);
+    _assertCacheUnitResult(RESOLVED_UNIT6);
+    _assertCacheUnitResult(RESOLVED_UNIT7);
+    _assertCacheUnitResult(RESOLVED_UNIT8);
+    _assertCacheUnitResult(RESOLVED_UNIT9);
+    _assertCacheUnitResult(RESOLVED_UNIT10);
+    if (expectCachePostConstantsValid) {
+      _assertCacheUnitResult(RESOLVED_UNIT11);
+      _assertCacheUnitResult(RESOLVED_UNIT);
+    }
+  }
+
+  /**
+   * Assert that the [result] of [source] is not INVALID.
+   */
+  void _assertCacheSourceResult(ResultDescriptor result) {
+    AnalysisCache cache = analysisContext2.analysisCache;
+    CacheState state = cache.getState(source, result);
+    expect(state, isNot(CacheState.INVALID), reason: result.toString());
+  }
+
+  /**
+   * Assert that the [result] of the defining unit [source] is not INVALID.
+   */
+  void _assertCacheUnitResult(ResultDescriptor result) {
+    AnalysisCache cache = analysisContext2.analysisCache;
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    CacheState state = cache.getState(target, result);
+    expect(state, isNot(CacheState.INVALID), reason: result.toString());
+  }
+
   void _assertEqualLineInfo(LineInfo incrLineInfo, LineInfo fullLineInfo) {
     for (int offset = 0; offset < 1000; offset++) {
       LineInfo_Location incrLocation = incrLineInfo.getLocation(offset);
       LineInfo_Location fullLocation = fullLineInfo.getLocation(offset);
       if (incrLocation.lineNumber != fullLocation.lineNumber ||
           incrLocation.columnNumber != fullLocation.columnNumber) {
         fail('At offset $offset ' +
             '(${incrLocation.lineNumber}, ${incrLocation.columnNumber})' +
             ' != ' +
             '(${fullLocation.lineNumber}, ${fullLocation.columnNumber})');
@@ skipping 23 matching lines @@
 
   void _runTasks() {
     AnalysisResult result = analysisContext.performAnalysisTask();
     while (result.changeNotices != null) {
       result = analysisContext.performAnalysisTask();
     }
   }
 
   void _updateAndValidate(String newCode,
       {bool expectedSuccess: true,
+      bool expectCachePostConstantsValid: true,
       bool compareWithFull: true,
       bool runTasksBeforeIncremental: true}) {
     // Run any pending tasks tasks.
     if (runTasksBeforeIncremental) {
       _runTasks();
     }
     // Update the source - currently this may cause incremental resolution.
     // Then request the updated resolved unit.
     _resetWithIncremental(true);
     analysisContext2.setContents(source, newCode);
     CompilationUnit newUnit = resolveCompilationUnit(source, oldLibrary);
     expect(logger.hasError, isFalse);
     List<AnalysisError> newErrors = analysisContext.computeErrors(source);
     LineInfo newLineInfo = analysisContext.getLineInfo(source);
     // check for expected failure
     if (!expectedSuccess) {
       expect(newUnit.element, isNot(same(oldUnitElement)));
       return;
     }
+    // The cache must still have enough results to make the incremental
+    // resolution useful.
+    _assertCacheResults(
+        expectCachePostConstantsValid: expectCachePostConstantsValid);
     // The existing CompilationUnit[Element] should be updated.
     expect(newUnit, same(oldUnit));
     expect(newUnit.element, same(oldUnitElement));
     expect(analysisContext.getResolvedCompilationUnit(source, oldLibrary),
         same(oldUnit));
     // The only expected pending task should return the same resolved
     // "newUnit", so all clients will get it using the usual way.
     AnalysisResult analysisResult = analysisContext.performAnalysisTask();
     ChangeNotice notice = analysisResult.changeNotices[0];
     expect(notice.resolvedDartUnit, same(newUnit));
@@ skipping 289 matching lines @@
   @override
   void logException(Object exception, [Object stackTrace]) {
     hasError = true;
   }
 
   @override
   logging.LoggingTimer startTimer() {
     return new logging.LoggingTimer(this);
   }
 }