Properly handle circular references among constants in the task model.

pkg/analyzer/lib/src/task/inputs.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.inputs;
 
 import 'dart:collection';
 
 import 'package:analyzer/task/model.dart';
 
@@ skipping 218 matching lines @@
   @override
   void set currentValue(Object value) {
     if (currentBuilder == null) {
       throw new StateError(
           'Cannot set the result value when there is no current result');
     }
     currentBuilder.currentValue = value;
   }
 
   @override
+  void currentValueNotAvailable() {
+    if (currentBuilder == null) {
+      throw new StateError(
+          'Cannot set the result value when there is no current result');
+    }
+    currentBuilder.currentValueNotAvailable();
+  }
+
+  @override
   bool moveNext() {
     // Prepare base Map.
     if (baseMap == null) {
       if (currentBuilder.moveNext()) {
         return true;
       }
       baseMap = currentBuilder.inputValue;
+      if (baseMap == null) {
+        // No base map could be computed due to a circular dependency.  Use an
+        // empty map so that no further results will be computed.
+        baseMap = {};
+      }
       keyIterator = baseMap.keys.iterator;
       // Done with this builder.
       currentBuilder = null;
     }
     // Prepare the next result value.
     if (currentBuilder != null) {
       if (currentBuilder.moveNext()) {
         return true;
       }
       // Add the result value for the current Map key/value.
       E resultValue = currentBuilder.inputValue;
-      inputValue.add(resultValue);
+      if (resultValue != null) {
+        inputValue.add(resultValue);
+      }
       // Done with this builder.
       currentBuilder = null;
     }
     // Move to the next Map value.
     if (valueIterator != null && valueIterator.moveNext()) {
       K key = keyIterator.current;
       V value = valueIterator.current;
       currentBuilder = mapper(key, value).createBuilder();
       return moveNext();
     }
@@ skipping 54 matching lines @@
    * result.
    */
   static const _AFTER = 1;
 
   /**
    * The input being built.
    */
   final SimpleTaskInput<V> input;
 
   /**
-   * The value of the input being built.
+   * The value of the input being built.  `null` if the value hasn't been set
+   * yet, or if no result is available ([currentValueNotAvailable] was called).
    */
   V _resultValue = null;
 
   /**
    * The state of the builder.
    */
   int _state = _BEFORE;
 
   /**
    * A flag indicating whether the result value was explicitly set.
@@ skipping 24 matching lines @@
 
   @override
   V get inputValue {
     if (_state != _AFTER) {
       throw new StateError('Result value has not been created');
     }
     return _resultValue;
   }
 
   @override
+  void currentValueNotAvailable() {
+    if (_state != _AT) {
+      throw new StateError(
+          'Cannot set the result value when there is no current result');
+    }
+    _resultValue = null;
+    _resultSet = true;
+  }
+
+  @override
   bool moveNext() {
     if (_state == _BEFORE) {
       _state = _AT;
       return true;
     } else {
       if (!_resultSet) {
         throw new StateError(
             'The value of the current result must be set before moving to the next result.');
       }
       _state = _AFTER;
@@ skipping 76 matching lines @@
     }
     return inputs;
   }
 
   /**
    * Assuming that there is a current input, return its name.
    */
   String get _currentName => inputNames[nameIndex];
 
   @override
+  void currentValueNotAvailable() {
+    if (currentBuilder == null) {
+      throw new StateError(
+          'Cannot set the result value when there is no current result');
+    }
+    currentBuilder.currentValueNotAvailable();
+  }
+
+  @override
   bool moveNext() {
     if (nameIndex >= inputNames.length) {
       // We have already computed all of the results, so just return false.
       return false;
     }
     if (nameIndex < 0) {
       // This is the first time moveNext has been invoked, so we just determine
       // whether there are any results to be computed.
       nameIndex = 0;
     } else {
       if (currentBuilder.moveNext()) {
         // We are still working on building the value associated with the
         // current name.
         return true;
       }
-      inputs[_currentName] = currentBuilder.inputValue;
+      if (currentBuilder.inputValue != null) {
+        inputs[_currentName] = currentBuilder.inputValue;
+      }
       nameIndex++;
     }
     if (nameIndex >= inputNames.length) {
       // There is no next value, so we're done.
       return false;
     }
     currentBuilder = inputDescriptors[_currentName].createBuilder();
     // NOTE: This assumes that every builder will require at least one result
     // value to be created. If that assumption is every broken, this method will
     // need to be changed to advance until we find a builder that does require
@@ skipping 99 matching lines @@
     }
     return _resultValue;
   }
 
   /**
    * The list of values being built.
    */
   C get _resultValue;
 
   @override
+  void currentValueNotAvailable() {
+    if (currentBuilder == null) {
+      throw new StateError(
+          'Cannot set the result value when there is no current result');
+    }
+    currentBuilder.currentValueNotAvailable();
+  }
+
+  @override
   bool moveNext() {
     if (currentBuilder == null) {
       if (_resultValue == null) {
         // This is the first time moveNext has been invoked, so start by
         // computing the list of values from which the results will be derived.
         currentBuilder = input.baseAccessor.createBuilder();
         return currentBuilder.moveNext();
       } else {
         // We have already computed all of the results, so just return false.
         return false;
       }
     }
     if (currentBuilder.moveNext()) {
       return true;
     }
     if (_resultValue == null) {
       // We have finished computing the list of values from which the results
       // will be derived.
       _baseList = currentBuilder.inputValue;
+      if (_baseList == null) {
+        // No base list could be computed due to a circular dependency.  Use an
+        // empty list so that no further results will be computed.
+        _baseList = [];
+      }
       _baseListIndex = 0;
       _initResultValue();
     } else {
       // We have finished computing one of the elements in the result list.
-      _addResultElement(_baseListElement, currentBuilder.inputValue);
+      if (currentBuilder.inputValue != null) {
+        _addResultElement(_baseListElement, currentBuilder.inputValue);
+      }
       _baseListIndex++;
     }
     if (_baseListIndex >= _baseList.length) {
       currentBuilder = null;
       return false;
     }
     _baseListElement = _baseList[_baseListIndex];
     currentBuilder = input.generateTaskInputs(_baseListElement).createBuilder();
     return currentBuilder.moveNext();
   }
 
   void _addResultElement(B baseElement, E resultElement);
   void _initResultValue();
 }