Incrementally resolve users of a changed method.

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 engine.incremental_resolver_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/incremental_logger.dart' as log;
 import 'package:analyzer/src/generated/incremental_resolver.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
 import 'parser_test.dart';
 import 'resolver_test.dart';
 import 'test_support.dart';
 
 
+
 main() {
   groupSep = ' | ';
   runReflectiveTests(DeclarationMatcherTest);
   runReflectiveTests(IncrementalResolverTest);
   runReflectiveTests(PoorMansIncrementalResolutionTest);
   runReflectiveTests(ResolutionContextBuilderTest);
 }
 
 
+void _assertEqualError(AnalysisError incrError, AnalysisError fullError) {
+  expect(incrError.errorCode, same(fullError.errorCode));
+  expect(incrError.source, fullError.source);
+  expect(incrError.offset, fullError.offset);
+  expect(incrError.length, fullError.length);
+  expect(incrError.message, fullError.message);
+}
+
+
+void _assertEqualErrors(List<AnalysisError> incrErrors,
+    List<AnalysisError> fullErrors) {
+  expect(incrErrors, hasLength(fullErrors.length));
+  if (incrErrors.isNotEmpty) {
+    incrErrors.sort((a, b) => a.offset - b.offset);
+  }
+  if (fullErrors.isNotEmpty) {
+    fullErrors.sort((a, b) => a.offset - b.offset);
+  }
+  int length = incrErrors.length;
+  for (int i = 0; i < length; i++) {
+    AnalysisError incrError = incrErrors[i];
+    AnalysisError fullError = fullErrors[i];
+    _assertEqualError(incrError, fullError);
+  }
+}
+
+
 @ReflectiveTestCase()
 class DeclarationMatcherTest extends ResolverTestCase {
   void setUp() {
     super.setUp();
     test_resolveApiChanges = true;
   }
 
   void test_false_class_list_add() {
     _assertDoesNotMatch(r'''
 class A {}
@@ skipping 761 matching lines @@
 }
 ''', r'''
 class A {
   a() {}
   b() {}
 }
 ''');
   }
 
   void test_false_method_parameters_type_edit() {
-    // TODO
     _assertDoesNotMatchOK(r'''
 class A {
   m(int p) {
   }
 }
 ''', r'''
 class A {
   m(String p) {
   }
 }
@@ skipping 1063 matching lines @@
 @ReflectiveTestCase()
 class IncrementalResolverTest extends ResolverTestCase {
   Source source;
   String code;
   LibraryElement library;
   CompilationUnit unit;
 
   void setUp() {
     super.setUp();
     test_resolveApiChanges = true;
+    log.logger = log.NULL_LOGGER;
   }
 
   void test_api_method_edit_returnType() {
     _resolveUnit(r'''
 class A {
   int m() {
     return null;
   }
 }
 main() {
   A a = new A();
-  var v = a.m();
+  int v = a.m();
+  print(v);
 }
 ''');
     _resolve(_editString('int m', 'String m'), _isDeclaration);
     // We don't add or fix an error, but we verify that type of "v"
     // is updated from "int" to "String".
   }
 
   void test_classMemberAccessor_body() {
     _resolveUnit(r'''
 class A {
@@ skipping 309 matching lines @@
     {
       bool success = NodeReplacer.replace(oldNode, newNode);
       expect(success, isTrue);
     }
     // update tokens
     {
       int delta = edit.replacement.length - edit.length;
       _shiftTokens(unit.beginToken, offset, delta);
     }
     // do incremental resolution
+    int updateOffset = edit.offset;
+    int updateEndOld = updateOffset + edit.length;
+    int updateOldNew = updateOffset + edit.replacement.length;
     IncrementalResolver resolver = new IncrementalResolver(
-        typeProvider,
         unit.element,
-        edit.offset,
-        edit.length,
-        edit.replacement.length);
+        updateOffset,
+        updateEndOld,
+        updateOldNew);
     bool success = resolver.resolve(newNode);
     expect(success, isTrue);
+    List<AnalysisError> newErrors = analysisContext.getErrors(source).errors;
     // resolve "newCode" from scratch
     CompilationUnit fullNewUnit;
     {
       source = addSource(newCode);
+      _runTasks();
       LibraryElement library = resolve(source);
       fullNewUnit = resolveCompilationUnit(source, library);
     }
     _SameResolutionValidator.assertSameResolution(unit, fullNewUnit);
+    // errors
+    List<AnalysisError> newFullErrors =
+        analysisContext.getErrors(source).errors;
+    _assertEqualErrors(newErrors, newFullErrors);
+    // prepare for the next cycle
+    code = newCode;
   }
 
   void _resolveUnit(String code) {
     this.code = code;
     source = addSource(code);
     library = resolve(source);
     unit = resolveCompilationUnit(source, library);
+    _runTasks();
+  }
+
+  void _runTasks() {
+    AnalysisResult result = analysisContext.performAnalysisTask();
+    while (result.changeNotices != null) {
+      result = analysisContext.performAnalysisTask();
+    }
   }
 
   static AstNode _findNodeAt(CompilationUnit oldUnit, int offset,
       Predicate<AstNode> predicate) {
     NodeLocator locator = new NodeLocator.con1(offset);
     AstNode node = locator.searchWithin(oldUnit);
     return node.getAncestor(predicate);
   }
 
   static bool _isBlock(AstNode node) => node is Block;
@@ skipping 406 matching lines @@
 
   void test_true_emptyLine_betweenCompilationUnitMembers_remove() {
     _resolveUnit(r'''
 a() {
   print(1)
 }
 
 b() {
   foo(42);
 }
-foo(String p) {};
+foo(String p) {}
 ''');
     _updateAndValidate(r'''
 a() {
   print(1)
 }
 b() {
   foo(42);
 }
-foo(String p) {};
+foo(String p) {}
 ''');
   }
 
   void test_true_wholeConstructor() {
     _resolveUnit(r'''
 class A {
   A(int a) {
     print(a);
   }
 }
@@ skipping 270 matching lines @@
       // Validate that "incremental" and "full" units have the same resolution.
       _SameResolutionValidator.assertSameResolution(newUnit, fullNewUnit);
       _assertEqualTokens(newUnit, fullNewUnit);
       List<AnalysisError> newFullErrors =
           analysisContext.getErrors(source).errors;
       _assertEqualErrors(newErrors, newFullErrors);
       // TODO(scheglov) check line info
     }
   }
 
-  static void _assertEqualError(AnalysisError incrError,
-      AnalysisError fullError) {
-    expect(incrError.errorCode, same(fullError.errorCode));
-    expect(incrError.source, fullError.source);
-    expect(incrError.offset, fullError.offset);
-    expect(incrError.length, fullError.length);
-    expect(incrError.message, fullError.message);
-  }
-
-  static void _assertEqualErrors(List<AnalysisError> incrErrors,
-      List<AnalysisError> fullErrors) {
-    expect(incrErrors, hasLength(fullErrors.length));
-    if (incrErrors.isNotEmpty) {
-      incrErrors.sort((a, b) => a.offset - b.offset);
-    }
-    if (fullErrors.isNotEmpty) {
-      fullErrors.sort((a, b) => a.offset - b.offset);
-    }
-    int length = incrErrors.length;
-    for (int i = 0; i < length; i++) {
-      AnalysisError incrError = incrErrors[i];
-      AnalysisError fullError = fullErrors[i];
-      _assertEqualError(incrError, fullError);
-    }
-  }
-
   static void _assertEqualToken(Token incrToken, Token fullToken) {
     expect(incrToken.type, fullToken.type);
     expect(incrToken.offset, fullToken.offset);
     expect(incrToken.length, fullToken.length);
     expect(incrToken.lexeme, fullToken.lexeme);
   }
 
   static void _assertEqualTokens(CompilationUnit incrUnit,
       CompilationUnit fullUnit) {
     Token incrToken = incrUnit.beginToken;
     Token fullToken = fullUnit.beginToken;
     while (incrToken.type != TokenType.EOF && fullToken.type != TokenType.EOF) {
-//      print('$incrToken @ ${incrToken.offset}');
-//      print('$fullToken @ ${fullToken.offset}');
       _assertEqualToken(incrToken, fullToken);
       // comments
       {
         Token incrComment = incrToken.precedingComments;
         Token fullComment = fullToken.precedingComments;
         while (true) {
           if (fullComment == null) {
             expect(incrComment, isNull);
             break;
           }
@@ skipping 1077 matching lines @@
     _visitList(node.metadata, other.metadata);
     _visitNode(node.identifier, other.identifier);
   }
 
   static void assertSameResolution(CompilationUnit actual,
       CompilationUnit expected) {
     _SameResolutionValidator validator = new _SameResolutionValidator(expected);
     actual.accept(validator);
   }
 }