Revert "Create IterableMixinWorkaround and move most of the Collections methods there."

sdk/lib/_internal/compiler/implementation/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 16 matching lines @@
     return JS('var', r'#.splice(#, 1)[0]', this, index);
   }
 
   E removeLast() {
     checkGrowable(this, 'removeLast');
     if (length == 0) throw new RangeError.value(-1);
     return JS('var', r'#.pop()', this);
   }
 
   Iterable<E> where(bool f(E element)) {
-    return IterableMixinWorkaround.where(this, f);
+    return new WhereIterable<E>(this, f);
   }
 
   void addAll(Collection<E> collection) {
     for (E e in collection) {
       this.add(e);
     }
   }
 
   void addLast(E value) {
     checkGrowable(this, 'addLast');
     JS('void', r'#.push(#)', this, value);
   }
 
   void clear() {
     length = 0;
   }
 
   void forEach(void f(E element)) {
-    return IterableMixinWorkaround.forEach(this, f);
+    return Collections.forEach(this, f);
   }
 
   List mappedBy(f(E element)) {
-    return IterableMixinWorkaround.mappedBy(this, f);
+    return new MappedList(this, f);
   }
 
   String join([String separator]) {
     if (separator == null) 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);
   }
 
   List<E> take(int n) {
-    return IterableMixinWorkaround.takeList(this, n);
+    return new ListView<E>(this, 0, n);
   }
 
   Iterable<E> takeWhile(bool test(E value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<E>(this, test);
   }
 
   List<E> skip(int n) {
-    return IterableMixinWorkaround.skipList(this, n);
+    return new ListView<E>(this, n, null);
   }
 
   Iterable<E> skipWhile(bool test(E value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<E>(this, test);
   }
 
   reduce(initialValue, combine(previousValue, E element)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
   E firstMatching(bool test(E value), {E orElse()}) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   E lastMatching(bool test(E value), {E orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   E singleMatching(bool test(E value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   E elementAt(int index) {
     return this[index];
   }
 
   List<E> getRange(int start, int length) {
     // TODO(ngeoffray): Parameterize the return value.
     if (0 == length) return [];
     checkNull(start); // TODO(ahe): This is not specified but co19 tests it.
@@ skipping 23 matching lines @@
     if (length > 0) return this[length - 1];
     throw new StateError("No elements");
   }
 
   E get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  E min([int compare(E a, E b)]) => IterableMixinWorkaround.min(this, compare);
+  E min([int compare(E a, E b)]) => Collections.min(this, compare);
 
-  E max([int compare(E a, E b)]) => IterableMixinWorkaround.max(this, compare);
+  E max([int compare(E a, E b)]) => Collections.max(this, compare);
 
   void removeRange(int start, int length) {
     checkGrowable(this, 'removeRange');
     if (length == 0) {
       return;
     }
     checkNull(start); // TODO(ahe): This is not specified but co19 tests it.
     checkNull(length); // TODO(ahe): This is not specified but co19 tests it.
     if (start is !int) throw new ArgumentError(start);
     if (length is !int) throw new ArgumentError(length);
@@ skipping 25 matching lines @@
     if (startFrom is !int) throw new ArgumentError(startFrom);
     if (length < 0) throw new ArgumentError(length);
     if (start < 0) throw new RangeError.value(start);
     if (start + length > this.length) {
       throw new RangeError.value(start + length);
     }
 
     Arrays.copy(from, startFrom, this, start, length);
   }
 
-  bool any(bool f(E element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(E element)) => Collections.any(this, f);
 
-  bool every(bool f(E element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(E element)) => Collections.every(this, f);
 
   void sort([int compare(E a, E b)]) {
     checkMutable(this, 'sort');
     if (compare == null) compare = Comparable.compare;
     coreSort(this, compare);
   }
 
   int indexOf(E element, [int start = 0]) {
     if (start is !int) throw new ArgumentError(start);
     return Arrays.indexOf(this, element, start, length);
@@ skipping 67 matching lines @@
     if (nextPosition < length) {
       _position = nextPosition;
       _current = _list[nextPosition];
       return true;
     }
     _position = length;
     _current = null;
     return false;
   }
 }