Make IterableMixinWorkaround using classes return correctly typed Iterables.

sdk/lib/_internal/lib/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 _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
@@ skipping 129 matching lines @@
     // This could, and should, be optimized.
     IterableMixinWorkaround.removeWhereList(this, test);
   }
 
   void retainWhere(bool test(E element)) {
     IterableMixinWorkaround.removeWhereList(this,
                                             (E element) => !test(element));
   }
 
   Iterable<E> where(bool f(E element)) {
-    return IterableMixinWorkaround.where(this, f);
+    return new IterableMixinWorkaround<E>().where(this, f);
   }
 
   Iterable expand(Iterable f(E element)) {
     return IterableMixinWorkaround.expand(this, f);
   }
 
   void addAll(Iterable<E> collection) {
     for (E e in collection) {
       this.add(e);
     }
@@ skipping 13 matching lines @@
 
   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);
   }
 
   Iterable<E> take(int n) {
-    return IterableMixinWorkaround.takeList(this, n);
+    return new IterableMixinWorkaround<E>().takeList(this, n);
   }
 
   Iterable<E> takeWhile(bool test(E value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new IterableMixinWorkaround<E>().takeWhile(this, test);
   }
 
   Iterable<E> skip(int n) {
-    return IterableMixinWorkaround.skipList(this, n);
+    return new IterableMixinWorkaround<E>().skipList(this, n);
   }
 
   Iterable<E> skipWhile(bool test(E value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    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)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ skipping 27 matching lines @@
         throw new RangeError.range(end, start, length);
       }
     }
     if (start == end) return <E>[];
     return new JSArray<E>.markGrowable(
         JS('', r'#.slice(#, #)', this, start, end));
   }
 
 
   Iterable<E> getRange(int start, int end) {
-    return IterableMixinWorkaround.getRangeList(this, start, end);
+    return new IterableMixinWorkaround<E>().getRangeList(this, start, end);
   }
 
   E get first {
     if (length > 0) return this[0];
     throw new StateError("No elements");
   }
 
   E get last {
     if (length > 0) return this[length - 1];
     throw new StateError("No elements");
@@ skipping 34 matching lines @@
 
   void replaceRange(int start, int end, Iterable<E> iterable) {
     checkGrowable('removeRange');
     IterableMixinWorkaround.replaceRangeList(this, start, end, iterable);
   }
 
   bool any(bool f(E element)) => IterableMixinWorkaround.any(this, f);
 
   bool every(bool f(E element)) => IterableMixinWorkaround.every(this, f);
 
-  Iterable<E> get reversed => IterableMixinWorkaround.reversedList(this);
+  Iterable<E> get reversed =>
+      new IterableMixinWorkaround<E>().reversedList(this);
 
   void sort([int compare(E a, E b)]) {
     checkMutable('sort');
     IterableMixinWorkaround.sortList(this, compare);
   }
 
   void shuffle([Random random]) {
     IterableMixinWorkaround.shuffleList(this, random);
   }
 
@@ skipping 48 matching lines @@
   }
 
   void operator []=(int index, E value) {
     checkMutable('indexed set');
     if (index is !int) throw new ArgumentError(index);
     if (index >= length || index < 0) throw new RangeError.value(index);
     JS('void', r'#[#] = #', this, index, value);
   }
 
   Map<int, E> asMap() {
-    return IterableMixinWorkaround.asMapList(this);
+    return new IterableMixinWorkaround<E>().asMapList(this);
   }
 }
 
 /**
  * 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> {}