Fix for updating HINTS during incremental resolution with TM.

pkg/analyzer/lib/src/generated/incremental_resolver.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;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/context/cache.dart'
@@ skipping 846 matching lines @@
   @override
   DeltaResult validate(InternalAnalysisContext context, AnalysisTarget target,
       ResultDescriptor descriptor) {
     // don't invalidate results of standard Dart tasks
     bool isByTask(TaskDescriptor taskDescriptor) {
       return taskDescriptor.results.contains(descriptor);
     }
     if (descriptor == CONTENT) {
       return DeltaResult.KEEP_CONTINUE;
     }
-    if (target is Source && target != source) {
-      if (isByTask(DartErrorsTask.DESCRIPTOR) ||
-          isByTask(LibraryErrorsReadyTask.DESCRIPTOR)) {
+    if (target is LibrarySpecificUnit && target.unit != source) {
+      if (isByTask(GatherUsedLocalElementsTask.DESCRIPTOR) ||
+          isByTask(GatherUsedImportedElementsTask.DESCRIPTOR)) {
         return DeltaResult.KEEP_CONTINUE;
       }
     }
-    if (target is LibrarySpecificUnit &&
-        target.unit != source &&
-        target.library != source) {
-      if (isByTask(GatherUsedLocalElementsTask.DESCRIPTOR) ||
-          isByTask(GatherUsedImportedElementsTask.DESCRIPTOR) ||
-          isByTask(GenerateHintsTask.DESCRIPTOR) ||
-          isByTask(LibraryUnitErrorsTask.DESCRIPTOR)) {
-        return DeltaResult.KEEP_CONTINUE;
-      }
-    }
     if (isByTask(BuildCompilationUnitElementTask.DESCRIPTOR) ||
         isByTask(BuildDirectiveElementsTask.DESCRIPTOR) ||
         isByTask(BuildEnumMemberElementsTask.DESCRIPTOR) ||
         isByTask(BuildExportNamespaceTask.DESCRIPTOR) ||
         isByTask(BuildLibraryElementTask.DESCRIPTOR) ||
         isByTask(BuildPublicNamespaceTask.DESCRIPTOR) ||
         isByTask(BuildSourceExportClosureTask.DESCRIPTOR) ||
         isByTask(BuildSourceImportExportClosureTask.DESCRIPTOR) ||
         isByTask(ComputeConstantDependenciesTask.DESCRIPTOR) ||
         isByTask(ComputeConstantValueTask.DESCRIPTOR) ||
+        isByTask(DartErrorsTask.DESCRIPTOR) ||
         isByTask(EvaluateUnitConstantsTask.DESCRIPTOR) ||
+        isByTask(GenerateHintsTask.DESCRIPTOR) ||
         isByTask(InferInstanceMembersInUnitTask.DESCRIPTOR) ||
         isByTask(InferStaticVariableTypesInUnitTask.DESCRIPTOR) ||
+        isByTask(LibraryErrorsReadyTask.DESCRIPTOR) ||
+        isByTask(LibraryUnitErrorsTask.DESCRIPTOR) ||
         isByTask(ParseDartTask.DESCRIPTOR) ||
         isByTask(PartiallyResolveUnitReferencesTask.DESCRIPTOR) ||
         isByTask(ScanDartTask.DESCRIPTOR) ||
         isByTask(ResolveFunctionBodiesInUnitTask.DESCRIPTOR) ||
         isByTask(ResolveLibraryReferencesTask.DESCRIPTOR) ||
         isByTask(ResolveLibraryTypeNamesTask.DESCRIPTOR) ||
         isByTask(ResolveUnitTypeNamesTask.DESCRIPTOR) ||
         isByTask(ResolveVariableReferencesTask.DESCRIPTOR) ||
         isByTask(VerifyUnitTask.DESCRIPTOR)) {
       return DeltaResult.KEEP_CONTINUE;
     }
     // invalidate all the other results
-    return DeltaResult.INVALIDATE;
+    return DeltaResult.INVALIDATE_NO_DELTA;
   }
 }
 
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The element of the compilation unit being resolved.
@@ skipping 368 matching lines @@
   void _updateEntry() {
     if (oldEntry != null) {
       _updateEntry_OLD();
     } else {
       _updateEntry_NEW();
     }
   }
 
   void _updateEntry_NEW() {
     _updateErrors_NEW(INFER_STATIC_VARIABLE_TYPES_ERRORS, _resolveErrors);
-    _updateErrors_NEW(LIBRARY_UNIT_ERRORS, _resolveErrors);
     _updateErrors_NEW(PARTIALLY_RESOLVE_REFERENCES_ERRORS, _resolveErrors);
     _updateErrors_NEW(RESOLVE_FUNCTION_BODIES_ERRORS, _resolveErrors);
     _updateErrors_NEW(RESOLVE_TYPE_NAMES_ERRORS, []);
     _updateErrors_NEW(VARIABLE_REFERENCE_ERRORS, []);
     _updateErrors_NEW(VERIFY_ERRORS, _verifyErrors);
     // invalidate results we don't update incrementally
     newUnitEntry.setState(USED_IMPORTED_ELEMENTS, CacheState.INVALID);
     newUnitEntry.setState(USED_LOCAL_ELEMENTS, CacheState.INVALID);
     newUnitEntry.setState(HINTS, CacheState.INVALID);
   }
@@ skipping 24 matching lines @@
       }
     }
     // done
     return errors;
   }
 
   void _updateErrors_NEW(ResultDescriptor<List<AnalysisError>> descriptor,
       List<AnalysisError> newErrors) {
     List<AnalysisError> oldErrors = newUnitEntry.getValue(descriptor);
     List<AnalysisError> errors = _updateErrors(oldErrors, newErrors);
-    newUnitEntry.setValueIncremental(descriptor, errors);
+    newUnitEntry.setValueIncremental(descriptor, errors, true);
   }
 
   void _updateErrors_OLD(DataDescriptor<List<AnalysisError>> descriptor,
       List<AnalysisError> newErrors) {
     List<AnalysisError> oldErrors =
         oldEntry.getValueInLibrary(descriptor, _librarySource);
     List<AnalysisError> errors = _updateErrors(oldErrors, newErrors);
     oldEntry.setValueInLibrary(descriptor, _librarySource, errors);
   }
 
