When invalidate because of the ERROR state, propagate its exception.

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/ast.dart';
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 395 matching lines @@
   void setErrorState(
       CaughtException exception, List<ResultDescriptor> descriptors) {
     if (descriptors == null || descriptors.isEmpty) {
       throw new ArgumentError('at least one descriptor is expected');
     }
     if (exception == null) {
       throw new ArgumentError('an exception is expected');
     }
     this._exception = exception;
     for (ResultDescriptor descriptor in descriptors) {
-      ResultData data = _getResultData(descriptor);
-      TargetedResult thisResult = new TargetedResult(_target, descriptor);
-      data.invalidate(_cache, thisResult, CacheState.ERROR);
+      _invalidate(descriptor, exception);
     }
   }
 
   /**
    * Set the state of the result represented by the given [descriptor] to the
    * given [state].
    */
   void setState(ResultDescriptor descriptor, CacheState state) {
     if (state == CacheState.ERROR) {
       throw new ArgumentError('use setErrorState() to set the state to ERROR');
     }
     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) {
-        TargetedResult thisResult = new TargetedResult(_target, descriptor);
-        data.invalidate(_cache, thisResult, CacheState.INVALID);
-      }
+      _invalidate(descriptor, null);
     } else {
       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]. The optional [memento] may help to recompute [value] more
    * efficiently after invalidation.
    */
   /*<V>*/ void setValue(ResultDescriptor /*<V>*/ descriptor, dynamic /*V*/
       value, List<TargetedResult> dependedOn, Object memento) {
     _validateStateChange(descriptor, CacheState.VALID);
+    _invalidate(descriptor, null);
     ResultData data = _getResultData(descriptor);
     {
       TargetedResult thisResult = new TargetedResult(_target, descriptor);
-      data.invalidate(_cache, thisResult, CacheState.INVALID);
       data.setDependedOnResults(_cache, thisResult, dependedOn);
     }
     data.state = CacheState.VALID;
     data.value = value == null ? descriptor.defaultValue : value;
     data.memento = memento;
   }
 
   @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].
+   * Propagate invalidation to other results that depend on it.
+   */
+  void _invalidate(ResultDescriptor descriptor, CaughtException exception) {
+    ResultData data = _getResultData(descriptor);
+    // Invalidate this result.
+    if (exception == null) {
+      data.state = CacheState.INVALID;
+    } else {
+      data.state = CacheState.ERROR;
+      _exception = exception;
+    }
+    data.value = descriptor.defaultValue;
+    // Stop depending on other results.
+    TargetedResult thisResult = new TargetedResult(_target, descriptor);
+    List<TargetedResult> dependedOnResults = data.dependedOnResults;
+    data.dependedOnResults = <TargetedResult>[];
+    dependedOnResults.forEach((TargetedResult dependedOnResult) {
+      ResultData data = _cache._getDataFor(dependedOnResult);
+      data.removeDependentResult(thisResult);
+    });
+    // Invalidate results that depend on this result.
+    List<TargetedResult> dependentResults = data.dependentResults;
+    data.dependentResults = <TargetedResult>[];
+    dependentResults.forEach((TargetedResult dependentResult) {
+      CacheEntry entry = _cache.get(dependentResult.target);
+      entry._invalidate(dependentResult.result, exception);
+    });
+  }
+
+  /**
    * Set the value of the flag with the given [index] to the given [value].
    */
   void _setFlag(int index, bool value) {
     _flags = BooleanArray.set(_flags, index, value);
   }
 
   /**
    * If the state of the value described by the given [descriptor] is changing
    * from ERROR to anything else, capture the information. This is an attempt to
    * discover the underlying cause of a long-standing bug.
@@ skipping 356 matching lines @@
   }
 
   /**
    * Add the given [result] to the list of dependent results.
    */
   void addDependentResult(TargetedResult result) {
     dependentResults.add(result);
   }
 
   /**
-   * Invalidate this [ResultData] that corresponds to [thisResult] and
-   * propagate invalidation to the results that depend on this one.
-   */
-  void invalidate(
-      AnalysisCache cache, TargetedResult thisResult, CacheState newState) {
-    // Invalidate this result.
-    state = newState;
-    value = descriptor.defaultValue;
-    // Stop depending on other results.
-    List<TargetedResult> dependedOnResults = this.dependedOnResults;
-    this.dependedOnResults = <TargetedResult>[];
-    dependedOnResults.forEach((TargetedResult dependedOnResult) {
-      ResultData data = cache._getDataFor(dependedOnResult);
-      data.removeDependentResult(thisResult);
-    });
-    // Invalidate results that depend on this result.
-    List<TargetedResult> dependentResults = this.dependentResults;
-    this.dependentResults = <TargetedResult>[];
-    dependentResults.forEach((TargetedResult dependentResult) {
-      ResultData data = cache._getDataFor(dependentResult);
-      data.invalidate(cache, dependentResult, newState);
-    });
-  }
-
-  /**
    * Remove the given [result] from the list of dependent results.
    */
   void removeDependentResult(TargetedResult result) {
     dependentResults.remove(result);
   }
 
   /**
    * Set the [dependedOn] on which this result depends.
    */
   void setDependedOnResults(AnalysisCache cache, TargetedResult thisResult,
@@ skipping 79 matching lines @@
    * structures in the cache, using the [retentionPolicy] to determine which
    * AST structures to flush.
    */
   UniversalCachePartition(InternalAnalysisContext context, int maxCacheSize,
       CacheRetentionPolicy retentionPolicy)
       : super(context, maxCacheSize, retentionPolicy);
 
   @override
   bool contains(AnalysisTarget target) => true;
 }