Update to latest analyzer

tool/input_sdk/lib/core/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.core;
 
 /**
  * An object that uses an [Iterator] to serve objects one at a time.
  *
  * You can iterate over all objects served by an Iterable object
@@ skipping 54 matching lines @@
   /**
    * Returns a new lazy [Iterable] with elements that are created by
    * calling `f` on the elements of this `Iterable`.
    *
    * This method returns a view of the mapped elements. As long as the
    * returned [Iterable] is not iterated over, the supplied function [f] will
    * not be invoked. The transformed elements will not be cached. Iterating
    * multiple times over the the returned [Iterable] will invoke the supplied
    * function [f] multiple times on the same element.
    */
-  Iterable map(f(E element));
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element));
 
   /**
    * Returns a new lazy [Iterable] with all elements that satisfy the
    * predicate [test].
    *
    * This method returns a view of the mapped elements. As long as the
    * returned [Iterable] is not iterated over, the supplied function [test] will
    * not be invoked. Iterating will not cache results, and thus iterating
    * multiple times over the returned [Iterable] will invoke the supplied
    * function [test] multiple times on the same element.
    */
   Iterable<E> where(bool test(E element));
 
   /**
    * Expands each element of this [Iterable] into zero or more elements.
    *
    * The resulting Iterable runs through the elements returned
    * by [f] for each element of this, in order.
    *
    * The returned [Iterable] is lazy, and calls [f] for each element
    * of this every time it's iterated.
    */
-  Iterable expand(Iterable f(E element));
+  Iterable/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ f(E element));
 
   /**
    * Returns true if the collection contains an element equal to [element].
    *
    * The equality used to determine whether [element] is equal to an element of
    * the iterable, depends on the type of iterable.
    * For example, a [Set] may have a custom equality
    * (see, e.g., [Set.identical]) that its `contains` uses.
    * Likewise the `Iterable` returned by a [Map.keys] call
    * will likely use the same equality that the `Map` uses for keys.
@@ skipping 22 matching lines @@
    * function.
    *
    * Use [initialValue] as the initial value, and the function [combine] to
    * create a new value from the previous one and an element.
    *
    * Example of calculating the sum of an iterable:
    *
    *     iterable.fold(0, (prev, element) => prev + element);
    *
    */
-  dynamic fold(var initialValue,
-               dynamic combine(var previousValue, E element));
+  dynamic/*=T*/ fold/*<T>*/(var/*=T*/ initialValue,
+               dynamic/*=T*/ combine(var/*=T*/ previousValue, E element));
 
   /**
    * Returns true if every elements of this collection satisify the
    * predicate [test]. Returns `false` otherwise.
    */
   bool every(bool test(E element));
 
   /**
    * Converts each element to a [String] and concatenates the strings.
    *
@@ skipping 217 matching lines @@
  */
 abstract class BidirectionalIterator<E> implements Iterator<E> {
   /**
    * Move back to the previous element.
    *
    * Returns true and updates [current] if successful. Returns false
    * and sets [current] to null if there is no previous element.
    */
   bool movePrevious();
 }