Properly handle circular references among constants in the task model.

pkg/analyzer/lib/src/generated/constant.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'dart:collection';
@@ skipping 817 matching lines @@
           // [ErrorVerifier.checkForRecursiveFactoryRedirect()]).
           break;
         }
       }
       constructor = redirectedConstructor;
     }
     return constructor;
   }
 
   /**
+   * Generate an error indicating that the given [constant] is not a valid
+   * compile-time constant because it references at least one of the constants
+   * in the given [cycle], each of which directly or indirectly references the
+   * constant.
+   */
+  void generateCycleError(Iterable<ConstantEvaluationTarget> cycle,
+      ConstantEvaluationTarget constant) {
+    if (constant is VariableElement) {
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      ErrorReporter errorReporter =
+          new ErrorReporter(errorListener, constant.source);
+      // TODO(paulberry): It would be really nice if we could extract enough
+      // information from the 'cycle' argument to provide the user with a
+      // description of the cycle.
+      errorReporter.reportErrorForElement(
+          CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT, constant, []);
+      (constant as VariableElementImpl).evaluationResult =
+          new EvaluationResultImpl(null, errorListener.errors);
+    } else if (constant is ConstructorElement) {
+      // We don't report cycle errors on constructor declarations since there
+      // is nowhere to put the error information.
+    } else {
+      // Should not happen.  Formal parameter defaults and annotations should
+      // never appear as part of a cycle because they can't be referred to.
+      assert(false);
+      AnalysisEngine.instance.logger.logError(
+          "Constant value computer trying to report a cycle error for a node of type ${constant.runtimeType}");
+    }
+  }
+
+  /**
    * If [constructor] redirects to another const constructor, return the
    * const constructor it redirects to.  Otherwise return `null`.
    */
   ConstructorElement getConstRedirectedConstructor(
       ConstructorElement constructor) {
     if (!constructor.isFactory) {
       return null;
     }
     if (identical(constructor.enclosingElement.type, typeProvider.symbolType)) {
       // The dart:core.Symbol has a const factory constructor that redirects
@@ skipping 390 matching lines @@
         referenceGraph.addEdge(constant, dependency);
       });
     }
     List<List<ConstantEvaluationTarget>> topologicalSort =
         referenceGraph.computeTopologicalSort();
     for (List<ConstantEvaluationTarget> constantsInCycle in topologicalSort) {
       if (constantsInCycle.length == 1) {
         _computeValueFor(constantsInCycle[0]);
       } else {
         for (ConstantEvaluationTarget constant in constantsInCycle) {
-          _generateCycleError(constantsInCycle, constant);
+          evaluationEngine.generateCycleError(constantsInCycle, constant);
         }
       }
     }
   }
 
   /**
    * Compute a value for the given [constant].
    */
   void _computeValueFor(ConstantEvaluationTarget constant) {
     if (!_constantsToCompute.contains(constant)) {
       // Element is in the dependency graph but should have been computed by
       // a previous stage of analysis.
       // TODO(paulberry): once we have moved over to the new task model, this
       // should only occur for constants associated with enum members.  Once
       // that happens we should add an assertion to verify that it doesn't
       // occur in any other cases.
       return;
     }
     evaluationEngine.computeConstantValue(constant);
   }
-
-  /**
-   * Generate an error indicating that the given [constant] is not a valid
-   * compile-time constant because it references at least one of the constants
-   * in the given [cycle], each of which directly or indirectly references the
-   * constant.
-   */
-  void _generateCycleError(
-      List<ConstantEvaluationTarget> cycle, ConstantEvaluationTarget constant) {
-    if (constant is VariableElement) {
-      RecordingErrorListener errorListener = new RecordingErrorListener();
-      ErrorReporter errorReporter =
-          new ErrorReporter(errorListener, constant.source);
-      // TODO(paulberry): It would be really nice if we could extract enough
-      // information from the 'cycle' argument to provide the user with a
-      // description of the cycle.
-      errorReporter.reportErrorForElement(
-          CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT, constant, []);
-      (constant as VariableElementImpl).evaluationResult =
-          new EvaluationResultImpl(null, errorListener.errors);
-    } else if (constant is ConstructorElement) {
-      // We don't report cycle errors on constructor declarations since there
-      // is nowhere to put the error information.
-    } else {
-      // Should not happen.  Formal parameter defaults and annotations should
-      // never appear as part of a cycle because they can't be referred to.
-      assert(false);
-      AnalysisEngine.instance.logger.logError(
-          "Constant value computer trying to report a cycle error for a node of type ${constant.runtimeType}");
-    }
-  }
 }
 
 /**
  * A visitor used to evaluate constant expressions to produce their compile-time
  * value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  *
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time
@@ skipping 3905 matching lines @@
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }