Removed fixed dependencies

packages/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' hide AnalysisTask;
-import 'package:analyzer/src/generated/error.dart' show AnalysisError;
-import 'package:analyzer/src/generated/java_engine.dart';
+import 'package:analyzer/error/error.dart' show AnalysisError;
+import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/model.dart';
 
 /**
  * A function that converts the given [key] and [value] into a [TaskInput].
  */
 typedef TaskInput<E> BinaryFunction<K, V, E>(K key, V value);
 
 /**
  * A function that takes an analysis [context] and an analysis [target] and
  * returns an analysis task. Such functions are passed to a [TaskDescriptor] to
  * be used to create the described task.
  */
 typedef AnalysisTask BuildTask(AnalysisContext context, AnalysisTarget target);
 
 /**
  * A function that takes the target for which a task will produce results and
  * returns a map from input names to descriptions of the analysis results needed
  * by the task in order for the task to be performed. Such functions are passed
  * to a [TaskDescriptor] to be used to determine the inputs needed by the task.
  */
 typedef Map<String, TaskInput> CreateTaskInputs(AnalysisTarget target);
 
 /**
+ * A function that takes the target for which a task will produce results and
+ * returns an indication of how suitable the task is for the target. Such
+ * functions are passed to a [TaskDescriptor] to be used to determine their
+ * suitability for computing results.
+ */
+typedef TaskSuitability SuitabilityFor(AnalysisTarget target);
+
+/**
  * A function that converts an object of the type [B] into a [TaskInput].
  * This is used, for example, by a [ListTaskInput] to create task inputs
  * for each value in a list of values.
  */
 typedef TaskInput<E> UnaryFunction<B, E>(B object);
 
 /**
  * An [AnalysisTarget] wrapper for an [AnalysisContext].
  */
 class AnalysisContextTarget implements AnalysisTarget {
   static final AnalysisContextTarget request = new AnalysisContextTarget(null);
 
   final AnalysisContext context;
 
   AnalysisContextTarget(this.context);
 
   @override
+  Source get librarySource => null;
+
+  @override
   Source get source => null;
 }
 
 /**
  * An object with which an analysis result can be associated.
  *
  * Clients may implement this class when creating new kinds of targets.
  * Instances of this type are used in hashed data structures, so subtypes are
  * required to correctly implement [==] and [hashCode].
  */
 abstract class AnalysisTarget {
   /**
+   * If this target is associated with a library, return the source of the
+   * library's defining compilation unit; otherwise return `null`.
+   */
+  Source get librarySource;
+
+  /**
    * Return the source associated with this target, or `null` if this target is
    * not associated with a source.
    */
   Source get source;
 }
 
 /**
  * An object used to compute one or more analysis results associated with a
  * single target.
  *
  * Clients must extend this class when creating new tasks.
  */
 abstract class AnalysisTask {
   /**
+   * A queue storing the last 10 task descriptions for diagnostic purposes.
+   */
+  static final LimitedQueue<String> LAST_TASKS = new LimitedQueue<String>(10);
+
+  /**
    * A table mapping the types of analysis tasks to the number of times each
    * kind of task has been performed.
    */
   static final Map<Type, int> countMap = new HashMap<Type, int>();
 
   /**
    * A table mapping the types of analysis tasks to user tags used to collect
    * timing data for the Observatory.
    */
   static Map<Type, UserTag> tagMap = new HashMap<Type, UserTag>();
@@ skipping 59 matching lines @@
 
   /**
    * Indicates whether the task is capable of handling dependency cycles.  A
    * task that overrides this getter to return `true` must be prepared for the
    * possibility that it will be invoked with a non-`null` value of
    * [dependencyCycle], and with not all of its inputs computed.
    */
   bool get handlesDependencyCycles => false;
 
   /**
+   * Return the value of the input with the given [name], or `null` if the input
+   * value is not defined.
+   */
+  Object getOptionalInput(String name) {
+    if (inputs == null || !inputs.containsKey(name)) {
+      return null;
+    }
+    return inputs[name];
+  }
+
+  /**
    * Return the value of the input with the given [name]. Throw an exception if
    * the input value is not defined.
    */
-  Object getRequiredInput(String name) {
+  Object/*=E*/ getRequiredInput/*<E>*/(String name) {
     if (inputs == null || !inputs.containsKey(name)) {
       throw new AnalysisException("Could not $description: missing $name");
     }
-    return inputs[name];
+    return inputs[name] as Object/*=E*/;
   }
 
   /**
    * Return the source associated with the target. Throw an exception if
    * the target is not associated with a source.
    */
   Source getRequiredSource() {
     Source source = target.source;
     if (source == null) {
       throw new AnalysisException("Could not $description: missing source");
@@ skipping 20 matching lines @@
    * this task is expected to produce) or the [caughtException] should be set.
    *
    * Clients may not override this method.
    */
   void perform() {
     try {
       _safelyPerform();
     } on AnalysisException catch (exception, stackTrace) {
       caughtException = new CaughtException(exception, stackTrace);
       AnalysisEngine.instance.logger
-          .logInformation("Task failed: ${description}", caughtException);
+          .logError("Task failed: $description", caughtException);
     }
   }
 
   @override
   String toString() => description;
 
   /**
+   * Given a strongly connected component, find and return a list of
+   * [TargetedResult]s that describes a cyclic path within the cycle.  Returns
+   * null if no cyclic path is found.
+   */
+  List<TargetedResult> _findCyclicPath(List<WorkItem> cycle) {
+    WorkItem findInCycle(AnalysisTarget target, ResultDescriptor descriptor) {
+      for (WorkItem item in cycle) {
+        if (target == item.target && descriptor == item.spawningResult) {
+          return item;
+        }
+      }
+      return null;
+    }
+
+    HashSet<WorkItem> active = new HashSet<WorkItem>();
+    List<TargetedResult> path = null;
+    bool traverse(WorkItem item) {
+      if (!active.add(item)) {
+        // We've found a cycle
+        path = <TargetedResult>[];
+        return true;
+      }
+      for (TargetedResult result in item.inputTargetedResults) {
+        WorkItem item = findInCycle(result.target, result.result);
+        // Ignore edges that leave the cycle.
+        if (item != null) {
+          if (traverse(item)) {
+            // This edge is in a cycle (or leads to a cycle) so add it to the
+            // path
+            path.add(result);
+            return true;
+          }
+        }
+      }
+      // There was no cycle.
+      return false;
+    }
+
+    if (cycle.length > 0) {
+      traverse(cycle[0]);
+    }
+    return path;
+  }
+
+  /**
    * Perform this analysis task, ensuring that all exceptions are wrapped in an
    * [AnalysisException].
    *
    * Clients may not override this method.
    */
   void _safelyPerform() {
     try {
       //
+      // Store task description for diagnostics.
+      //
+      LAST_TASKS.add(description);
+
+      //
       // Report that this task is being performed.
       //
       String contextName = context.name;
       if (contextName == null) {
         contextName = 'unnamed';
       }
       AnalysisEngine.instance.instrumentationService
           .logAnalysisTask(contextName, this);
       //
       // Gather statistics on the performance of the task.
       //
       int count = countMap[runtimeType];
       countMap[runtimeType] = count == null ? 1 : count + 1;
 //      UserTag tag = tagMap.putIfAbsent(
 //          runtimeType, () => new UserTag(runtimeType.toString()));
       Stopwatch stopwatch = stopwatchMap[runtimeType];
       if (stopwatch == null) {
         stopwatch = new Stopwatch();
         stopwatchMap[runtimeType] = stopwatch;
       }
 //      UserTag previousTag = tag.makeCurrent();
 //      try {
       stopwatch.start();
       //
       // Actually perform the task.
       //
       try {
         if (dependencyCycle != null && !handlesDependencyCycles) {
-          throw new InfiniteTaskLoopException(this, dependencyCycle);
+          throw new InfiniteTaskLoopException(
+              this, dependencyCycle, _findCyclicPath(dependencyCycle));
         }
         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
  * [AnalysisTask].
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ListResultDescriptor<E> implements ResultDescriptor<List<E>> {
   /**
    * Initialize a newly created analysis result to have the given [name] and
    * [defaultValue]. If a [cachingPolicy] is provided, it will control how long
    * values associated with this result will remain in the cache.
    */
   factory ListResultDescriptor(String name, List<E> defaultValue,
-      {ResultCachingPolicy<List<E>> cachingPolicy}) = ListResultDescriptorImpl<
-      E>;
+          {ResultCachingPolicy<List<E>> cachingPolicy}) =
+      ListResultDescriptorImpl<E>;
 
   @override
   ListTaskInput<E> of(AnalysisTarget target, {bool flushOnAccess: false});
 }
 
 /**
  * A description of an input to an [AnalysisTask] that can be used to compute
  * that input.
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class ListTaskInput<E> extends TaskInput<List<E>> {
+abstract class ListTaskInput<E> implements TaskInput<List<E>> {
+  /**
+   * Return a task input that can be used to compute a flatten list whose
+   * elements are combined [subListResult]'s associated with those elements.
+   */
+  ListTaskInput/*<V>*/ toFlattenListOf/*<V>*/(
+      ListResultDescriptor/*<V>*/ subListResult);
+
   /**
    * Return a task input that can be used to compute a list whose elements are
    * the result of passing the elements of this input to the [mapper] function.
    */
-  ListTaskInput /*<V>*/ toList(UnaryFunction<E, dynamic /*<V>*/ > mapper);
+  ListTaskInput/*<V>*/ toList/*<V>*/(UnaryFunction<E, dynamic/*=V*/ > mapper);
 
   /**
    * Return a task input that can be used to compute a list whose elements are
    * [valueResult]'s associated with those elements.
    */
-  ListTaskInput /*<V>*/ toListOf(ResultDescriptor /*<V>*/ valueResult);
+  ListTaskInput/*<V>*/ toListOf/*<V>*/(ResultDescriptor/*<V>*/ valueResult);
 
   /**
    * Return a task input that can be used to compute a map whose keys are the
    * elements of this input and whose values are the result of passing the
    * corresponding key to the [mapper] function.
    */
-  MapTaskInput<E, dynamic /*V*/ > toMap(
-      UnaryFunction<E, dynamic /*<V>*/ > mapper);
+  MapTaskInput<E, dynamic/*=V*/ > toMap/*<V>*/(
+      UnaryFunction<E, dynamic/*=V*/ > mapper);
 
   /**
    * Return a task input that can be used to compute a map whose keys are the
    * elements of this input and whose values are the [valueResult]'s associated
    * with those elements.
    */
-  MapTaskInput<AnalysisTarget, dynamic /*V*/ > toMapOf(
-      ResultDescriptor /*<V>*/ valueResult);
+  MapTaskInput<AnalysisTarget, dynamic/*=V*/ > toMapOf/*<V>*/(
+      ResultDescriptor/*<V>*/ valueResult);
 }
 
 /**
  * A description of an input with a [Map] based values.
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class MapTaskInput<K, V> extends TaskInput<Map<K, V>> {
+abstract class MapTaskInput<K, V> implements TaskInput<Map<K, V>> {
   /**
    * [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(
-      BinaryFunction<K, dynamic /*element of V*/, dynamic /*<E>*/ > mapper);
+  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 Source source;
+
+  ModificationTimeMismatchError(this.source);
+}
+
+/**
  * 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 14 matching lines @@
   int measure(T object);
 }
 
 /**
  * A description of an analysis result that can be computed by an [AnalysisTask].
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ResultDescriptor<V> {
   /**
+   * A comparator that can be used to sort result descriptors by their name.
+   */
+  static final Comparator<ResultDescriptor> SORT_BY_NAME =
+      (ResultDescriptor first, ResultDescriptor second) =>
+          first.name.compareTo(second.name);
+
+  /**
    * Initialize a newly created analysis result to have the given [name] and
    * [defaultValue].
    *
    * The given [cachingPolicy] is used to limit the total size of results
    * described by this descriptor. If no policy is specified, the results are
    * never evicted from the cache, and removed only when they are invalidated.
    */
   factory ResultDescriptor(String name, V defaultValue,
-      {ResultCachingPolicy<V> cachingPolicy}) = ResultDescriptorImpl;
+      {ResultCachingPolicy<V> cachingPolicy}) = ResultDescriptorImpl<V>;
 
   /**
    * Return the caching policy for results described by this descriptor.
    */
   ResultCachingPolicy<V> get cachingPolicy;
 
   /**
    * Return the default value for results described by this descriptor.
    */
   V get defaultValue;
@@ skipping 55 matching lines @@
 
 /**
  * A description of an [AnalysisTask].
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TaskDescriptor {
   /**
    * Initialize a newly created task descriptor to have the given [name] and to
    * describe a task that takes the inputs built using the given [inputBuilder],
-   * and produces the given [results]. The [buildTask] will be used to create
-   * the instance of [AnalysisTask] thusly described.
+   * and produces the given [results]. The [buildTask] function will be used to
+   * create the instance of [AnalysisTask] being described. If provided, the
+   * [isAppropriateFor] function will be used to determine whether the task can
+   * be used on a specific target.
    */
-  factory TaskDescriptor(
-      String name,
-      BuildTask buildTask,
-      CreateTaskInputs inputBuilder,
-      List<ResultDescriptor> results) = TaskDescriptorImpl;
+  factory TaskDescriptor(String name, BuildTask buildTask,
+      CreateTaskInputs inputBuilder, List<ResultDescriptor> results,
+      {SuitabilityFor suitabilityFor}) = TaskDescriptorImpl;
 
   /**
    * Return the builder used to build the inputs to the task.
    */
   CreateTaskInputs get createTaskInputs;
 
   /**
    * Return the name of the task being described.
    */
   String get name;
 
   /**
    * Return a list of the analysis results that will be computed by this task.
    */
   List<ResultDescriptor> get results;
 
   /**
    * Create and return a task that is described by this descriptor that can be
    * used to compute results based on the given [inputs].
    */
   AnalysisTask createTask(AnalysisContext context, AnalysisTarget target,
       Map<String, dynamic> inputs);
+
+  /**
+   * Return an indication of how suitable this task is for the given [target].
+   */
+  TaskSuitability suitabilityFor(AnalysisTarget target);
 }
 
 /**
  * A description of an input to an [AnalysisTask] that can be used to compute
  * that input.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TaskInput<V> {
   /**
    * Create and return a builder that can be used to build this task input.
    */
   TaskInputBuilder<V> createBuilder();
 
   /**
    * Return a task input that can be used to compute a list whose elements are
    * the result of passing the result of this input to the [mapper] function.
    */
