When in-body incremantal resolution is performed, it should update REFERENCED_NAMES.

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/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 502 matching lines @@
 @reflectiveTest
 class PoorMansIncrementalResolutionTest extends ResolverTestCase {
   final _TestLogger logger = new _TestLogger();
 
   Source source;
   String code;
   LibraryElement oldLibrary;
   CompilationUnit oldUnit;
   CompilationUnitElement oldUnitElement;
 
+  void assertSameReferencedNames(
+      ReferencedNames incNames, ReferencedNames fullNames) {
+    expectEqualSets(Iterable actual, Iterable expected) {
+      expect(actual, unorderedEquals(expected));
+    }
+    expectEqualSets(incNames.names, fullNames.names);
+    expectEqualSets(incNames.instantiatedNames, fullNames.instantiatedNames);
+    expectEqualSets(incNames.superToSubs.keys, fullNames.superToSubs.keys);
+    for (String key in fullNames.superToSubs.keys) {
+      expectEqualSets(incNames.superToSubs[key], fullNames.superToSubs[key]);
+    }
+  }
+
   @override
   void setUp() {
     super.setUp();
     _resetWithIncremental(true);
   }
 
   void test_computeConstants() {
     _resolveUnit(r'''
 int f() => 0;
 main() {
@@ skipping 1369 matching lines @@
       _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);
     logger.expectNoErrors();
     List<AnalysisError> newErrors = analysisContext.computeErrors(source);
     LineInfo newLineInfo = analysisContext.getLineInfo(source);
+    ReferencedNames newReferencedNames =
+        analysisContext.getResult(source, REFERENCED_NAMES);
     // 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(
         expectLibraryUnchanged: expectLibraryUnchanged,
         expectCachePostConstantsValid: expectCachePostConstantsValid);
@@ skipping 12 matching lines @@
       _resetWithIncremental(false);
       changeSource(source, '');
       changeSource(source, newCode);
       _runTasks();
       LibraryElement library = resolve2(source);
       CompilationUnit fullNewUnit = resolveCompilationUnit(source, library);
       // Validate tokens.
       _assertEqualTokens(newUnit, fullNewUnit);
       // Validate LineInfo
       _assertEqualLineInfo(newLineInfo, analysisContext.getLineInfo(source));
+      // Validate referenced names.
+      ReferencedNames fullReferencedNames =
+          analysisContext.getResult(source, REFERENCED_NAMES);
+      assertSameReferencedNames(newReferencedNames, fullReferencedNames);
       // Validate that "incremental" and "full" units have the same resolution.
       try {
         assertSameResolution(newUnit, fullNewUnit, validateTypes: true);
       } on IncrementalResolutionMismatch catch (mismatch) {
         fail(mismatch.message);
       }
       List<AnalysisError> newFullErrors =
           analysisContext.getErrors(source).errors;
       _assertEqualErrors(newErrors, newFullErrors);
     }
@@ skipping 275 matching lines @@
   void logException(Object exception, [Object stackTrace]) {
     lastException = exception;
     lastStackTrace = stackTrace;
   }
 
   @override
   logging.LoggingTimer startTimer() {
     return new logging.LoggingTimer(this);
   }
 }