Add CacheEntry.setErrorState().

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 217 matching lines @@
   /**
    * 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;
+  CaughtException _exception;
 
   /**
    * A bit-encoding of boolean flags associated with this entry's target.
    */
   int _flags = 0;
 
   /**
    * A table mapping result descriptors to the cached values of those results.
    */
   Map<ResultDescriptor, ResultData> _resultMap =
       new HashMap<ResultDescriptor, ResultData>();
 
   /**
+   * The exception that caused one or more values to have a state of
+   * [CacheState.ERROR].
+   */
+  CaughtException get exception => _exception;
+
+  /**
    * Return `true` if the source was explicitly added to the context or `false`
    * if the source was implicitly added because it was referenced by another
    * source.
    */
   bool get explicitlyAdded => _getFlag(_EXPLICITLY_ADDED_FLAG);
 
   /**
    * Set whether the source was explicitly added to the context to match the
    * [explicitlyAdded] flag.
    */
@@ skipping 11 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
-    if (hasErrorState()) {
-      if (exception == null) {
-        //
-        // This code should never be reached, but is a fail-safe in case an
-        // exception is not recorded when it should be.
-        //
-        // TODO(brianwilkerson) Log this?
-        String message = 'State set to ERROR without setting an exception';
-        exception = new CaughtException(new AnalysisException(message), null);
-      }
-    } else {
-      exception = null;
+    if (!hasErrorState()) {
+      _exception = null;
     }
   }
 
   /**
    * Mark any AST structures associated with this cache entry as being flushed.
    */
   void flushAstStructures() {
     _resultMap.forEach((ResultDescriptor descriptor, ResultData data) {
       if (data.value is AstNode || data.value is XmlNode) {
         _validateStateChange(descriptor, CacheState.FLUSHED);
@@ skipping 36 matching lines @@
       }
     }
     return false;
   }
 
   /**
    * Invalidate all of the information associated with this entry's target.
    */
   void invalidateAllInformation() {
     _resultMap.clear();
-    exception = null;
+    _exception = null;
   }
 
   /**
+   * Set the [CacheState.ERROR] state for given [descriptors], their values to
+   * the corresponding default values, and remember the [exception] that caused
+   * this state.
+   */
+  void setErrorState(
+      List<ResultDescriptor> descriptors, CaughtException exception) {

[Brian Wilkerson, 2015/03/07 15:43:32]

I would prefer having the exception be the first argument. I think that client
code formats better when variable length arguments (such as list literals) can
be placed at the end of the argument list.

[scheglov, 2015/03/07 17:01:04]

Done.

+    if (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;
+    }
+  }
+
+  /**
    * Set the state of the result represented by the given [descriptor] to the
    * given [state].
    */
   void setState(ResultDescriptor descriptor, CacheState state) {
-    // TODO(brianwilkerson) Consider introducing a different method used to set
-    // the state of a list of descriptors to ERROR that could validate that an
-    // exception was also provided. (It would then be an error to use this
-    // method to set the state to ERROR.)
+    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);
     } else {
-      ResultData data =
-          _resultMap.putIfAbsent(descriptor, () => new ResultData(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) {
     _validateStateChange(descriptor, CacheState.VALID);
-    ResultData data =
-        _resultMap.putIfAbsent(descriptor, () => new ResultData(descriptor));
+    ResultData data = _getResultData(descriptor);
     data.state = CacheState.VALID;
     data.value = value == null ? descriptor.defaultValue : value;
   }
 
   @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));
+  }
+
+  /**
    * 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 361 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;
 }