-  ListTaskInput /*<E>*/ mappedToList(List /*<E>*/ mapper(V value));
+  ListTaskInput/*<E>*/ mappedToList/*<E>*/(List/*<E>*/ mapper(V value));
 }
 
 /**
  * An object used to build the value associated with a single [TaskInput].
  *
  * All builders work by requesting one or more results (each result being
  * associated with a target). The interaction pattern is modeled after the class
  * [Iterator], in which the method [moveNext] is invoked to move from one result
  * request to the next. The getters [currentResult] and [currentTarget] are used
  * to get the result and target of the current request. The value of the result
@@ skipping 59 matching lines @@
    * It is safe to invoke [moveNext] after it has returned `false`. In this case
    * [moveNext] has no effect and will again return `false`.
    *
    * Throws a [StateError] if the value of the current result has not been
    * provided using [currentValue].
    */
   bool moveNext();
 }
 
 /**
+ * An indication of how suitable a task is for a given target.
+ */
+enum TaskSuitability { NONE, LOWEST, HIGHEST }
+
+/**
  * [WorkManager]s are used to drive analysis.
  *
  * They know specific of the targets and results they care about,
  * so they can request analysis results in optimal order.
  *
  * Clients may implement this class when implementing plugins.
  */
 abstract class WorkManager {
   /**
    * Notifies the manager about changes in the explicit source list.
@@ skipping 72 matching lines @@
   /**
    * A work should be done, but without any special urgency.
    */
   NORMAL,
 
   /**
    * Nothing to do.
    */
   NONE
 }