@@ skipping 352 matching lines @@
 
   void _updateEntry() {
     if (_oldEntry != null) {
       _updateEntry_OLD();
     } else {
       _updateEntry_NEW();
     }
   }
 
   void _updateEntry_NEW() {
-    _newSourceEntry.setState(DART_ERRORS, CacheState.INVALID);
     // scan results
-    List<TargetedResult> scanDeps = <TargetedResult>[
-      new TargetedResult(_unitSource, CONTENT)
-    ];
-    _newSourceEntry.setState(SCAN_ERRORS, CacheState.INVALID);
-    _newSourceEntry.setValue(SCAN_ERRORS, _newScanErrors, scanDeps);
-    _newSourceEntry.setValue(LINE_INFO, _newLineInfo, scanDeps);
+    _newSourceEntry.setValueIncremental(SCAN_ERRORS, _newScanErrors, true);
+    _newSourceEntry.setValueIncremental(LINE_INFO, _newLineInfo, false);
     // parse results
-    List<TargetedResult> parseDeps = <TargetedResult>[
-      new TargetedResult(_unitSource, TOKEN_STREAM)
-    ];
-    _newSourceEntry.setState(PARSE_ERRORS, CacheState.INVALID);
-    _newSourceEntry.setValue(PARSE_ERRORS, _newParseErrors, parseDeps);
-    _newSourceEntry.setValue(PARSED_UNIT, _oldUnit, parseDeps);
+    _newSourceEntry.setValueIncremental(PARSE_ERRORS, _newScanErrors, true);
+    _newSourceEntry.setValueIncremental(PARSED_UNIT, _newScanErrors, false);
   }
 
   void _updateEntry_OLD() {
     _oldEntry.setValue(SourceEntry.LINE_INFO, _newLineInfo);
     _oldEntry.setValue(DartEntry.SCAN_ERRORS, _newScanErrors);
     _oldEntry.setValue(DartEntry.PARSE_ERRORS, _newParseErrors);
   }
 
   /**
    * Checks if [token] has a balanced number of open and closed curly brackets.
@@ skipping 396 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }