Record dependencies and invalidate results.

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'
     show AnalysisEngine, CacheState, InternalAnalysisContext, RetentionPriority;
 import 'package:analyzer/src/generated/html.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
+import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * An LRU cache of results produced by analysis.
  */
 class AnalysisCache {
   /**
    * A flag used to control whether trace information should be produced when
    * the content of the cache is modified.
    */
@@ skipping 101 matching lines @@
     for (int i = 0; i < count; i++) {
       maps[i] = _partitions[i].map;
     }
     return new MultipleMapIterator<AnalysisTarget, CacheEntry>(maps);
   }
 
   /**
    * Associate the given [entry] with the given [target].
    */
   void put(AnalysisTarget target, CacheEntry entry) {
+    entry._cache = this;
+    entry._target = target;
     entry.fixExceptionState();
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(target)) {
         if (_TRACE_CHANGES) {
           CacheEntry oldEntry = _partitions[i].get(target);
           if (oldEntry == null) {
             AnalysisEngine.instance.logger
                 .logInformation('Added a cache entry for $target.');
           } else {
@@ skipping 59 matching lines @@
    */
   void storedAst(AnalysisTarget target) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(target)) {
         _partitions[i].storedAst(target);
         return;
       }
     }
   }
+
+  ResultData _getDataFor(TargetedResult result) {
+    AnalysisTarget target = result.target;
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      if (_partitions[i].contains(target)) {
+        CacheEntry entry = _partitions[i].get(target);
+        return entry._getResultData(result.result);
+      }
+    }
+    return null;
+  }
 }
 
 /**
  * The information cached by an analysis context about an individual target.
  */
 class CacheEntry {
   /**
    * The index of the flag indicating whether the source was explicitly added to
    * the context or whether the source was implicitly added because it was
    * referenced by another source.
    */
   static int _EXPLICITLY_ADDED_FLAG = 0;
 
   /**
+   * The cache that contains this entry.
+   */
+  AnalysisCache _cache;
+
+  /**
+   * The target this entry is about.
+   */
+  AnalysisTarget _target;
+
+  /**
    * The most recent time at which the state of the target matched the state
    * represented by this entry.
    */
   int modificationTime = 0;
 
   /**
    * The exception that caused one or more values to have a state of
    * [CacheState.ERROR].
    */
   CaughtException _exception;
@@ skipping 116 matching lines @@
       getState(descriptor) == CacheState.INVALID;
 
   /**
    * Return `true` if the state of the result represented by the given
    * [descriptor] is [CacheState.VALID].
    */
   bool isValid(ResultDescriptor descriptor) =>
       getState(descriptor) == CacheState.VALID;
 
   /**
-   * Set the [CacheState.ERROR] state for given [descriptors], their values to
-   * the corresponding default values, and remember the [exception] that caused
-   * this state.
+   * For each of the given [descriptors], set their states to
+   * [CacheState.ERROR], their values to the corresponding default values, and
+   * remember the [exception] that caused this state.
    */
   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);
-      data.state = CacheState.ERROR;
-      data.value = descriptor.defaultValue;
+      TargetedResult thisResult = new TargetedResult(_target, descriptor);
+      data.invalidate(_cache, thisResult, CacheState.ERROR);
     }
   }
 
   /**
    * 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) {
-      _resultMap.remove(descriptor);
+      ResultData data = _resultMap[descriptor];
+      if (data != null) {
+        TargetedResult thisResult = new TargetedResult(_target, descriptor);
+        data.invalidate(_cache, thisResult, CacheState.INVALID);
+      }
     } 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].
    */
   /*<V>*/ void setValue(ResultDescriptor /*<V>*/ descriptor, dynamic /*V*/
-      value) {
+      value, List<TargetedResult> dependedOn) {
     _validateStateChange(descriptor, CacheState.VALID);
     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;
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _writeOn(buffer);
     return buffer.toString();
   }
@@ skipping 333 matching lines @@
   }
 }
 
 /**
  * The data about a single analysis result that is stored in a [CacheEntry].
  */
 // TODO(brianwilkerson) Consider making this a generic class so that the value
 // can be typed.
 class ResultData {
   /**
+   * The [ResultDescriptor] this result is for.
+   */
+  final ResultDescriptor descriptor;
+
+  /**
    * The state of the cached value.
    */
   CacheState state;
 
   /**
    * The value being cached, or the default value for the result if there is no
    * value (for example, when the [state] is [CacheState.INVALID]).
    */
   Object value;
 
   /**
+   * A list of the results on which this result depends.
+   */
+  List<TargetedResult> dependedOnResults = <TargetedResult>[];
+
+  /**
+   * A list of the results that depend on this result.
+   */
+  List<TargetedResult> dependentResults = <TargetedResult>[];
+
+  /**
    * Initialize a newly created result holder to represent the value of data
    * described by the given [descriptor].
    */
-  ResultData(ResultDescriptor descriptor) {
+  ResultData(this.descriptor) {
     state = CacheState.INVALID;
     value = descriptor.defaultValue;
   }
+
+  /**
+   * 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,
+      List<TargetedResult> dependedOn) {
+    dependedOnResults.forEach((TargetedResult dependedOnResult) {
+      ResultData data = cache._getDataFor(dependedOnResult);
+      data.removeDependentResult(thisResult);
+    });
+    dependedOnResults = dependedOn;
+    dependedOnResults.forEach((TargetedResult dependentResult) {
+      ResultData data = cache._getDataFor(dependentResult);
+      data.addDependentResult(thisResult);
+    });
+  }
 }
 
 /**
  * A cache partition that contains all of the targets in the SDK.
  */
 class SdkCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context]. The partition will maintain at most [maxCacheSize] AST
    * structures in the cache.
    */
   SdkCachePartition(InternalAnalysisContext context, int maxCacheSize)
       : super(context, maxCacheSize, DefaultRetentionPolicy.POLICY);
 
   @override
   bool contains(AnalysisTarget target) {
     Source source = target.source;
     return source != null && source.isInSystemLibrary;
   }
 }
 
 /**
+ * A specification of a specific result computed for a specific target.
+ */
+class TargetedResult {
+  /**
+   * An empty list of results.
+   */
+  static final List<TargetedResult> EMPTY_LIST = const <TargetedResult>[];
+
+  /**
+   * The target with which the result is associated.
+   */
+  final AnalysisTarget target;
+
+  /**
+   * The result associated with the target.
+   */
+  final ResultDescriptor result;
+
+  /**
+   * Initialize a new targeted result.
+   */
+  TargetedResult(this.target, this.result);
+
+  @override
+  int get hashCode {
+    return JenkinsSmiHash.combine(target.hashCode, result.hashCode);
+  }
+
+  @override
+  bool operator ==(other) {
+    return other is TargetedResult &&
+        other.target == target &&
+        other.result == result;
+  }
+
+  @override
+  String toString() => '$result for $target';
+}
+
+/**
  * A cache partition that contains all targets not contained in other partitions.
  */
 class UniversalCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context]. The partition will maintain at most [maxCacheSize] AST
    * 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;
 }