Generate the proper error when a constant refers to itself.

pkg/analyzer/test/src/task/driver_test.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 test.src.task.driver_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
     hide
         AnalysisCache,
@@ skipping 436 matching lines @@
       expect(workOrder, priorityTarget ? isNotNull : isNull);
     } else {
       expect(workOrder, isNotNull);
     }
   }
 }
 
 @reflectiveTest
 class CycleAwareDependencyWalkerTest {
   void checkGraph(Map<int, List<int>> graph, int startingNode,
-      List<List<int>> expectedResults) {
+      List<StronglyConnectedComponent<int>> expectedResults) {
     List<Set<int>> expectedResultsDisregardingOrder =
-        expectedResults.map((nodes) => nodes.toSet()).toList();
+        expectedResults.map((component) => component.nodes.toSet()).toList();
+    List<bool> expectedCycleIndicators =
+        expectedResults.map((component) => component.containsCycle).toList();
     List<Set<int>> results = <Set<int>>[];
+    List<bool> cycleIndicators = <bool>[];
     _TestCycleAwareDependencyWalker walker =
         new _TestCycleAwareDependencyWalker(graph, startingNode);
     while (true) {
-      List<int> nextResult = walker.getNextStronglyConnectedComponent();
-      if (nextResult == null) {
+      StronglyConnectedComponent<int> nextStronglyConnectedComponent =
+          walker.getNextStronglyConnectedComponent();
+      if (nextStronglyConnectedComponent == null) {
         break;
       }
-      results.add(nextResult.toSet());
-      walker.evaluatedNodes.addAll(nextResult);
+      results.add(nextStronglyConnectedComponent.nodes.toSet());
+      cycleIndicators.add(nextStronglyConnectedComponent.containsCycle);
+      walker.evaluatedNodes.addAll(nextStronglyConnectedComponent.nodes);
     }
     expect(results, expectedResultsDisregardingOrder);
+    expect(cycleIndicators, expectedCycleIndicators);
   }
 
+  StronglyConnectedComponent<int> cycle(List<int> nodes) =>
+      new StronglyConnectedComponent(nodes, true);
+
+  StronglyConnectedComponent<int> singleton(int node) =>
+      new StronglyConnectedComponent(<int>[node], false);
+
   void test_complex_graph() {
     checkGraph({
       1: [2, 3],
       2: [3, 4],
       3: [],
       4: [3, 5],
       5: [2, 6],
       6: [3, 4]
-    }, 1, [[3], [2, 4, 5, 6], [1]]);
+    }, 1, [singleton(3), cycle([2, 4, 5, 6]), singleton(1)]);
   }
 
   void test_cycle_depends_on_other_nodes() {
-    checkGraph({1: [2, 3], 2: [4, 1], 3: [], 4: []}, 1, [[4], [3], [1, 2]]);
+    checkGraph({1: [2, 3], 2: [4, 1], 3: [], 4: []}, 1, [
+      singleton(4),
+      singleton(3),
+      cycle([1, 2])
+    ]);
   }
 
   void test_initial_node_depends_on_cycle() {
-    checkGraph({1: [2], 2: [3], 3: [2]}, 1, [[2, 3], [1]]);
+    checkGraph({1: [2], 2: [3], 3: [2]}, 1, [cycle([2, 3]), singleton(1)]);
   }
 
   void test_simple_cycle() {
-    checkGraph({1: [2], 2: [1]}, 1, [[1, 2]]);
+    checkGraph({1: [2], 2: [1]}, 1, [cycle([1, 2])]);
   }
 
   void test_simple_dependency_chain() {
-    checkGraph({1: [2], 2: []}, 1, [[2], [1]]);
+    checkGraph({1: [2], 2: []}, 1, [singleton(2), singleton(1)]);
   }
 
   void test_single_node() {
-    checkGraph({1: []}, 1, [[1]]);
+    checkGraph({1: []}, 1, [singleton(1)]);
+  }
+
+  void test_single_node_cycle() {
+    checkGraph({1: [1]}, 1, [cycle([1])]);
   }
 }
 
 @reflectiveTest
 class WorkItemTest extends AbstractDriverTest {
   test_buildTask_complete() {
     AnalysisTarget target = new TestSource();
     TaskDescriptor descriptor = new TaskDescriptor('task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {}, [new ResultDescriptor('output', null)]);
@@ skipping 147 matching lines @@
         return dependency;
       }
     }
     return null;
   }
 }
 
 class _WorkManagerMock extends TypedMock implements WorkManager {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }