Adapt the existing incremental resolution implementation to the new model.

pkg/analyzer/lib/src/context/cache.dart

 // Copyright (c) 2015, 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.src.context.cache;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, CacheState, InternalAnalysisContext, RetentionPriority;
@@ skipping 284 matching lines @@
   /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (!hasErrorState()) {
       _exception = null;
     }
   }
 
   /**
+   * Look up the [ResultData] of [descriptor], or add a new one if it isn't
+   * there.
+   */
+  ResultData getResultData(ResultDescriptor descriptor) {
+    return _resultMap.putIfAbsent(descriptor, () => new ResultData(descriptor));
+  }
+
+  /**
    * Return the state of the result represented by the given [descriptor].
    */
   CacheState getState(ResultDescriptor descriptor) {
     ResultData data = _resultMap[descriptor];
     if (data == null) {
       return CacheState.INVALID;
     }
     return data.state;
   }
 
@@ skipping 76 matching lines @@
     if (state == CacheState.VALID) {
       throw new ArgumentError('use setValue() to set the state to VALID');
     }
     _validateStateChange(descriptor, state);
     if (state == CacheState.INVALID) {
       ResultData data = _resultMap[descriptor];
       if (data != null) {
         _invalidate(descriptor);
       }
     } else {
-      ResultData data = _getResultData(descriptor);
+      ResultData data = getResultData(descriptor);
       data.state = state;
       if (state != CacheState.IN_PROCESS) {
         //
         // If the state is in-process, we can leave the current value in the
         // cache for any 'get' methods to access.
         //
         data.value = descriptor.defaultValue;
       }
     }
   }
 
   /**
    * Set the value of the result represented by the given [descriptor] to the
    * given [value].
    */
   /*<V>*/ void setValue(ResultDescriptor /*<V>*/ descriptor, dynamic /*V*/
       value, List<TargetedResult> dependedOn) {
 //    print('  setValue: $descriptor for $target dependedOn=$dependedOn');
     _validateStateChange(descriptor, CacheState.VALID);
     TargetedResult thisResult = new TargetedResult(target, descriptor);
     if (_partition != null) {
       _partition.resultStored(thisResult, value);
     }
-    ResultData data = _getResultData(descriptor);
+    ResultData data = getResultData(descriptor);
     _setDependedOnResults(data, thisResult, dependedOn);
     data.state = CacheState.VALID;
     data.value = value == null ? descriptor.defaultValue : value;
   }
 
+  /**
+   * Set the value of the result represented by the given [descriptor] to the
+   * given [value], keep its dependency, invalidate all the dependent result.
+   */
+  void setValueIncremental(ResultDescriptor descriptor, dynamic value) {
+    ResultData data = getResultData(descriptor);
+    List<TargetedResult> dependedOn = data.dependedOnResults;
+    _invalidate(descriptor);
+    setValue(descriptor, value, dependedOn);
+  }
+
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _writeOn(buffer);
     return buffer.toString();
   }
 
   /**
    * Return the value of the flag with the given [index].
    */
   bool _getFlag(int index) => BooleanArray.get(_flags, index);
 
   /**
-   * Look up the [ResultData] of [descriptor], or add a new one if it isn't
-   * there.
-   */
-  ResultData _getResultData(ResultDescriptor descriptor) {
-    return _resultMap.putIfAbsent(descriptor, () => new ResultData(descriptor));
-  }
-
-  /**
    * Invalidate the result represented by the given [descriptor] and propagate
    * invalidation to other results that depend on it.
    */
   void _invalidate(ResultDescriptor descriptor) {
     ResultData thisData = _resultMap.remove(descriptor);
 //    print('invalidate: $descriptor for $target');
     if (thisData == null) {
       return;
     }
     // Stop depending on other results.
@@ skipping 48 matching lines @@
         data.dependentResults.add(thisResult);
       }
     });
   }
 
   /**
    * Set states of the given and dependent results to [CacheState.ERROR] and
    * their values to the corresponding default values
    */
   void _setErrorState(ResultDescriptor descriptor, CaughtException exception) {
-    ResultData thisData = _getResultData(descriptor);
+    ResultData thisData = getResultData(descriptor);
     // Set the error state.
     _exception = exception;
     thisData.state = CacheState.ERROR;
     thisData.value = descriptor.defaultValue;
     // Propagate the error state.
     thisData.dependentResults.forEach((TargetedResult dependentResult) {
       CacheEntry entry = _partition.get(dependentResult.target);
       entry._setErrorState(dependentResult.result, exception);
     });
   }
@@ skipping 323 matching lines @@
         _pathToSources.putIfAbsent(fullName, () => <Source>[]).add(target);
       }
     }
   }
 
   ResultData _getDataFor(TargetedResult result, {bool orNull: false}) {
     CacheEntry entry = context.analysisCache.get(result.target);
     if (orNull) {
       return entry != null ? entry._resultMap[result.result] : null;
     } else {
-      return entry._getResultData(result.result);
+      return entry.getResultData(result.result);
     }
   }
 
   /**
    * Return the [CacheFlushManager] for the given [descriptor], not `null`.
    */
   CacheFlushManager _getFlushManager(ResultDescriptor descriptor) {
     ResultCachingPolicy policy = descriptor.cachingPolicy;
     if (identical(policy, DEFAULT_CACHING_POLICY)) {
       return UnlimitedCacheFlushManager.INSTANCE;
@@ skipping 166 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }