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

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 23 matching lines @@
  */
 abstract class ListTaskInputMixin<E> implements ListTaskInput<E> {
   ListTaskInput /*<V>*/ toList(UnaryFunction<E, dynamic /*<V>*/ > mapper) {
     return new ListToListTaskInput<E, dynamic /*V*/ >(this, mapper);
   }
 
   ListTaskInput /*<V>*/ toListOf(ResultDescriptor /*<V>*/ valueResult) {
     return (this as ListTaskInputImpl<AnalysisTarget>).toList(valueResult.of);
   }
 
-  TaskInput<Map<E, dynamic /*V*/ >> toMap(
+  MapTaskInput<E, dynamic /*V*/ > toMap(
       UnaryFunction<E, dynamic /*<V>*/ > mapper) {
     return new ListToMapTaskInput<E, dynamic /*V*/ >(this, mapper);
   }
 
-  TaskInput<Map<AnalysisTarget, dynamic /*V*/ >> toMapOf(
+  MapTaskInput<AnalysisTarget, dynamic /*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,
@@ skipping 46 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 the map of the base elements to the analysis results is used as the
  * input to the task.
  */
 class ListToMapTaskInput<B, E>
-    extends _ListToCollectionTaskInput<B, E, Map<B, E>> {
+    extends _ListToCollectionTaskInput<B, E, Map<B, E>>
+    with MapTaskInputMixin<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.
    */
   ListToMapTaskInput(TaskInput<List<B>> baseAccessor,
       GenerateTaskInputs<B, E> generateTaskInputs)
       : super(baseAccessor, generateTaskInputs);
 
@@ skipping 23 matching lines @@
     _resultValue[baseElement] = resultElement;
   }
 
   @override
   void _initResultValue() {
     _resultValue = new HashMap<B, E>();
   }
 }
 
 /**
+ * A mixin-ready implementation of [MapTaskInput].
+ */
+abstract class MapTaskInputMixin<K, V> implements MapTaskInput<K, V> {
+  TaskInput<List /*<E>*/ > toFlattenList(
+      BinaryFunction<K, dynamic /*element of V*/, dynamic /*<E>*/ > mapper) {
+    return new MapToFlattenListTaskInput<K, dynamic /*element of V*/, dynamic /*E*/ >(
+        this as MapTaskInput<K, List /*<element of V>*/ >, mapper);
+  }
+}
+
+/**
+ * A [TaskInput] that is computed by the following steps.
+ *
+ * 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>> {
+  final MapTaskInput<K, List<V>> base;
+  final BinaryFunction<K, V, E> mapper;
+
+  MapToFlattenListTaskInput(this.base, this.mapper);
+
+  @override
+  TaskInputBuilder<List> createBuilder() {
+    return new MapToFlattenListTaskInputBuilder<K, V, E>(base, mapper);
+  }
+}
+
+/**
+ * The [TaskInputBuilder] for [MapToFlattenListTaskInput].
+ */
+class MapToFlattenListTaskInputBuilder<K, V, E>
+    implements TaskInputBuilder<List<E>> {
+  final MapTaskInput<K, List<V>> base;
+  final BinaryFunction<K, V, E> mapper;
+
+  TaskInputBuilder currentBuilder;
+  Map<K, List<V>> baseMap;
+  Iterator<K> keyIterator;
+  Iterator<V> valueIterator;
+
+  final List<E> inputValue = <E>[];
+
+  MapToFlattenListTaskInputBuilder(this.base, this.mapper) {
+    currentBuilder = base.createBuilder();
+  }
+
+  @override
+  ResultDescriptor get currentResult {
+    if (currentBuilder == null) {
+      return null;
+    }
+    return currentBuilder.currentResult;
+  }
+
+  AnalysisTarget get currentTarget {
+    if (currentBuilder == null) {
+      return null;
+    }
+    return currentBuilder.currentTarget;
+  }
+
+  @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
+  bool moveNext() {
+    // Prepare base Map.
+    if (baseMap == null) {
+      if (currentBuilder.moveNext()) {
+        return true;
+      }
+      baseMap = currentBuilder.inputValue;
+      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);
+      // 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();
+    }
+    // Move to the next Map key.
+    if (keyIterator.moveNext()) {
+      K key = keyIterator.current;
+      valueIterator = baseMap[key].iterator;
+      return moveNext();
+    }
+    // No more values/keys to transform.
+    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> {
   /**
    * The target on which the result is defined.
    */
   final AnalysisTarget target;
 
   /**
@@ skipping 346 matching lines @@
       return false;
     }
     _baseListElement = _baseList[_baseListIndex];
     currentBuilder = input.generateTaskInputs(_baseListElement).createBuilder();
     return currentBuilder.moveNext();
   }
 
   void _addResultElement(B baseElement, E resultElement);
   void _initResultValue();
 }