Properly handle circular references among constants in the task model.

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 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.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
@@ skipping 87 matching lines @@
   Map<ResultDescriptor, dynamic> outputs =
       new HashMap<ResultDescriptor, dynamic>();
 
   /**
    * The exception that was thrown while performing this task, or `null` if the
    * task completed successfully.
    */
   CaughtException caughtException;
 
   /**
+   * If a dependency cycle was found while computing the inputs for the task,
+   * the set of [WorkItem]s contained in the cycle (if there are overlapping
+   * cycles, this is the set of all [WorkItem]s in the entire strongly
+   * connected component).  Otherwise, `null`.
+   */
+  List<WorkItem> dependencyCycle;
+
+  /**
    * Initialize a newly created task to perform analysis within the given
    * [context] in order to produce results for the given [target].
    */
   AnalysisTask(this.context, this.target);
 
   /**
    * Return a textual description of this task.
    */
   String get description;
 
   /**
    * Return the descriptor that describes this task.
    */
   TaskDescriptor get descriptor;
 
   /**
+   * 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]. Throw an exception if
    * the input value is not defined.
    */
   Object getRequiredInput(String name) {
     if (inputs == null || !inputs.containsKey(name)) {
       throw new AnalysisException("Could not $description: missing $name");
     }
     return inputs[name];
   }
 
@@ skipping 67 matching lines @@
       Stopwatch stopwatch = stopwatchMap[runtimeType];
       if (stopwatch == null) {
         stopwatch = new Stopwatch();
         stopwatchMap[runtimeType] = stopwatch;
       }
       stopwatch.start();
       //
       // Actually perform the task.
       //
       try {
+        if (dependencyCycle != null && !handlesDependencyCycles) {
+          throw new InfiniteTaskLoopException(this, dependencyCycle);
+        }
         internalPerform();
       } finally {
         stopwatch.stop();
       }
     } on AnalysisException {
       rethrow;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           'Unexpected exception while performing $description',
           new CaughtException(exception, stackTrace));
@@ skipping 222 matching lines @@
    * Throws a [StateError] if [moveNext] has not been invoked or if the last
    * invocation of [moveNext] returned `false`.
    */
   void set currentValue(Object value);
 
   /**
    * Return the [value] that was computed by this builder.
    *
    * Throws a [StateError] if [moveNext] has not been invoked or if the last
    * invocation of [moveNext] returned `true`.
+   *
+   * Returns `null` if no value could be computed due to a circular dependency.
    */
   V get inputValue;
 
   /**
+   * Record that no value is available for the current result, due to a
+   * circular dependency.
+   *
+   * Throws a [StateError] if [moveNext] has not been invoked or if the last
+   * invocation of [moveNext] returned `false`.
+   */
+  void currentValueNotAvailable();
+
+  /**
    * Move to the next result that needs to be computed in order to build the
    * inputs for a task. Return `true` if there is another result that needs to
    * be computed, or `false` if the inputs have been computed.
    *
    * 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();
 }