Update to latest analyzer

tool/input_sdk/private/js_array.dart

 // Copyright (c) 2012, 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._interceptors;
 
 /**
  * The interceptor class for [List]. The compiler recognizes this
  * class as an interceptor, and changes references to [:this:] to
  * actually use the receiver of the method, which is generated as an extra
  * argument added to each member.
  */
 @JsPeerInterface(name: 'Array')
 class JSArray<E> implements List<E>, JSIndexable {
 
   const JSArray();
 
   /**
    * Constructor for adding type parameters to an existing JavaScript Array.
    */
   factory JSArray.typed(allocation) =>
       // TODO(jmesserly): skip this when E is dynamic and Object.
       JS('-dynamic', 'dart.list(#, #)', allocation, E);
 
   // TODO(jmesserly): consider a fixed array subclass instead.
   factory JSArray.markFixed(allocation) =>
       new JSArray<E>.typed(markFixedList(allocation));
 
-  factory JSArray.markGrowable(allocation) = JSArray.typed;
+  factory JSArray.markGrowable(allocation) = JSArray<E>.typed;
 
   static List markFixedList(List list) {
     // Functions are stored in the hidden class and not as properties in
     // the object. We never actually look at the value, but only want
     // to know if the property exists.
     JS('void', r'#.fixed$length = Array', list);
     return list;
   }
 
   checkGrowable(reason) {
@@ skipping 58 matching lines @@
 
   void retainWhere(bool test(E element)) {
     IterableMixinWorkaround.removeWhereList(this,
                                             (E element) => !test(element));
   }
 
   Iterable<E> where(bool f(E element)) {
     return new IterableMixinWorkaround<E>().where(this, f);
   }
 
-  Iterable expand(Iterable f(E element)) {
+  Iterable/*<T>*/ expand/*<T>*/(Iterable/*<E>*/ /*=Iterable<T>*/f(E element)) {
     return IterableMixinWorkaround.expand(this, f);
   }
 
   void addAll(Iterable<E> collection) {
     for (E e in collection) {
       this.add(e);
     }
   }
 
   void clear() {
     length = 0;
   }
 
   void forEach(void f(E element)) {
     int length = this.length;
     for (int i = 0; i < length; i++) {
       f(JS('', '#[#]', this, i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
   }
 
-  Iterable map(f(E element)) {
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element)) {
     return IterableMixinWorkaround.mapList(this, f);
   }
 
   String join([String separator = ""]) {
     var list = new List(this.length);
     for (int i = 0; i < this.length; i++) {
       list[i] = "${this[i]}";
     }
     return JS('String', "#.join(#)", list, separator);
   }
@@ skipping 11 matching lines @@
   }
 
   Iterable<E> skipWhile(bool test(E value)) {
     return new IterableMixinWorkaround<E>().skipWhile(this, test);
   }
 
   E reduce(E combine(E value, E element)) {
     return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  fold(initialValue, combine(previousValue, E element)) {
+  /*=T*/ fold/*<T>*/(/*=T*/ initialValue, /*=T*/ combine(/*=T*/ previousValue, E element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
   E firstWhere(bool test(E value), {E orElse()}) {
     return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
   E lastWhere(bool test(E value), {E orElse()}) {
     return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
@@ skipping 150 matching lines @@
 }
 
 /**
  * Dummy subclasses that allow the backend to track more precise
  * information about arrays through their type. The CPA type inference
  * relies on the fact that these classes do not override [] nor []=.
  */
 class JSMutableArray<E> extends JSArray<E> implements JSMutableIndexable {}
 class JSFixedArray<E> extends JSMutableArray<E> {}
 class JSExtendableArray<E> extends JSMutableArray<E> {}