Issue 26629. Detect cache inconsistency in GetContentTask.

pkg/analyzer/lib/task/model.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.task.model;
 
 import 'dart:collection';
 import 'dart:developer';
 
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 317 matching lines @@
         }
         internalPerform();
       } finally {
         stopwatch.stop();
       }
 //      } finally {
 //        previousTag.makeCurrent();
 //      }
     } on AnalysisException {
       rethrow;
+    } on ModificationTimeMismatchError {
+      rethrow;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           'Unexpected exception while performing $description',
           new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * A description of a [List]-based analysis result that can be computed by an
@@ skipping 68 matching lines @@
    * [V] must be a [List].
    * Return a task input that can be used to compute a list whose elements are
    * the result of passing keys [K] and the corresponding elements of [V] to
    * the [mapper] function.
    */
   TaskInput<List/*<E>*/ > toFlattenList/*<E>*/(
       BinaryFunction<K, dynamic /*element of V*/, dynamic/*=E*/ > mapper);
 }
 
 /**
+ * Instances of this class are thrown when a task detects that the modification
+ * time of a cache entry is not the same as the actual modification time.  This
+ * means that any analysis results based on the content of the target cannot be
+ * used anymore and must be invalidated.
+ */
+class ModificationTimeMismatchError {
+  final AnalysisTarget target;

[Brian Wilkerson, 2016/06/08 22:21:55]

I suspect this will always be a Source, but the extra generality might not be a
problem.

+
+  ModificationTimeMismatchError(this.target);
+}
+
+/**
  * A policy object that can compute sizes of results and provide the maximum
  * active and idle sizes that can be kept in the cache.
  *
  * All the [ResultDescriptor]s with the same [ResultCachingPolicy] instance
  * share the same total size in a cache.
  *
  * Clients may implement this class when implementing plugins.
  */
 abstract class ResultCachingPolicy<T> {
   /**
@@ skipping 335 matching lines @@
   /**
    * A work should be done, but without any special urgency.
    */
   NORMAL,
 
   /**
    * Nothing to do.
    */
   NONE
 }