Create generic check methods for RangeError causing checks.

sdk/lib/internal/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._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
@@ skipping 219 matching lines @@
   }
 }
 
 class SubListIterable<E> extends ListIterable<E> {
   final Iterable<E> _iterable;  // Has efficient length and elementAt.
   final int _start;
   /** If null, represents the length of the iterable. */
   final int _endOrLength;
 
   SubListIterable(this._iterable, this._start, this._endOrLength) {
-    if (_start < 0) {
-      throw new RangeError.value(_start);
-    }
+    RangeError.checkNotNegative(_start, "start");
     if (_endOrLength != null) {
-      if (_endOrLength < 0) {
-        throw new RangeError.value(_endOrLength);
-      }
+      RangeError.checkNotNegative(_endOrLength, "end");
       if (_start > _endOrLength) {
-        throw new RangeError.range(_start, 0, _endOrLength);
+        throw new RangeError.range(_start, 0, _endOrLength, "start");
       }
     }
   }
 
   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;
     return _start;
   }
 
   int get length {
     int length = _iterable.length;
     if (_start >= length) return 0;
     if (_endOrLength == null || _endOrLength >= length) {
       return length - _start;
     }
     return _endOrLength - _start;
   }
 
   E elementAt(int index) {
     int realIndex = _startIndex + index;
     if (index < 0 || realIndex >= _endIndex) {
-      throw new RangeError.range(index, 0, length);
+      throw new RangeError.index(index, this, "index");
     }
     return _iterable.elementAt(realIndex);
   }
 
   Iterable<E> skip(int count) {
-    if (count < 0) throw new RangeError.value(count);
+    RangeError.checkNotNegative(count, "count");
     int newStart = _start + count;
     if (_endOrLength != null && newStart >= _endOrLength) {
       return new EmptyIterable<E>();
     }
     return new SubListIterable<E>(_iterable, newStart, _endOrLength);
   }
 
   Iterable<E> take(int count) {
-    if (count < 0) throw new RangeError.value(count);
+    RangeError.checkNotNegative(count, "count");
     if (_endOrLength == null) {
       return new SubListIterable<E>(_iterable, _start, _start + count);
     } else {
       int newEnd = _start + count;
       if (_endOrLength < newEnd) return this;
       return new SubListIterable<E>(_iterable, _start, newEnd);
     }
   }
 
   List<E> toList({bool growable: true}) {
@@ skipping 276 matching lines @@
   E get current {
     if (_isFinished) return null;
     return _iterator.current;
   }
 }
 
 class SkipIterable<E> extends IterableBase<E> {
   final Iterable<E> _iterable;
   final int _skipCount;
 
-  factory SkipIterable(Iterable<E> iterable, int skipCount) {
+  factory SkipIterable(Iterable<E> iterable, int count) {
     if (iterable is EfficientLength) {
-      return new EfficientLengthSkipIterable<E>(iterable, skipCount);
+      return new EfficientLengthSkipIterable<E>(iterable, count);
     }
-    return new SkipIterable<E>._(iterable, skipCount);
+    return new SkipIterable<E>._(iterable, count);
   }
 
   SkipIterable._(this._iterable, this._skipCount) {
-    if (_skipCount is! int || _skipCount < 0) {
-      throw new RangeError(_skipCount);
+    if (_skipCount is! int) {
+      throw new ArgumentError.value(_skipCount, "count is not an integer");
     }
+    RangeError.checkNotNegative(_skipCount, "count");
   }
 
-  Iterable<E> skip(int n) {
-    if (n is! int || n < 0) {
-      throw new RangeError.value(n);
+  Iterable<E> skip(int count) {
+    if (_skipCount is! int) {
+      throw new ArgumentError.value(_skipCount, "count is not an integer");
     }
-    return new SkipIterable<E>(_iterable, _skipCount + n);
+    RangeError.checkNotNegative(_skipCount, "count");
+    return new SkipIterable<E>._(_iterable, _skipCount + count);
   }
 
   Iterator<E> get iterator {
     return new SkipIterator<E>(_iterable.iterator, _skipCount);
   }
 }
 
 class EfficientLengthSkipIterable<E> extends SkipIterable<E>
                                      implements EfficientLength {
   EfficientLengthSkipIterable(Iterable<E> iterable, int skipCount)
@@ skipping 67 matching lines @@
   bool get isEmpty => true;
 
   int get length => 0;
 
   E get first { throw IterableElementError.noElement(); }
 
   E get last { throw IterableElementError.noElement(); }
 
   E get single { throw IterableElementError.noElement(); }
 
-  E elementAt(int index) { throw new RangeError.value(index); }
+  E elementAt(int index) { throw new RangeError.range(index, 0, 0, "index"); }
 
   bool contains(Object element) => false;
 
   bool every(bool test(E element)) => true;
 
   bool any(bool test(E element)) => false;
 
   E firstWhere(bool test(E element), { E orElse() }) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
@@ skipping 17 matching lines @@
 
   E reduce(E combine(E value, E element)) {
     throw IterableElementError.noElement();
   }
 
   fold(var initialValue, combine(var previousValue, E element)) {
     return initialValue;
   }
 
   Iterable<E> skip(int count) {
-    if (count < 0) throw new RangeError.value(count);
+    RangeError.checkNotNegative(count, "count");
     return this;
   }
 
   Iterable<E> skipWhile(bool test(E element)) => this;
 
   Iterable<E> take(int count) {
-    if (count < 0) throw new RangeError.value(count);
+    RangeError.checkNotNegative(count, "count");
     return 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>();
 }
 
@@ skipping 167 matching lines @@
           throw IterableElementError.tooMany();
         }
         result = element;
         foundMatching = true;
       }
     }
     if (foundMatching) return result;
     throw IterableElementError.noElement();
   }
 
-  static dynamic elementAt(Iterable iterable, int index) {
-    if (index is! int || index < 0) throw new RangeError.value(index);
-    int remaining = index;
-    for (dynamic element in iterable) {
-      if (remaining == 0) return element;
-      remaining--;
+  static elementAt(Iterable iterable, int index) {
+    if (index is! int) throw new ArgumentError.notNull("index");
+    RangeError.checkNotNegative(index, "index");
+    int elementIndex = 0;
+    for (E element in iterable) {
+      if (index == elementIndex) return element;
+      elementIndex++;
     }
-    throw new RangeError.value(index);
+    throw new RangeError.index(index, iterable, "index", null, elementIndex);
   }
 
   static String join(Iterable iterable, [String separator]) {
     StringBuffer buffer = new StringBuffer();
     buffer.writeAll(iterable, separator);
     return buffer.toString();
   }
 
   static String joinList(List list, [String separator]) {
     if (list.isEmpty) return "";
@@ skipping 73 matching lines @@
   static int indexOfList(List list, var element, int start) {
     return Lists.indexOf(list, element, start, list.length);
   }
 
   static int lastIndexOfList(List list, var element, int start) {
     if (start == null) start = list.length - 1;
     return Lists.lastIndexOf(list, element, start);
   }
 
   static void _rangeCheck(List list, int start, int end) {
-    if (start < 0 || start > list.length) {
-      throw new RangeError.range(start, 0, list.length);
-    }
-    if (end < start || end > list.length) {
-      throw new RangeError.range(end, start, list.length);
-    }
+    RangeError.checkValidRange(start, end, list.length);
   }
 
   Iterable<T> getRangeList(List list, int start, int end) {
     _rangeCheck(list, start, end);
     // The generic type is currently lost. It will be fixed with mixins.
     return new SubListIterable<T>(list, start, end);
   }
 
   static void setRangeList(List list, int start, int end,
                            Iterable from, int skipCount) {
@@ skipping 47 matching lines @@
   }
 
   static void fillRangeList(List list, int start, int end, fillValue) {
     _rangeCheck(list, start, end);
     for (int i = start; i < end; i++) {
       list[i] = fillValue;
     }
   }
 
   static void insertAllList(List list, int index, Iterable iterable) {
-    if (index < 0 || index > list.length) {
-      throw new RangeError.range(index, 0, list.length);
-    }
+    RangeError.checkValidIndex(index, list);
     if (iterable is! EfficientLength) {
       iterable = iterable.toList(growable: false);
     }
     int insertionLength = iterable.length;
     list.length += insertionLength;
     list.setRange(index + insertionLength, list.length, list, index);
     for (var element in iterable) {
       list[index++] = element;
     }
   }
 
   static void setAllList(List list, int index, Iterable iterable) {
-    if (index < 0 || index > list.length) {
-      throw new RangeError.range(index, 0, list.length);
-    }
+    RangeError.checkValueInInterval(index, 0, list.length, "index");
     for (var element in iterable) {
       list[index++] = element;
     }
   }
 
   Map<int, T> asMapList(List l) {
     return new ListMapView<T>(l);
   }
 
   static bool setContainsAll(Set set, Iterable other) {
@@ skipping 41 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }