Add toMap / toMapOf / toList

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);
 
 /**
+ * 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>>
+    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)
+      : super(target, result);
+
+  @override
+  TaskInput<List /*<V>*/ > toList(UnaryFunction<E, Object /*<V>*/ > mapper) {
+    return new ListToListTaskInput<E, Object /*V*/ >(this, mapper);
+  }
+
+  @override
+  TaskInput<List /*<V>*/ > toListOf(ResultDescriptor /*<V>*/ valueResult) {
+    return (this as ListTaskInputImpl<AnalysisTarget>).toList(valueResult.of);
+  }
+
+  @override
+  TaskInput<Map<E, Object /*V*/ >> toMap(
+      UnaryFunction<E, Object /*<V>*/ > mapper) {
+    return new ListToMapTaskInput<E, Object /*V*/ >(this, mapper);
+  }
+
+  @override
+  TaskInput<Map<AnalysisTarget, Object /*V*/ >> toMapOf(
+      ResultDescriptor /*<V>*/ valueResult) {
+    return (this as ListTaskInputImpl<AnalysisTarget>).toMap(valueResult.of);
+  }
+}
+
+/**
  * 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 ListToListTaskInput<B, E>
     extends _ListToCollectionTaskInput<B, E, List<E>> {
   /**
    * Initialize a result accessor to use the given [baseAccessor] to access a
@@ skipping 449 matching lines @@
       return false;
     }
     _baseListElement = _baseList[_baseListIndex];
     currentBuilder = input.generateTaskInputs(_baseListElement).createBuilder();
     return currentBuilder.moveNext();
   }
 
   void _addResultElement(B baseElement, E resultElement);
   void _initResultValue();
 }