Generate the proper error when a constant refers to itself.

pkg/analyzer/lib/src/task/driver.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.task.driver;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 330 matching lines @@
    * [skipInputs], and return it.  If [node] has no further inputs, return
    * `null`.
    */
   Node getNextInput(Node node, List<Node> skipInputs);
 
   /**
    * Determine the next strongly connected component in the graph, and return
    * it.  The client is expected to evaluate this component before calling
    * [getNextStronglyConnectedComponent] again.
    */
-  List<Node> getNextStronglyConnectedComponent() {
+  StronglyConnectedComponent<Node> getNextStronglyConnectedComponent() {
     while (_currentIndices.isNotEmpty) {
       Node nextUnevaluatedInput = getNextInput(_path[_currentIndices.last],
           _provisionalDependencies[_currentIndices.last]);
       assert(!_provisionalDependencies[_currentIndices.last]
           .contains(nextUnevaluatedInput));
       if (nextUnevaluatedInput != null) {
         // TODO(paulberry): the call to _path.indexOf makes the algorithm
         // O(n^2) in the depth of the dependency graph.  If this becomes a
         // problem, consider maintaining a map from node to index.
         int previousIndex = _path.indexOf(nextUnevaluatedInput);
@@ skipping 25 matching lines @@
       } else {
         // The node has no more inputs.  Figure out if there are any more nodes
         // in the current strongly connected component that need to have their
         // indices examined.
         _currentIndices.removeLast();
         if (_currentIndices.isEmpty ||
             _currentIndices.last < _contractedPath.last) {
           // No more nodes in the current strongly connected component need to
           // have their indices examined.  We can now yield this component to
           // the caller.
-          List<Node> component = _path.sublist(_contractedPath.last);
+          List<Node> nodes = _path.sublist(_contractedPath.last);
+          bool containsCycle = nodes.length > 1;
+          if (!containsCycle) {
+            if (_provisionalDependencies.last.isNotEmpty) {
+              containsCycle = true;
+            }
+          }
           _path.length = _contractedPath.last;
           _provisionalDependencies.length = _contractedPath.last;
           _contractedPath.removeLast();
-          return component;
+          return new StronglyConnectedComponent<Node>(nodes, containsCycle);
         } else {
           // At least one node in the current strongly connected component
           // still needs to have its inputs examined.  So loop and allow the
           // inputs to be examined.
           continue;
         }
       }
     }
     // No further strongly connected components found.
     return null;
@@ skipping 27 matching lines @@
 
   /**
    * Initialize a newly created exception to represent a failed attempt to
    * perform the given [task] due to the given [dependencyCycle].
    */
   InfiniteTaskLoopException(AnalysisTask task, this.dependencyCycle) : super(
           'Infinite loop while performing task ${task.descriptor.name} for ${task.target}');
 }
 
 /**
+ * Object used by CycleAwareDependencyWalker to report a single strongly
+ * connected component of nodes.
+ */
+class StronglyConnectedComponent<Node> {
+  /**
+   * The nodes contained in the strongly connected component.
+   */
+  final List<Node> nodes;
+
+  /**
+   * Indicates whether the strongly component contains any cycles.  Note that
+   * if [nodes] has multiple elements, this will always be `true`.  However, if
+   * [nodes] has exactly one element, this may be either `true` or `false`
+   * depending on whether the node has a dependency on itself.
+   */
+  final bool containsCycle;
+
+  StronglyConnectedComponent(this.nodes, this.containsCycle);
+}
+
+/**
  * A description of a single anaysis task that can be performed to advance
  * analysis.
  */
 class WorkItem {
   /**
    * The context in which the task will be performed.
    */
   final InternalAnalysisContext context;
 
   /**
@@ skipping 229 matching lines @@
   }
 
   @override
   bool moveNext() {
     if (currentItems != null && currentItems.length > 1) {
       // Yield more items.
       currentItems.removeLast();
       return true;
     } else {
       // Get a new strongly connected component.
-      currentItems = _dependencyWalker.getNextStronglyConnectedComponent();
-      if (currentItems == null) {
+      StronglyConnectedComponent<WorkItem> nextStronglyConnectedComponent =
+          _dependencyWalker.getNextStronglyConnectedComponent();
+      if (nextStronglyConnectedComponent == null) {
+        currentItems = null;
         return false;
       }
-      if (currentItems.length > 1) {
+      currentItems = nextStronglyConnectedComponent.nodes;
+      if (nextStronglyConnectedComponent.containsCycle) {
         // A cycle has been found.
         for (WorkItem item in currentItems) {
           item.dependencyCycle = currentItems.toList();
         }
       } else {
         assert(currentItems.length == 1);
       }
       return true;
     }
   }
@@ skipping 34 matching lines @@
   final TaskManager taskManager;
 
   _WorkOrderDependencyWalker(this.taskManager, WorkItem startingNode)
       : super(startingNode);
 
   @override
   WorkItem getNextInput(WorkItem node, List<WorkItem> skipInputs) {
     return node.gatherInputs(taskManager, skipInputs);
   }
 }