Resolve type hierarchies for all units of the library's import closure.

pkg/analyzer/lib/task/model.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.task.model;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/java_engine.dart';
@@ skipping 16 matching lines @@
 typedef Map<String, TaskInput> CreateTaskInputs(AnalysisTarget target);
 
 /**
  * A function that converts an object of the type [B] into a [TaskInput].
  * This is used, for example, by a [ListTaskInput] to create task inputs
  * for each value in a list of values.
  */
 typedef TaskInput<E> UnaryFunction<B, E>(B object);
 
 /**
+ * TODO

[Brian Wilkerson, 2015/04/01 22:13:08]

Did you intend to leave this TODO?

+ */
+typedef TaskInput<E> BinaryFunction<K, V, E>(K key, V value);
+
+/**
  * An [AnalysisTarget] wrapper for an [AnalysisContext].
  */
 class AnalysisContextTarget implements AnalysisTarget {
   static final AnalysisContextTarget request = new AnalysisContextTarget(null);
 
   final AnalysisContext context;
 
   AnalysisContextTarget(this.context);
 
   @override
@@ skipping 238 matching lines @@
    * Return a task input that can be used to compute a list whose elements are
    * [valueResult]'s associated with those elements.
    */
   ListTaskInput /*<V>*/ toListOf(ResultDescriptor /*<V>*/ valueResult);
 
   /**
    * Return a task input that can be used to compute a map whose keys are the
    * elements of this input and whose values are the result of passing the
    * corresponding key to the [mapper] function.
    */
-  TaskInput<Map<E, dynamic /*V*/ >> toMap(
+  MapTaskInput<E, dynamic /*V*/ > toMap(
       UnaryFunction<E, dynamic /*<V>*/ > mapper);
 
   /**
    * Return a task input that can be used to compute a map whose keys are the
    * elements of this input and whose values are the [valueResult]'s associated
    * with those elements.
    */
-  TaskInput<Map<AnalysisTarget, dynamic /*V*/ >> toMapOf(
+  MapTaskInput<AnalysisTarget, dynamic /*V*/ > toMapOf(
       ResultDescriptor /*<V>*/ valueResult);
 }
 
 /**
+ * A description of an input with a [Map] based values. TODO
+ *
+ * Clients are not expected to subtype this class.
+ */
+abstract class MapTaskInput<K, V> extends TaskInput<Map<K, V>> {
+  /**
+   * [V] must be a [List].
+   * Return a task input that can be used to compute a list whose elements are
+   * the result of passing keys [K] and the corresponding elements of [V] to
+   * the [mapper] function.
+   */
+  TaskInput<List /*<E>*/ > toFlattenList(
+      BinaryFunction<K, dynamic /*element of V*/, dynamic /*<E>*/ > mapper);
+}
+
+/**
  * A description of an analysis result that can be computed by an [AnalysisTask].
  *
  * Clients are not expected to subtype this class.
  */
 abstract class ResultDescriptor<V> {
   /**
    * Initialize a newly created analysis result to have the given [name]. If a
    * composite result is specified, then this result will contribute to it.
    */
   factory ResultDescriptor(String name, V defaultValue,
@@ skipping 117 matching lines @@
    * be computed, or `false` if the inputs have been computed.
    *
    * It is safe to invoke [moveNext] after it has returned `false`. In this case
    * [moveNext] has no effect and will again return `false`.
    *
    * Throws a [StateError] if the value of the current result has not been
    * provided using [currentValue].
    */
   bool moveNext();
 }