Remove last uses of IterableMixinWorkaround from VM's typed data implementation.

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>
+// This class does not extend ListBase<T> since that would add type arguments
+// to instances of _TypeListBase. Instead the subclasses use number-type specific

[Ivan Posva, 2015/01/29 15:03:18]

Long line.

[Florian Schneider, 2015/02/03 08:18:19]

Done.

+// mixins (like _IntListMixin, _DoubleListMixin) to implement ListBase<T>.
 abstract class _TypedListBase {
 
   // Method(s) implementing the Collection interface.
-  bool contains(element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(element) {
+    int len = this.length;
+    for (int i = 0; i < len; ++i) {
+      if (this[i] == element) return true;
+    }
+    return false;
+  }
 
   void forEach(void f(element)) {
-    var len = this.length;
-    for (var i = 0; i < len; i++) {
+    int len = this.length;
+    for (int i = 0; i < len; i++) {

[Ivan Posva, 2015/01/29 15:03:18]

Any reason for this change? Generally we tend to use non-typed locals, but typed
parameters and return types.

[Florian Schneider, 2015/02/03 08:18:19]

Done.

       f(this[i]);
     }
   }
 
   String join([String separator = ""]) {
-    return IterableMixinWorkaround.join(this, separator);
+    StringBuffer buffer = new StringBuffer();
+    buffer.writeAll(this, separator);
+    return buffer.toString();
   }
 
   dynamic reduce(dynamic combine(value, element)) {
-    return IterableMixinWorkaround.reduce(this, combine);
+    int len = this.length;
+    if (len == 0) throw IterableElementError.noElement();
+    int i = 0;

[srdjan, 2015/01/29 17:29:40]

Remove int i = 0;

[Florian Schneider, 2015/02/03 08:18:19]

Done.

+    var value = this[0];
+    for (var i = 1; i < len; ++i) {
+      value = combine(value, this[i]);
+    }
+    return value;
   }
 
   dynamic fold(dynamic initialValue,
                dynamic combine(dynamic initialValue, element)) {
-    return IterableMixinWorkaround.fold(this, initialValue, combine);
+    int len = this.length;
+    for (int i = 0; i < len; ++i) {
+      initialValue = combine(initialValue, this[i]);
+    }
+    return initialValue;
   }
 
-  Iterable map(f(element)) {
-    return IterableMixinWorkaround.mapList(this, f);
-  }
+  Iterable map(f(element)) => new MappedIterable(this, f);
 
-  Iterable expand(Iterable f(element)) {
-    return IterableMixinWorkaround.expand(this, f);
-  }
+  Iterable expand(Iterable f(element)) => new ExpandIterable(this, f);
 
   bool every(bool f(element)) {
-    return IterableMixinWorkaround.every(this, f);
+    int len = this.length;
+    for (int i = 0; i < len; ++i) {
+      if (!f(this[i])) return false;
+    }
+    return true;
   }
 
   bool any(bool f(element)) {
-    return IterableMixinWorkaround.any(this, f);
+    int len = this.length;
+    for (int i = 0; i < len; ++i) {
+      if (f(this[i])) return true;
+    }
+    return false;
   }
 
   dynamic firstWhere(bool test(element), {orElse()}) {
-    return IterableMixinWorkaround.firstWhere(this, test, orElse);
+    int len = this.length;
+    for (int i = 0; i < len; ++i) {
+      var element = this[i];
+      if (test(element)) return element;
+    }
+    if (orElse != null) return orElse();
+    throw IterableElementError.noElement();
   }
 
   dynamic lastWhere(bool test(element), {orElse()}) {
-    return IterableMixinWorkaround.lastWhereList(this, test, orElse);
+    dynamic result = null;

[srdjan, 2015/01/29 17:29:39]

var result = null;

[Florian Schneider, 2015/02/03 08:18:19]

Done.

+    bool foundMatching = false;
+    int len = this.length;
+    for (int i = 0; i < len; ++i) {

[srdjan, 2015/01/29 17:29:39]

Why not going backward len - 1 ... 0 and return first found element? 

[Florian Schneider, 2015/02/03 08:18:19]

Done.

+      dynamic element = this[i];

[srdjan, 2015/01/29 17:29:40]

var element =

[Florian Schneider, 2015/02/03 08:18:19]

Done.

+      if (test(element)) {
+        result = element;
+        foundMatching = true;
+      }
+    }
+    if (foundMatching) return result;
+    if (orElse != null) return orElse();
+    throw IterableElementError.noElement();
   }
 
   dynamic singleWhere(bool test(element)) {
-    return IterableMixinWorkaround.singleWhere(this, test);
+    dynamic result = null;

[srdjan, 2015/01/29 17:29:40]

var result =

[Florian Schneider, 2015/02/03 08:18:19]

Done.

+    bool foundMatching = false;
+    int len = this.length;
+    for (int i = 0; i < len; ++i) {
+      dynamic element = this[i];
+      if (test(element)) {
+        if (foundMatching) {
+          throw IterableElementError.tooMany();
+        }
+        result = element;
+        foundMatching = true;
+      }
+    }
+    if (foundMatching) return result;
+    throw IterableElementError.noElement();
   }
 
   dynamic elementAt(int index) {
     return this[index];
   }
 
   bool get isEmpty {
     return this.length == 0;
   }
 
@@ skipping 20 matching lines @@
     throw new UnsupportedError(
         "Cannot insert into a fixed-length list");
   }
 
   void insertAll(int index, Iterable values) {
     throw new UnsupportedError(
         "Cannot insert into a fixed-length list");
   }
 
   void sort([int compare(a, b)]) {
-    IterableMixinWorkaround.sortList(this, compare);
+    if (compare == null) compare = Comparable.compare;
+    Sort.sort(this, compare);
   }
 
   void shuffle([Random random]) {
-    IterableMixinWorkaround.shuffleList(this, random);
+    if (random == null) random = new Random();
+    int i = this.length;
+    while (i > 1) {
+      int pos = random.nextInt(i);
+      i -= 1;
+      var tmp = this[i];
+      this[i] = this[pos];
+      this[pos] = tmp;
+    }
   }
 
   int indexOf(element, [int start = 0]) {
-    return IterableMixinWorkaround.indexOfList(this, element, start);
+    return Lists.indexOf(this, element, start, this.length);
   }
 
   int lastIndexOf(element, [int start = null]) {
-    return IterableMixinWorkaround.lastIndexOfList(this, element, start);
+    if (start == null) start = this.length - 1;
+    return Lists.lastIndexOf(this, element, start);
   }
 
   void clear() {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
   }
 
   int removeLast() {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
@@ skipping 14 matching lines @@
         "Cannot remove from a fixed-length list");
   }
 
   void retainWhere(bool test(element)) {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
   }
 
   dynamic get first {
     if (length > 0) return this[0];
-    throw new StateError("No elements");
+    throw IterableElementError.noElement();
   }
 
   dynamic get last {
     if (length > 0) return this[length - 1];
-    throw new StateError("No elements");
+    throw IterableElementError.noElement();
   }
 
   dynamic get single {
     if (length == 1) return this[0];
-    if (length == 0) throw new StateError("No elements");
-    throw new StateError("More than one element");
+    if (length == 0) throw IterableElementError.noElement();
+    throw IterableElementError.tooMany();
   }
 
   void removeRange(int start, int end) {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
   }
 
   void replaceRange(int start, int end, Iterable iterable) {
     throw new UnsupportedError(
         "Cannot remove from a fixed-length list");
@@ skipping 26 matching lines @@
     }
     if (start > end) {
       throw _newRangeError(start, end + 1);
     }
     if (skipCount < 0) {
       throw new ArgumentError(skipCount);
     }
 
     final count = end - start;
     if ((from.length - skipCount) < count) {
-      throw new StateError("Not enough elements");
+      throw IterableElementError.tooFew();
     }
 
     if (from is _TypedListBase) {
       if (this.elementSizeInBytes == from.elementSizeInBytes) {
         if ((count < 10) && (from.buffer != this.buffer)) {
           Lists.copy(from, skipCount, this, start, count);
           return;
         } else if (this.buffer._data._setRange(
               start * elementSizeInBytes + this.offsetInBytes,
               count * elementSizeInBytes,
               from.buffer._data,
               skipCount * elementSizeInBytes + from.offsetInBytes,
               ClassID.getID(this), ClassID.getID(from))) {
           return;
         }
       } else if (from.buffer == this.buffer) {
         // Different element sizes, but same buffer means that we need
         // an intermediate structure.
         // TODO(srdjan): Optimize to skip copying if the range does not overlap.
         final temp_buffer = new List(count);
         for (int i = 0; i < count; i++) {
           temp_buffer[i] = from[skipCount + i];
         }
         for (int i = start; i < end; i++) {
           this[i] = temp_buffer[i - start];
         }
         return;
       }
     }
-    IterableMixinWorkaround.setRangeList(this, start,
-                                         end, from, skipCount);
+
+    if (count == 0) return;
+    List otherList;
+    int otherStart;
+    if (from is List) {
+      otherList = from;
+      otherStart = skipCount;
+    } else {
+      otherList = from.skip(skipCount).toList(growable: false);
+      otherStart = 0;
+    }
+    if (otherStart + count > otherList.length) {
+      throw IterableElementError.tooFew();
+    }
+    Lists.copy(otherList, otherStart, this, start, count);
   }
 
   void setAll(int index, Iterable iterable) {
     final end = iterable.length + index;
     setRange(index, end, iterable);
   }
 
   void fillRange(int start, int end, [fillValue]) {
-    IterableMixinWorkaround.fillRangeList(this, start, end, fillValue);
+    RangeError.checkValidRange(start, end, this.length);
+    for (int i = start; i < end; ++i) {
+      this[i] = fillValue;
+    }
   }
 
 
   // Method(s) implementing Object interface.
 
   String toString() => ListBase.listToString(this);
 
 
   // Internal utility methods.
 
@@ skipping 2994 matching lines @@
     return value;
   }
   return object;
 }
 
 
 _newRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   return new RangeError(message);
 }