Make IterableMixinWorkaround using classes return correctly typed Iterables.

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 177 matching lines @@
     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;
   }
 
-  Iterable<E> skip(int count) => new SubListIterable(this, count, null);
+  Iterable<E> skip(int count) => new SubListIterable<E>(this, count, null);
 
   Iterable<E> skipWhile(bool test(E element)) => super.skipWhile(test);
 
-  Iterable<E> take(int count) => new SubListIterable(this, 0, count);
+  Iterable<E> take(int count) => new SubListIterable<E>(this, 0, count);
 
   Iterable<E> takeWhile(bool test(E element)) => super.takeWhile(test);
 
   List<E> toList({ bool growable: true }) {
     List<E> result;
     if (growable) {
       result = new List<E>()..length = length;
     } else {
       result = new List<E>(length);
     }
@@ skipping 56 matching lines @@
   E elementAt(int index) {
     int realIndex = _startIndex + index;
     if (index < 0 || realIndex >= _endIndex) {
       throw new RangeError.range(index, 0, length);
     }
     return _iterable.elementAt(realIndex);
   }
 
   Iterable<E> skip(int count) {
     if (count < 0) throw new RangeError.value(count);
-    return new SubListIterable(_iterable, _start + count, _endOrLength);
+    int newStart = _start + count;
+    if (_endOrLength != null && newStart >= _endOrLength) {
+      return new EmptyIterable<E>();
+    }
+    return new SubListIterable<E>(_iterable, newStart, _endOrLength);
   }
 
   Iterable<E> take(int count) {
     if (count < 0) throw new RangeError.value(count);
     if (_endOrLength == null) {
-      return new SubListIterable(_iterable, _start, _start + count);
+      return new SubListIterable<E>(_iterable, _start, _start + count);
     } else {
       int newEnd = _start + count;
       if (_endOrLength < newEnd) return this;
-      return new SubListIterable(_iterable, _start, newEnd);
+      return new SubListIterable<E>(_iterable, _start, newEnd);
     }
   }
 }
 
 /**
  * An [Iterator] that iterates a list-like [Iterable].
  *
  * All iterations is done in terms of [Iterable.length] and
  * [Iterable.elementAt]. These operations are fast for list-like
  * iterables.
@@ skipping 433 matching lines @@
 /** An [Iterator] that can move in both directions. */
 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 {
+class IterableMixinWorkaround<T> {
   static bool contains(Iterable iterable, var element) {
     for (final e in iterable) {
       if (e == element) return true;
     }
     return false;
   }
 
   static void forEach(Iterable iterable, void f(o)) {
     for (final e in iterable) {
       f(e);
@@ skipping 173 matching lines @@
     } else {
       buffer.write(list[0]);
       for (int i = 1; i < list.length; i++) {
         buffer.write(separator);
         buffer.write(list[i]);
       }
     }
     return buffer.toString();
   }
 
-  static Iterable where(Iterable iterable, bool f(var element)) {
-    return new WhereIterable(iterable, f);
+  Iterable<T> where(Iterable iterable, bool f(var element)) {
+    return new WhereIterable<T>(iterable, f);
   }
 
   static Iterable map(Iterable iterable, f(var element)) {
     return new MappedIterable(iterable, f);
   }
 
   static Iterable mapList(List list, f(var element)) {
     return new MappedListIterable(list, f);
   }
 
   static Iterable expand(Iterable iterable, Iterable f(var element)) {
     return new ExpandIterable(iterable, f);
   }
 
-  static Iterable takeList(List list, int n) {
+  Iterable<T> takeList(List list, int n) {
     // The generic type is currently lost. It will be fixed with mixins.
-    return new SubListIterable(list, 0, n);
+    return new SubListIterable<T>(list, 0, n);
   }
 
-  static Iterable takeWhile(Iterable iterable, bool test(var value)) {
+  Iterable<T> takeWhile(Iterable iterable, bool test(var value)) {
     // The generic type is currently lost. It will be fixed with mixins.
-    return new TakeWhileIterable(iterable, test);
+    return new TakeWhileIterable<T>(iterable, test);
   }
 
-  static Iterable skipList(List list, int n) {
+  Iterable<T> skipList(List list, int n) {
     // The generic type is currently lost. It will be fixed with mixins.
-    return new SubListIterable(list, n, null);
+    return new SubListIterable<T>(list, n, null);
   }
 
-  static Iterable skipWhile(Iterable iterable, bool test(var value)) {
+  Iterable<T> skipWhile(Iterable iterable, bool test(var value)) {
     // The generic type is currently lost. It will be fixed with mixins.
-    return new SkipWhileIterable(iterable, test);
+    return new SkipWhileIterable<T>(iterable, test);
   }
 
-  static Iterable reversedList(List list) {
-    return new ReversedListIterable(list);
+  Iterable<T> reversedList(List list) {
+    return new ReversedListIterable<T>(list);
   }
 
   static void sortList(List list, int compare(a, b)) {
     if (compare == null) compare = Comparable.compare;
     Sort.sort(list, compare);
   }
 
   static void shuffleList(List list, Random random) {
     if (random == null) random = new Random();
     int length = list.length;
@@ skipping 17 matching lines @@
 
   static void _rangeCheck(List list, int start, int end) {
     if (start < 0 || start > list.length) {
       throw new RangeError.range(start, 0, list.length);
     }
     if (end < start || end > list.length) {
       throw new RangeError.range(end, start, list.length);
     }
   }
 
-  static Iterable getRangeList(List list, int start, int end) {
+  Iterable<T> getRangeList(List list, int start, int end) {
     _rangeCheck(list, start, end);
     // The generic type is currently lost. It will be fixed with mixins.
-    return new SubListIterable(list, start, end);
+    return new SubListIterable<T>(list, start, end);
   }
 
   static void setRangeList(List list, int start, int end,
                            Iterable from, int skipCount) {
     _rangeCheck(list, start, end);
     int length = end - start;
     if (length == 0) return;
 
     if (skipCount < 0) throw new ArgumentError(skipCount);
 
@@ skipping 64 matching lines @@
 
   static void setAllList(List list, int index, Iterable iterable) {
     if (index < 0 || index > list.length) {
       throw new RangeError.range(index, 0, list.length);
     }
     for (var element in iterable) {
       list[index++] = element;
     }
   }
 
-  static Map<int, dynamic> asMapList(List l) {
-    return new ListMapView(l);
+  Map<int, T> asMapList(List l) {
+    return new ListMapView<T>(l);
   }
 
   static bool setContainsAll(Set set, Iterable other) {
     for (var element in other) {
       if (!set.contains(element)) return false;
     }
     return true;
   }
 
   static Set setIntersection(Set set, Set other, Set result) {
@@ skipping 34 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");
 }