Use all library units for hints 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 2414 matching lines @@
     }
     // 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(
-        unit.element,
-        updateOffset,
-        updateEndOld,
-        updateOldNew);
+    IncrementalResolver resolver =
+        new IncrementalResolver(<Source, CompilationUnit>{
+      source: newUnit
+    }, unit.element, 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);
@@ skipping 602 matching lines @@
 ''');
     _updateAndValidate(r'''
 class A {
   main(int b) {
     print(b);
   }
 }
 ''');
   }
 
+  void test_unusedHint_add_wasUsedOnlyInPart() {
+    Source partSource = addNamedSource('/my_unit.dart', r'''
+part of lib;
+
+f(A a) {
+  a._foo();
+}
+''');
+    _resolveUnit(r'''
+library lib;
+part 'my_unit.dart';
+class A {
+  _foo() {
+    print(1);
+  }
+}
+''');
+    _runTasks();
+    // perform incremental resolution
+    _resetWithIncremental(true);
+    analysisContext2.setContents(partSource, r'''
+part of lib;
+
+f(A a) {
+//  a._foo();
+}
+''');
+    // a new hint should be added
+    List<AnalysisError> errors = analysisContext.getErrors(source).errors;
+    expect(errors, hasLength(1));
+    expect(errors[0].errorCode.type, ErrorType.HINT);
+    // the same hint should be reported using a ChangeNotice
+    bool noticeFound = false;
+    AnalysisResult result = analysisContext2.performAnalysisTask();
+    for (ChangeNotice notice in result.changeNotices) {
+      if (notice.source == source) {
+        expect(notice.errors, contains(errors[0]));
+        noticeFound = true;
+      }
+    }
+    expect(noticeFound, isTrue);
+  }
+
+  void test_unusedHint_false_stillUsedInPart() {
+    addNamedSource('/my_unit.dart', r'''
+part of lib;
+
+f(A a) {
+  a._foo();
+}
+''');
+    _resolveUnit(r'''
+library lib;
+part 'my_unit.dart';
+class A {
+  _foo() {
+    print(1);
+  }
+}
+''');
+    // perform incremental resolution
+    _resetWithIncremental(true);
+    analysisContext2.setContents(source, r'''
+library lib;
+part 'my_unit.dart';
+class A {
+  _foo() {
+    print(12);
+  }
+}
+''');
+    // no hints
+    List<AnalysisError> errors = analysisContext.getErrors(source).errors;
+    expect(errors, isEmpty);
+  }
+
   void test_updateErrors_addNew_hint() {
     _resolveUnit(r'''
 int main() {
   return 42;
 }
 ''');
     _updateAndValidate(r'''
 int main() {
 }
 ''');
@@ skipping 494 matching lines @@
   }
 }
 
 
 class _Edit {
   final int offset;
   final int length;
   final String replacement;
   _Edit(this.offset, this.length, this.replacement);
 }