Include more errors when computing complete list

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';
 
 /**
  * A function that converts an object of the type [B] into a [TaskInput].
  * This is used, for example, by a [ListToListTaskInput] to create task inputs
  * for each value in a list of values.
  */
 typedef TaskInput<E> GenerateTaskInputs<B, E>(B object);
 
 /**
+ * A function that maps one [value] to another value.
+ */
+typedef R Mapper<P, R>(P value);
+
+/**
  * An input to an [AnalysisTask] that is computed by accessing a single result
  * defined on a single target.
  */
 class ListTaskInputImpl<E> extends SimpleTaskInput<List<E>>
     with ListTaskInputMixin<E> implements ListTaskInput<E> {
   /**
    * Initialize a newly created task input that computes the input by accessing
    * the given [result] associated with the given [target].
    */
   ListTaskInputImpl(AnalysisTarget target, ResultDescriptor<List<E>> result)
@@ skipping 144 matching lines @@
  *
  * First the [base] task input is used to compute a [Map]-valued result.
  * The values of the [Map] must be [List]s.
  *
  * The given [mapper] is used to transform each key / value pair of the [Map]
  * into task inputs.
  *
  * Finally, each of the task inputs are used to access analysis results,
  * and the list of the results is used as the input.
  */
-class MapToFlattenListTaskInput<K, V, E> implements TaskInput<List<E>> {
+class MapToFlattenListTaskInput<K, V, E> extends TaskInputImpl<List<E>> {
   final MapTaskInput<K, List<V>> base;
   final BinaryFunction<K, V, E> mapper;
 
   MapToFlattenListTaskInput(this.base, this.mapper);
 
   @override
   TaskInputBuilder<List<E>> createBuilder() {
     return new MapToFlattenListTaskInputBuilder<K, V, E>(base, mapper);
   }
 }
@@ skipping 92 matching lines @@
       K key = keyIterator.current;
       valueIterator = baseMap[key].iterator;
       return moveNext();
     }
     // No more Map values/keys to transform.
     return false;
   }
 }
 
 /**
+ * An input to an [AnalysisTask] that is computed by mapping the value of
+ * another task input to a list of values.
+ */
+class ObjectToListTaskInput<E> extends TaskInputImpl with ListTaskInputMixin<E>
+    implements ListTaskInput<E> {
+  /**
+   * The input used to compute the value to be mapped.
+   */
+  final TaskInput baseInput;
+
+  /**
+   * The function used to map the value of the base input to the list of values.
+   */
+  final Mapper<Object, List<E>> mapper;
+
+  /**
+   * Initialize a newly created task input that computes the input by accessing
+   * the given [result] associated with the given [target].
+   */
+  ObjectToListTaskInput(this.baseInput, this.mapper);
+
+  @override
+  TaskInputBuilder<List<E>> createBuilder() =>
+      new ObjectToListTaskInputBuilder<E>(this);
+
+  @override
+  ListTaskInput /*<V>*/ toListOf(ResultDescriptor /*<V>*/ valueResult) {
+    return new ListToListTaskInput<E, dynamic /*V*/ >(
+        this, valueResult.of as dynamic);
+  }
+
+  @override
+  MapTaskInput<AnalysisTarget, dynamic /*V*/ > toMapOf(
+      ResultDescriptor /*<V>*/ valueResult) {
+    return new ListToMapTaskInput<AnalysisTarget, dynamic /*V*/ >(
+        this, valueResult.of);
+  }
+}
+
+/**
+ * A [TaskInputBuilder] used to build an input based on a [SimpleTaskInput].
+ */
+class ObjectToListTaskInputBuilder<E> implements TaskInputBuilder<List<E>> {
+  /**
+   * The input being built.
+   */
+  final ObjectToListTaskInput<E> input;
+
+  /**
+   * The builder created by the input.
+   */
+  TaskInputBuilder builder;
+
+  /**
+   * The value of the input being built, or `null` if the value hasn't been set
+   * yet or if no result is available ([currentValueNotAvailable] was called).
+   */
+  List<E> _inputValue = null;
+
+  /**
+   * Initialize a newly created task input builder that computes the result
+   * specified by the given [input].
+   */
+  ObjectToListTaskInputBuilder(this.input) {
+    builder = input.baseInput.createBuilder();
+  }
+
+  @override
+  ResultDescriptor get currentResult {
+    if (builder == null) {
+      return null;
+    }
+    return builder.currentResult;
+  }
+
+  @override
+  AnalysisTarget get currentTarget {
+    if (builder == null) {
+      return null;
+    }
+    return builder.currentTarget;
+  }
+
+  @override
+  void set currentValue(Object value) {
+    if (builder == null) {
+      throw new StateError(
+          'Cannot set the result value when there is no current result');
+    }
+    builder.currentValue = value;
+  }
+
+  @override
+  List<E> get inputValue {
+    if (builder != null) {
+      throw new StateError('Result value has not been created');
+    }
+    return _inputValue;
+  }
+
+  @override
+  void currentValueNotAvailable() {
+    if (builder == null) {
+      throw new StateError(
+          'Cannot set the result value when there is no current result');
+    }
+    builder.currentValueNotAvailable();
+  }
+
+  @override
+  bool moveNext() {
+    if (builder == null) {
+      return false;
+    } else if (builder.moveNext()) {
+      return true;
+    } else {
+      // This might not be the right semantics. If the value could not be
+      // computed then we pass the resulting `null` in to the mapper function.
+      // Unfortunately, we cannot tell the difference between a `null` that's
+      // there because no value could be computed and a `null` that's there
+      // because that's what *was* computed.
+      _inputValue = input.mapper(builder.inputValue);
+      builder = null;
+      return false;
+    }
+  }
+}
+
+/**
  * An input to an [AnalysisTask] that is computed by accessing a single result
  * defined on a single target.
  */
