Update errors during incremental resolution.

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';
@@ skipping 1725 matching lines @@
     {
       int delta = edit.replacement.length - edit.length;
       _shiftTokens(unit.beginToken, offset, delta);
     }
     // replace the node
     AstNode oldNode = _findNodeAt(unit, offset, predicate);
     AstNode newNode = _findNodeAt(newUnit, offset, predicate);
     bool success = NodeReplacer.replace(oldNode, newNode);
     expect(success, isTrue);
     // do incremental resolution
-    GatheringErrorListener errorListener = new GatheringErrorListener();
     IncrementalResolver resolver = new IncrementalResolver(
-        errorListener,
         typeProvider,
         library,
         unit.element,
         source,
         edit.offset,
         edit.length,
         edit.replacement.length);
     resolver.resolve(newNode);
     // resolve "newCode" from scratch
     CompilationUnit fullNewUnit;
@@ skipping 95 matching lines @@
   print(0);
   print(1);
 }
 ''');
   }
 
   void test_inBody_tokenToNode() {
     _resolveUnit(r'''
 main() {
   var v = 42;
+  print(v);
 }
 ''');
     _updateAndValidate(r'''
 main() {
   int v = 42;
+  print(v);
 }
 ''');
   }
 
   void test_twice() {
     _resolveUnit(r'''
 main() {
   print(1);
 }''');
     _updateAndValidate(r'''
@@ skipping 23 matching lines @@
 }''', false);
     _updateAndValidate(r'''
 class A {
   m() {
     int vvvvvvvv = 42;
     print(vvvvvvvv);
   }
 }''', false);
   }
 
-  void test_withImport() {
+  void test_updateErrors_addNew_hints() {
     _resolveUnit(r'''
-import 'dart:async';
-import 'dart:math';
 main() {
-  print(1);
+  int v = 0;
+  print(v);
+  print(42);
+}
+''');
+    // TODO(scheglov) "print(42)" is here because it seems we have bug with
+    // incremental analysis and the end of a function body.
+    _updateAndValidate(r'''
+main() {
+  int v = 0;
+  print(42);
+}
+''');
+  }
+
+  void test_updateErrors_addNew_parse() {
+    _resolveUnit(r'''
+main() {
+  print(42);
 }
 ''');
     _updateAndValidate(r'''
-import 'dart:async';
-import 'dart:math';
 main() {
-  print(2 + 3);
+  print(42)
 }
 ''');
   }
+
+  void test_updateErrors_addNew_resolve() {
+    _resolveUnit(r'''
+main() {
+  foo();
+}
+foo() {}
+''');
+    _updateAndValidate(r'''
+main() {
+  bar();
+}
+foo() {}
+''');
+  }
+
+  void test_updateErrors_addNew_scan() {
+    _resolveUnit(r'''
+main() {
+  1;
+}
+''');
+    _updateAndValidate(r'''
+main() {
+  1e;
+}
+''');
+  }
+
+  void test_updateErrors_addNew_verify() {
+    _resolveUnit(r'''
+main() {
+  foo(0);
+}
+foo(int p) {}
+''');
+    _updateAndValidate(r'''
+main() {
+  foo('abc');
+}
+foo(int p) {}
+''');
+  }
+
+  void test_updateErrors_removeExisting() {
+    _resolveUnit(r'''
+f1() {
+  print(1)
+}
+f2() {
+  print(22)
+}
+f3() {
+  print(333)
+}
+''');
+    _updateAndValidate(r'''
+f1() {
+  print(1)
+}
+f2() {
+  print(22);
+}
+f3() {
+  print(333)
+}
+''');
+  }
+
+  void test_updateErrors_shiftExisting() {
+    _resolveUnit(r'''
+f1() {
+  print(1)
+}
+f2() {
+  print(2);
+}
+f3() {
+  print(333)
+}
+''');
+    _updateAndValidate(r'''
+f1() {
+  print(1)
+}
+f2() {
+  print(22);
+}
+f3() {
+  print(333)
+}
+''');
+  }
 
   /**
    * Reset the analysis context to have the 'incremental' option set to the
    * given value.
    */
   void _resetWithIncremental(bool enable) {
     AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
     analysisOptions.incremental = enable;
     analysisContext2.analysisOptions = analysisOptions;
   }
@@ skipping 14 matching lines @@
   }
 
   void _updateAndValidate(String newCode, [bool compareWithFull = true]) {
     // Run any pending tasks tasks.
     _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);
+    List<AnalysisError> newErrors = analysisContext.getErrors(source).errors;
     // The existing CompilationUnitElement should be updated.
     expect(newUnit.element, same(oldUnitElement));
     // 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.compilationUnit, same(newUnit));
     // Resolve "newCode" from scratch.
     if (compareWithFull) {
       _resetWithIncremental(false);
       source = addSource(newCode);
+      _runTasks();
       LibraryElement library = resolve(source);
       CompilationUnit fullNewUnit = resolveCompilationUnit(source, library);
       // Validate that "incremental" and "full" units have the same resolution.
       _SameResolutionValidator.assertSameResolution(newUnit, fullNewUnit);
-      _assertEqualsTokens(newUnit, fullNewUnit);
+      _assertEqualTokens(newUnit, fullNewUnit);
+      List<AnalysisError> newFullErrors =
+          analysisContext.getErrors(source).errors;
+      _assertEqualErrors(newErrors, newFullErrors);
+      // TODO(scheglov) check line info
     }
   }
 
-  static void _assertEqualsToken(Token incrToken, Token fullToken) {
+  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 _assertEqualsTokens(CompilationUnit incrUnit,
+  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}');
-      _assertEqualsToken(incrToken, fullToken);
+      _assertEqualToken(incrToken, fullToken);
       incrToken = incrToken.next;
       fullToken = fullToken.next;
     }
   }
 }
 
 
 class ResolutionContextBuilderTest extends EngineTestCase {
   GatheringErrorListener listener = new GatheringErrorListener();
 
@@ skipping 1053 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);
   }
 }