State that skip/take does not accept negative arguments.

sdk/lib/_collection_dev/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._collection.dev;
 
 /**
  * An [Iterable] for classes that have efficient [length] and [elementAt].
  *
  * All other methods are implemented in terms of [length] and [elementAt],
@@ skipping 198 matching lines @@
     return result;
   }
 }
 
 class SubListIterable<E> extends ListIterable<E> {
   final Iterable<E> _iterable;
   final int _start;
   /** If null, represents the length of the iterable. */
   final int _endOrLength;
 
-  SubListIterable(this._iterable, this._start, this._endOrLength);
+  SubListIterable(this._iterable, this._start, this._endOrLength) {
+    if (_start < 0) {
+      throw new RangeError.value(_start);
+    }
+    if (_endOrLength != null) {
+      if (_endOrLength < 0) {
+        throw new RangeError.value(_endOrLength);
+      }
+      if (_start > _endOrLength) {
+        throw new RangeError.range(_start, 0, _endOrLength);
+      }
+    }
+  }
 
   int get _endIndex {
     int length = _iterable.length;
     if (_endOrLength == null || _endOrLength > length) return length;
     return _endOrLength;
   }
 
   int get _startIndex {
     int length = _iterable.length;
     if (_start > length) return length;
@@ skipping 11 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 ArgumentError(count);
+    if (count < 0) throw new RangeError.value(count);
     return new SubListIterable(_iterable, _start + count, _endOrLength);
   }
 
   Iterable<E> take(int count) {
-    if (count < 0) throw new ArgumentError(count);
+    if (count < 0) throw new RangeError.value(count);
     if (_endOrLength == null) {
       return new SubListIterable(_iterable, _start, _start + count);
     } else {
       int newEnd = _start + count;
       if (_endOrLength < newEnd) return this;
       return new SubListIterable(_iterable, _start, newEnd);
     }
   }
 }
 
@@ skipping 244 matching lines @@
     return _iterator.current;
   }
 }
 
 class SkipIterable<E> extends IterableBase<E> {
   final Iterable<E> _iterable;
   final int _skipCount;
 
   SkipIterable(this._iterable, this._skipCount) {
     if (_skipCount is! int || _skipCount < 0) {
-      throw new ArgumentError(_skipCount);
+      throw new RangeError(_skipCount);
     }
   }
 
   Iterable<E> skip(int n) {
     if (n is! int || n < 0) {
-      throw new ArgumentError(n);
+      throw new RangeError.value(n);
     }
     return new SkipIterable<E>(_iterable, _skipCount + n);
   }
 
   Iterator<E> get iterator {
     return new SkipIterator<E>(_iterable.iterator, _skipCount);
   }
 }
 
 class SkipIterator<E> extends Iterator<E> {
@@ skipping 98 matching lines @@
   Iterable map(f(E element)) => const EmptyIterable();
 
   E reduce(E combine(E value, E element)) {
     throw new StateError("No elements");
   }
 
   fold(var initialValue, combine(var previousValue, E element)) {
     return initialValue;
   }
 
-  Iterable<E> skip(int count) => this;
+  Iterable<E> skip(int count) {
+    if (count < 0) throw new RangeError.value(count);
+    return this;
+  }
 
   Iterable<E> skipWhile(bool test(E element)) => this;
 
-  Iterable<E> take(int count) => this;
+  Iterable<E> take(int count) {
+    if (count < 0) throw new RangeError.value(count);
+    this;
+  }
 
   Iterable<E> takeWhile(bool test(E element)) => this;
 
   List toList({ bool growable: true }) => growable ? <E>[] : new List<E>(0);
 
   Set toSet() => new Set<E>();
 }
 
 /** The always empty iterator. */
 class EmptyIterator<E> implements Iterator<E> {
@@ skipping 375 matching lines @@
 
   static Set setDifference(Set set, Set other, Set result) {
     for (var element in set) {
       if (!other.contains(element)) {
         result.add(element);
       }
     }
     return result;
   }
 }