-class SimpleTaskInput<V> implements TaskInput<V> {
+class SimpleTaskInput<V> extends TaskInputImpl<V> {
   /**
    * The target on which the result is defined.
    */
   final AnalysisTarget target;
 
   /**
    * The result to be accessed.
    */
   final ResultDescriptor<V> result;
 
@@ skipping 99 matching lines @@
       if (!_resultSet) {
         throw new StateError(
             'The value of the current result must be set before moving to the next result.');
       }
       _state = _AFTER;
       return false;
     }
   }
 }
 
+abstract class TaskInputImpl<V> implements TaskInput<V> {
+  @override
+  ListTaskInput /*<E>*/ mappedToList(List /*<E>*/ mapper(V value)) {
+    return new ObjectToListTaskInput(this, mapper);
+  }
+}
+
 /**
  * A [TaskInputBuilder] used to build an input based on one or more other task
  * inputs. The task inputs to be built are specified by a table mapping the name
  * of the input to the task used to access the input's value.
  */
 class TopLevelTaskInputBuilder
     implements TaskInputBuilder<Map<String, Object>> {
   /**
    * The descriptors describing the inputs to be built.
    */
@@ skipping 110 matching lines @@
   }
 }
 
 /**
  * An input to an [AnalysisTask] that is computed by the following steps. First
  * another (base) task input is used to compute a [List]-valued result. An input
  * generator function is then used to map each element of that list to a task
  * input. Finally, each of the task inputs are used to access analysis results,
  * and a collection of the analysis results is used as the input to the task.
  */
-abstract class _ListToCollectionTaskInput<B, E, C> implements TaskInput<C> {
+abstract class _ListToCollectionTaskInput<B, E, C> extends TaskInputImpl<C> {
   /**
    * The accessor used to access the list of elements being mapped.
    */
   final TaskInput<List<B>> baseAccessor;
 
   /**
    * The function used to convert an element in the list returned by the
    * [baseAccessor] to a task input.
    */
   final GenerateTaskInputs<B, E> generateTaskInputs;
@@ skipping 130 matching lines @@
       return false;
     }
     _baseListElement = _baseList[_baseListIndex];
     currentBuilder = input.generateTaskInputs(_baseListElement).createBuilder();
     return currentBuilder.moveNext();
   }
 
   void _addResultElement(B baseElement, E resultElement);
   void _initResultValue();
 }