Properly handle circular references among constants in the task model.

pkg/analyzer/lib/src/task/dart.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.dart;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/general.dart';
 import 'package:analyzer/src/task/model.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * The [ResultCachingPolicy] for ASTs.
  */
 const ResultCachingPolicy AST_CACHING_POLICY =
@@ skipping 1746 matching lines @@
       <ResultDescriptor>[CONSTANT_VALUE]);
 
   ComputeConstantValueTask(
       InternalAnalysisContext context, ConstantEvaluationTarget constant)
       : super(context, constant);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
+  bool get handlesDependencyCycles => true;
+
+  @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: DEPENDENCIES_INPUT is not needed.  It is merely a bookkeeping
     // dependency to ensure that the constants that this constant depends on
     // are computed first.
     ConstantEvaluationTarget constant = target;
     AnalysisContext context = constant.context;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
-    // Compute the value of the constant.
+    // Compute the value of the constant, or report an error if there was a
+    // cycle.
     //
-    new ConstantEvaluationEngine(typeProvider, context.declaredVariables)
-        .computeConstantValue(constant);
+    ConstantEvaluationEngine constantEvaluationEngine =
+        new ConstantEvaluationEngine(typeProvider, context.declaredVariables);
+    if (dependencyCycle == null) {
+      constantEvaluationEngine.computeConstantValue(constant);
+    } else {
+      List<ConstantEvaluationTarget> constantsInCycle =
+          <ConstantEvaluationTarget>[];
+      for (WorkItem workItem in dependencyCycle) {
+        if (workItem.descriptor == DESCRIPTOR) {
+          constantsInCycle.add(workItem.target);
+        }
+      }
+      assert(constantsInCycle.isNotEmpty);
+      constantEvaluationEngine.generateCycleError(constantsInCycle, constant);
+    }
     //
     // Record outputs.
     //
     outputs[CONSTANT_VALUE] = constant;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [target].
@@ skipping 1424 matching lines @@
   final Source target;
 
   _ExportSourceClosureTaskInput(this.target);
 
   @override
   TaskInputBuilder<List<Source>> createBuilder() =>
       new _SourceClosureTaskInputBuilder(target, _SourceClosureKind.EXPORT);
 }
 
 /**
- * The kind of the source closure to build.
- */
-enum _SourceClosureKind { IMPORT, EXPORT, IMPORT_EXPORT }
-
-/**
  * A [TaskInput] whose value is a list of library sources imported or exported,
  * directly or indirectly by the target [Source].
  */
 class _ImportExportSourceClosureTaskInput implements TaskInput<List<Source>> {
   final Source target;
 
   _ImportExportSourceClosureTaskInput(this.target);
 
   @override
   TaskInputBuilder<List<Source>> createBuilder() =>
       new _SourceClosureTaskInputBuilder(
           target, _SourceClosureKind.IMPORT_EXPORT);
 }
 
 /**
  * A [TaskInput] whose value is a list of library sources imported directly
  * or indirectly by the target [Source].
  */
 class _ImportSourceClosureTaskInput implements TaskInput<List<Source>> {
   final Source target;
 
   _ImportSourceClosureTaskInput(this.target);
 
   @override
   TaskInputBuilder<List<Source>> createBuilder() =>
       new _SourceClosureTaskInputBuilder(target, _SourceClosureKind.IMPORT);
 }
 
 /**
+ * The kind of the source closure to build.
+ */
+enum _SourceClosureKind { IMPORT, EXPORT, IMPORT_EXPORT }
+
+/**
  * A [TaskInputBuilder] to build values for [_ImportSourceClosureTaskInput].
  */
 class _SourceClosureTaskInputBuilder implements TaskInputBuilder<List<Source>> {
   final _SourceClosureKind kind;
   final Set<LibraryElement> _libraries = new HashSet<LibraryElement>();
   final Set<Source> _newSources = new HashSet<Source>();
 
   Source currentTarget;
 
   _SourceClosureTaskInputBuilder(Source librarySource, this.kind) {
@@ skipping 22 matching lines @@
       }
     }
   }
 
   @override
   List<Source> get inputValue {
     return _libraries.map((LibraryElement library) => library.source).toList();
   }
 
   @override
+  void currentValueNotAvailable() {
+    // Nothing needs to be done.  moveNext() will simply go on to the next new
+    // source.
+  }
+
+  @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }