Make IterableMixinWorkaround using classes return correctly typed Iterables.

runtime/lib/typed_data.dart

 // Copyright (c) 2013, 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.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 import "dart:_internal";
 import 'dart:math' show Random;
 
 patch class Int8List {
@@ skipping 223 matching lines @@
 
   // Called directly from C code.
   factory ByteData._view(TypedData typedData, int offsetInBytes, int length) {
     return new _ByteDataView(typedData, offsetInBytes, length);
   }
 }
 
 
 // Based class for _TypedList that provides common methods for implementing
 // the collection and list interfaces.
-
+// TODO(13647): Make this extends ListBase<T>
 abstract class _TypedListBase {
 
   // Method(s) implementing the Collection interface.
   bool contains(element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(element)) {
     var len = this.length;
     for (var i = 0; i < len; i++) {
       f(this[i]);
     }
   }
 
-  Iterable map(f(element)) {
-    return IterableMixinWorkaround.mapList(this, f);
-  }
-
   String join([String separator = ""]) {
     return IterableMixinWorkaround.join(this, separator);
   }
 
   dynamic reduce(dynamic combine(value, element)) {
     return IterableMixinWorkaround.reduce(this, combine);
   }
 
   dynamic fold(dynamic initialValue,
                dynamic combine(dynamic initialValue, element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
-  Iterable where(bool f(element)) {
-    return IterableMixinWorkaround.where(this, f);
+  Iterable map(f(element)) {
+    return IterableMixinWorkaround.mapList(this, f);
   }
 
   Iterable expand(Iterable f(element)) {
     return IterableMixinWorkaround.expand(this, f);
   }
 
+  // The following methods need to know the element type (int or double).
+  Iterable where(bool f(element)) {
+    return new IterableMixinWorkaround().where(this, f);
+  }
+
   Iterable take(int n) {
-    return IterableMixinWorkaround.takeList(this, n);
+    return new IterableMixinWorkaround().takeList(this, n);
   }
 
   Iterable takeWhile(bool test(element)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new IterableMixinWorkaround().takeWhile(this, test);
   }
 
   Iterable skip(int n) {
-    return IterableMixinWorkaround.skipList(this, n);
+    return new IterableMixinWorkaround().skipList(this, n);
   }
 
   Iterable skipWhile(bool test(element)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new IterableMixinWorkaround().skipWhile(this, test);
   }
 
+  Iterable<dynamic> get reversed {
+    return new IterableMixinWorkaround().reversedList(this);
+  }
+
+  Map<int, dynamic> asMap() {
+    return new IterableMixinWorkaround().asMapList(this);
+  }
+
+  Iterable getRange(int start, [int end]) {
+    return new IterableMixinWorkaround().getRangeList(this, start, end);
+  }
+  // End of methods returning incorrectly parameterized types.
+
   bool every(bool f(element)) {
     return IterableMixinWorkaround.every(this, f);
   }
 
   bool any(bool f(element)) {
     return IterableMixinWorkaround.any(this, f);
   }
 
   dynamic firstWhere(bool test(element), {orElse()}) {
     return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
   dynamic lastWhere(bool test(element), {orElse()}) {
     return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
   dynamic singleWhere(bool test(element)) {
     return IterableMixinWorkaround.singleWhere(this, test);
   }
 
-  Iterable<dynamic> get reversed {
-    return IterableMixinWorkaround.reversedList(this);
-  }
-
   dynamic elementAt(int index) {
     return this[index];
   }
 
   bool get isEmpty {
     return this.length == 0;
   }
 
   bool get isNotEmpty => !isEmpty;
 
@@ skipping 97 matching lines @@
   }
 
   List toList({bool growable: true}) {
     return new List.from(this, growable: growable);
   }
 
   Set toSet() {
     return new Set.from(this);
   }
 
-  Map<int, dynamic> asMap() {
-    return IterableMixinWorkaround.asMapList(this);
-  }
-
   List sublist(int start, [int end]) {
     if (end == null) end = this.length;
     int length = end - start;
     _rangeCheck(this.length, start, length);
     List result = _createList(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
-  Iterable getRange(int start, [int end]) {
-    return IterableMixinWorkaround.getRangeList(this, start, end);
-  }
-
   void setRange(int start, int end, Iterable from, [int skipCount = 0]) {
     // Check ranges.
     if ((start < 0) || (start > length)) {
       _throwRangeError(start, length + 1);
     }
     if ((end < 0) || (end > length)) {
       _throwRangeError(end, length + 1);
     }
     if (start > end) {
       _throwRangeError(start, end + 1);
@@ skipping 3093 matching lines @@
     return value;
   }
   return object;
 }
 
 
 void _throwRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   throw new RangeError(message);
 }