Move Arrays class to private library.

sdk/lib/collection/collections.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 dart.collection;
 
 /**
  * This class provides default implementations for Iterables (including Lists).
  *
  * Once Dart receives Mixins it will be replaced with mixin classes.
@@ skipping 329 matching lines @@
     // The generic type is currently lost. It will be fixed with mixins.
     // This is currently a List as well as an Iterable.
     return new SubListIterable(list, n, null);
   }
 
   static Iterable skipWhile(Iterable iterable, bool test(var value)) {
     // The generic type is currently lost. It will be fixed with mixins.
     return new SkipWhileIterable(iterable, test);
   }
 
-  static Iterable reversedList(List l) {
-    return new ReversedListIterable(l);
+  static Iterable reversedList(List list) {
+    return new ReversedListIterable(list);
   }
 
-  static void sortList(List l, int compare(a, b)) {
+  static void sortList(List list, int compare(a, b)) {
     if (compare == null) compare = Comparable.compare;
-    Sort.sort(l, compare);
+    Sort.sort(list, compare);
+  }
+
+  static int indexOfList(List list, var element, int start) {
+    return Arrays.indexOf(list, element, start, list.length);
+  }
+
+  static int lastIndexOfList(List list, var element, int start) {
+    if (start == null) start = list.length - 1;
+    return Arrays.lastIndexOf(list, element, start);
+  }
+
+  static void setRangeList(List list, int start, int length,
+                           List from, int startFrom) {
+    if (length == 0) return;
+
+    // TODO(floitsch): decide what to do with these checks. Currently copied
+    // since that was the old behavior of dart2js, and some co19 tests rely on
+    // it.
+    if (start is! int) throw new ArgumentError(start);
+    if (length is! int) throw new ArgumentError(length);
+    if (from is! List) throw new ArgumentError(from);
+    if (startFrom is! int) throw new ArgumentError(startFrom);

[srdjan, 2013/03/04 21:51:49]

Please remove explicit type checks. Mark corresponding co19 tests as invalid.

[floitsch, 2013/03/05 13:24:39]

Done.

+    if (length < 0) throw new ArgumentError(length);
+    if (start < 0) throw new RangeError.value(start);
+    if (start + length > list.length) {
+      throw new RangeError.value(start + length);
+    }
+
+    Arrays.copy(from, startFrom, list, start, length);
   }
 
   static Map<int, dynamic> asMapList(List l) {
     return new ListMapView(l);
   }
 }
 
 class Collections {
   static String collectionToString(Collection c)
       => ToString.collectionToString(c);
 }
 
 /**
  * An unmodifiable [List] view of another List.
  *
  * The source of the elements may be a [List] or any [Iterable] with
  * efficient [Iterable.length] and [Iterable.elementAt].
  */
 class UnmodifiableListView<E> extends UnmodifiableListBase<E> {
   Iterable<E> _source;
   /** Create an unmodifiable list backed by [source]. */
   UnmodifiableListView(Iterable<E> source) : _source = source;
   int get length => _source.length;
   E operator[](int index) => _source.elementAt(index);
 }