Rename ListToX inputs.

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 arbitrary object into a [TaskInput]. This is
- * used, for example, by a [ListBasedTaskInput] to create task inputs for each
- * value in a list of values.
+ * 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<E>(Object object);
+typedef TaskInput<E> GenerateTaskInputs<B, E>(B object);
 
 /**
  * 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 the list of the analysis results is used as the input to the task.
  */
-class ListBasedTaskInput<B, E>
-    extends _CollectionBasedTaskInput<B, E, List<E>> {
+class ListToListTaskInput<B, E>
+    extends _ListToCollectionTaskInput<B, E, List<E>> {
   /**
    * Initialize a result accessor to use the given [baseAccessor] to access a
    * list of values that can be passed to the given [generateTaskInputs] to
    * generate a list of task inputs that can be used to access the elements of
    * the input being accessed.
    */
-  ListBasedTaskInput(
-      TaskInput<List<B>> baseAccessor, GenerateTaskInputs<E> generateTaskInputs)
+  ListToListTaskInput(TaskInput<List<B>> baseAccessor,
+      GenerateTaskInputs<B, E> generateTaskInputs)
       : super(baseAccessor, generateTaskInputs);
 
   @override
   TaskInputBuilder<List<E>> createBuilder() =>
-      new ListBasedTaskInputBuilder<B, E>(this);
+      new ListToListTaskInputBuilder<B, E>(this);
 }
 
 /**
- * A [TaskInputBuilder] used to build an input based on a [ListBasedTaskInput].
+ * A [TaskInputBuilder] used to build an input based on a [ListToListTaskInput].
  */
-class ListBasedTaskInputBuilder<B, E>
-    extends _CollectionBasedTaskInputBuilder<B, E, List<E>> {
+class ListToListTaskInputBuilder<B, E>
+    extends _ListToCollectionTaskInputBuilder<B, E, List<E>> {
   /**
    * The list of values being built.
    */
   List<E> _resultValue;
 
   /**
    * Initialize a newly created task input builder that computes the result
    * specified by the given [input].
    */
-  ListBasedTaskInputBuilder(ListBasedTaskInput<B, E> input) : super(input);
+  ListToListTaskInputBuilder(ListToListTaskInput<B, E> input) : super(input);
 
   @override
   void _addResultElement(B baseElement, E resultElement) {
     _resultValue.add(resultElement);
   }
 
   @override
   void _initResultValue() {
     _resultValue = <E>[];
   }
 }
 
 /**
  * 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 the map of the base elements to the analysis results is used as the
  * input to the task.
  */
-class MapBasedTaskInput<B, E>
-    extends _CollectionBasedTaskInput<B, E, Map<B, E>> {
+class ListToMapTaskInput<B, E>
+    extends _ListToCollectionTaskInput<B, E, Map<B, E>> {
   /**
    * Initialize a result accessor to use the given [baseAccessor] to access a
    * list of values that can be passed to the given [generateTaskInputs] to
    * generate a list of task inputs that can be used to access the elements of
    * the input being accessed.
    */
-  MapBasedTaskInput(
-      TaskInput<List<B>> baseAccessor, GenerateTaskInputs<E> generateTaskInputs)
+  ListToMapTaskInput(TaskInput<List<B>> baseAccessor,
+      GenerateTaskInputs<B, E> generateTaskInputs)
       : super(baseAccessor, generateTaskInputs);
 
   @override
   TaskInputBuilder<Map<B, E>> createBuilder() =>
-      new MapBasedTaskInputBuilder<B, E>(this);
+      new ListToMapTaskInputBuilder<B, E>(this);
 }
 
 /**
- * A [TaskInputBuilder] used to build an input based on a [MapBasedTaskInput].
+ * A [TaskInputBuilder] used to build an input based on a [ListToMapTaskInput].
  */
-class MapBasedTaskInputBuilder<B, E>
-    extends _CollectionBasedTaskInputBuilder<B, E, Map<B, E>> {
+class ListToMapTaskInputBuilder<B, E>
+    extends _ListToCollectionTaskInputBuilder<B, E, Map<B, E>> {
   /**
    * The map being built.
    */
   Map<B, E> _resultValue;
 
   /**
    * Initialize a newly created task input builder that computes the result
    * specified by the given [input].
    */
-  MapBasedTaskInputBuilder(MapBasedTaskInput<B, E> input) : super(input);
+  ListToMapTaskInputBuilder(ListToMapTaskInput<B, E> input) : super(input);
 
   @override
   void _addResultElement(B baseElement, E resultElement) {
     _resultValue[baseElement] = resultElement;
   }
 
   @override
   void _initResultValue() {
     _resultValue = new HashMap<B, E>();
   }
@@ skipping 224 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 _CollectionBasedTaskInput<B, E, C> implements TaskInput<C> {
+abstract class _ListToCollectionTaskInput<B, E, C> implements TaskInput<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<E> generateTaskInputs;
+  final GenerateTaskInputs<B, E> generateTaskInputs;
 
   /**
    * Initialize a result accessor to use the given [baseAccessor] to access a
    * list of values that can be passed to the given [generateTaskInputs] to
    * generate a list of task inputs that can be used to access the elements of
    * the input being accessed.
    */
-  _CollectionBasedTaskInput(this.baseAccessor, this.generateTaskInputs);
+  _ListToCollectionTaskInput(this.baseAccessor, this.generateTaskInputs);
 }
 
 /**
- * A [TaskInputBuilder] used to build an [_CollectionBasedTaskInput].
+ * A [TaskInputBuilder] used to build an [_ListToCollectionTaskInput].
  */
-abstract class _CollectionBasedTaskInputBuilder<B, E, C>
+abstract class _ListToCollectionTaskInputBuilder<B, E, C>
     implements TaskInputBuilder<C> {
   /**
    * The input being built.
    */
-  final _CollectionBasedTaskInput<B, E, C> input;
+  final _ListToCollectionTaskInput<B, E, C> input;
 
   /**
    * The builder used to build the current result.
    */
   TaskInputBuilder currentBuilder;
 
   /**
    * The list of values computed by the [input]'s base accessor.
    */
   List<B> _baseList = null;
 
   /**
    * The index in the [_baseList] of the value for which a value is currently
    * being built.
    */
   int _baseListIndex = -1;
 
   /**
    * The element of the [_baseList] for which a value is currently being built.
    */
   B _baseListElement;
 
   /**
    * Initialize a newly created task input builder that computes the result
    * specified by the given [input].
    */
-  _CollectionBasedTaskInputBuilder(this.input);
+  _ListToCollectionTaskInputBuilder(this.input);
 
   @override
   ResultDescriptor get currentResult {
     if (currentBuilder == null) {
       return null;
     }
     return currentBuilder.currentResult;
   }
 
   @override
@@ skipping 58 matching lines @@
       return false;
     }
     _baseListElement = _baseList[_baseListIndex];
     currentBuilder = input.generateTaskInputs(_baseListElement).createBuilder();
     return currentBuilder.moveNext();
   }
 
   void _addResultElement(B baseElement, E resultElement);
   void _initResultValue();
 }