Update to latest analyzer

tool/input_sdk/lib/internal/iterable.dart

 // Copyright (c) 2011, 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.
 
 part of dart._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
@@ skipping 154 matching lines @@
         if (length != this.length) {
           throw new ConcurrentModificationError(this);
         }
       }
       return buffer.toString();
     }
   }
 
   Iterable<E> where(bool test(E element)) => super.where(test);
 
-  Iterable map(f(E element)) => new MappedListIterable(this, f);
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/f(E element)) => new MappedListIterable<E, dynamic/*=T*/>(this, f);
 
   E reduce(E combine(var value, E element)) {
     int length = this.length;
     if (length == 0) throw IterableElementError.noElement();
     E value = elementAt(0);
     for (int i = 1; i < length; i++) {
       value = combine(value, elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
 
     }
     return value;
   }
 
-  fold(var initialValue, combine(var previousValue, E element)) {
+  /*=T*/ fold/*<T>*/(var/*=T*/ initialValue, /*=T*/combine(var/*=T*/ previousValue, E element)) {
     var value = initialValue;
     int length = this.length;
     for (int i = 0; i < length; i++) {
       value = combine(value, elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     return value;
   }
@@ skipping 507 matching lines @@
 
   E singleWhere(bool test(E element), { E orElse() }) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
   String join([String separator = ""]) => "";
 
   Iterable<E> where(bool test(E element)) => this;
 
-  Iterable map(f(E element)) => const EmptyIterable();
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element)) => const EmptyIterable();
 
   E reduce(E combine(E value, E element)) {
     throw IterableElementError.noElement();
   }
 
-  fold(var initialValue, combine(var previousValue, E element)) {
+  /*=T*/ fold/*<T>*/(var/*=T*/ initialValue, /*=T*/ combine(var/*=T*/ previousValue, E element)) {
     return initialValue;
   }
 
   Iterable<E> skip(int count) {
     RangeError.checkNotNegative(count, "count");
     return this;
   }
 
   Iterable<E> skipWhile(bool test(E element)) => this;
 
@@ skipping 20 matching lines @@
 abstract class BidirectionalIterator<T> implements Iterator<T> {
   bool movePrevious();
 }
 
 /**
  * This class provides default implementations for Iterables (including Lists).
  *
  * The uses of this class will be replaced by mixins.
  */
 class IterableMixinWorkaround<T> {
-  static bool contains(Iterable iterable, var element) {
+  static bool contains/*<E>*/(Iterable/*<E>*/ iterable, var element) {
     for (final e in iterable) {
       if (e == element) return true;
     }
     return false;
   }
 
-  static void forEach(Iterable iterable, void f(o)) {
+  static void forEach/*<E>*/(Iterable/*<E>*/ iterable, void f(/*=E*/ o)) {
     for (final e in iterable) {
       f(e);
     }
   }
 
-  static bool any(Iterable iterable, bool f(o)) {
+  static bool any/*<E>*/(Iterable/*<E>*/ iterable, bool f(/*=E*/ o)) {
     for (final e in iterable) {
       if (f(e)) return true;
     }
     return false;
   }
 
-  static bool every(Iterable iterable, bool f(o)) {
+  static bool every/*<E>*/(Iterable/*<E>*/ iterable, bool f(/*=E*/ o)) {
     for (final e in iterable) {
       if (!f(e)) return false;
     }
     return true;
   }
 
-  static dynamic reduce(Iterable iterable,
-                        dynamic combine(previousValue, element)) {
-    Iterator iterator = iterable.iterator;
+  static dynamic/*=E*/ reduce/*<E>*/(Iterable/*<E>*/ iterable,
+                                  dynamic/*=E*/ combine(/*=E*/previousValue, /*=E*/element)) {
+    Iterator/*<E>*/ iterator = iterable.iterator;
     if (!iterator.moveNext()) throw IterableElementError.noElement();
     var value = iterator.current;
     while (iterator.moveNext()) {
       value = combine(value, iterator.current);
     }
     return value;
   }
 
-  static dynamic fold(Iterable iterable,
-                      dynamic initialValue,
-                      dynamic combine(dynamic previousValue, element)) {
+  static /*=V*/ fold/*<E, V>*/(Iterable/*<E>*/ iterable,
+                               dynamic/*=V*/ initialValue,
+                               dynamic/*=V*/ combine(dynamic/*=V*/ previousValue, /*=E*/element)) {
     for (final element in iterable) {
       initialValue = combine(initialValue, element);
     }
     return initialValue;
   }
 
   /**
    * Removes elements matching [test] from [list].
    *
    * This is performed in two steps, to avoid exposing an inconsistent state
    * to the [test] function. First the elements to retain are found, and then
    * the original list is updated to contain those elements.
    */
-  static void removeWhereList(List list, bool test(var element)) {
-    List retained = [];
+  static void removeWhereList/*<E>*/(List/*<E>*/ list, bool test(var/*=E*/ element)) {
+    List/*<E>*/ retained = [];
     int length = list.length;
     for (int i = 0; i < length; i++) {
       var element = list[i];
       if (!test(element)) {
         retained.add(element);
       }
       if (length != list.length) {
         throw new ConcurrentModificationError(list);
       }
     }
     if (retained.length == length) return;
     list.length = retained.length;
     for (int i = 0; i < retained.length; i++) {
       list[i] = retained[i];
     }
   }
 
-  static bool isEmpty(Iterable iterable) {
+  static bool isEmpty/*<E>*/(Iterable/*<E>*/ iterable) {
     return !iterable.iterator.moveNext();
   }
 
-  static dynamic first(Iterable iterable) {
-    Iterator it = iterable.iterator;
+  static dynamic/*=E*/ first/*<E>*/(Iterable/*<E>*/ iterable) {
+    Iterator/*<E>*/ it = iterable.iterator;
     if (!it.moveNext()) {
       throw IterableElementError.noElement();
     }
     return it.current;
   }
 
-  static dynamic last(Iterable iterable) {
-    Iterator it = iterable.iterator;
+  static dynamic/*=E*/ last/*<E>*/(Iterable/*<E>*/ iterable) {
+    Iterator/*<E>*/ it = iterable.iterator;
     if (!it.moveNext()) {
       throw IterableElementError.noElement();
     }
-    dynamic result;
+    var/*=E*/ result;
     do {
       result = it.current;
     } while(it.moveNext());
     return result;
   }
 
-  static dynamic single(Iterable iterable) {
-    Iterator it = iterable.iterator;
+  static dynamic/*=E*/ single/*<E>*/(Iterable/*<E>*/ iterable) {
+    Iterator/*<E>*/ it = iterable.iterator;
     if (!it.moveNext()) throw IterableElementError.noElement();
-    dynamic result = it.current;
+    var result = it.current;
     if (it.moveNext()) throw IterableElementError.tooMany();
     return result;
   }
 
-  static dynamic firstWhere(Iterable iterable,
-                            bool test(dynamic value),
-                            dynamic orElse()) {
-    for (dynamic element in iterable) {
+  static dynamic/*=E*/ firstWhere/*<E>*/(Iterable/*<E>*/ iterable,
+                                         bool test(dynamic/*=E*/ value),
+                                         dynamic/*=E*/ orElse()) {
+    for (var element in iterable) {
       if (test(element)) return element;
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  static dynamic lastWhere(Iterable iterable,
-                           bool test(dynamic value),
-                           dynamic orElse()) {
-    dynamic result = null;
+  static dynamic/*=E*/ lastWhere/*<E>*/(Iterable/*<E>*/ iterable,
+                           bool test(dynamic/*=E*/ value),
+                           dynamic/*=E*/ orElse()) {
+    dynamic/*=E*/ result = null;
     bool foundMatching = false;
-    for (dynamic element in iterable) {
+    for (var element in iterable) {
       if (test(element)) {
         result = element;
         foundMatching = true;
       }
     }
     if (foundMatching) return result;
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  static dynamic lastWhereList(List list,
-                               bool test(dynamic value),
-                               dynamic orElse()) {
+  static dynamic/*=E*/ lastWhereList/*<E>*/(List/*<E>*/ list,
+                               bool test(dynamic/*=E*/ value),
+                               dynamic/*=E*/ orElse()) {
     // TODO(floitsch): check that arguments are of correct type?
     for (int i = list.length - 1; i >= 0; i--) {
-      dynamic element = list[i];
+      var element = list[i];
       if (test(element)) return element;
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  static dynamic singleWhere(Iterable iterable, bool test(dynamic value)) {
-    dynamic result = null;
+  static dynamic/*=E*/ singleWhere/*<E>*/(Iterable/*<E>*/ iterable, bool test(dynamic/*=E*/ value)) {
+    dynamic/*=E*/ result = null;
     bool foundMatching = false;
-    for (dynamic element in iterable) {
+    for (var element in iterable) {
       if (test(element)) {
         if (foundMatching) {
           throw IterableElementError.tooMany();
         }
         result = element;
         foundMatching = true;
       }
     }
     if (foundMatching) return result;
     throw IterableElementError.noElement();
   }
 
-  static elementAt(Iterable iterable, int index) {
+  static dynamic/*=E*/ elementAt/*<E>*/(Iterable/*<E>*/ iterable, int index) {
     if (index is! int) throw new ArgumentError.notNull("index");
     RangeError.checkNotNegative(index, "index");
     int elementIndex = 0;
     for (var element in iterable) {
       if (index == elementIndex) return element;
       elementIndex++;
     }
     throw new RangeError.index(index, iterable, "index", null, elementIndex);
   }
 
-  static String join(Iterable iterable, [String separator]) {
+  static String join/*<E>*/(Iterable/*<E>*/ iterable, [String separator]) {
     StringBuffer buffer = new StringBuffer();
     buffer.writeAll(iterable, separator);
     return buffer.toString();
   }
 
-  static String joinList(List list, [String separator]) {
+  static String joinList/*<E>*/(List/*<E>*/ list, [String separator]) {
     if (list.isEmpty) return "";
     if (list.length == 1) return "${list[0]}";
     StringBuffer buffer = new StringBuffer();
     if (separator.isEmpty) {
       for (int i = 0; i < list.length; i++) {
         buffer.write(list[i]);
       }
     } else {
       buffer.write(list[0]);
       for (int i = 1; i < list.length; i++) {
         buffer.write(separator);
         buffer.write(list[i]);
       }
     }
     return buffer.toString();
   }
 
-  Iterable<T> where(Iterable iterable, bool f(var element)) {
+  Iterable<T> where(Iterable<T> iterable, bool f(T element)) {
     return new WhereIterable<T>(iterable, f);
   }
 
-  static Iterable map(Iterable iterable, f(var element)) {
-    return new MappedIterable(iterable, f);
+  static Iterable/*<V>*/ map/*<E, V>*/(Iterable/*<E>*/ iterable, /*=V*/ f(var/*=E*/ element)) {
+    return new MappedIterable/*<E, V>*/(iterable, f);
   }
 
-  static Iterable mapList(List list, f(var element)) {
-    return new MappedListIterable(list, f);
+  static Iterable/*<V>*/ mapList/*<E, V>*/(List/*<E>*/ list, /*=V*/ f(var/*=E*/ element)) {
+    return new MappedListIterable/*<E, V>*/(list, f);
   }
 
-  static Iterable expand(Iterable iterable, Iterable f(var element)) {
-    return new ExpandIterable(iterable, f);
+  static Iterable/*<V>*/ expand/*<E, V>*/(Iterable/*<E>*/ iterable, Iterable/*<V>*/ f(var/*=E*/ element)) {
+    return new ExpandIterable/*<E, V>*/(iterable, f);
   }
 
   Iterable<T> takeList(List list, int n) {
     // The generic type is currently lost. It will be fixed with mixins.
     return new SubListIterable<T>(list, 0, n);
   }
 
   Iterable<T> takeWhile(Iterable iterable, bool test(var value)) {
     // The generic type is currently lost. It will be fixed with mixins.
     return new TakeWhileIterable<T>(iterable, test);
@@ skipping 176 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }