Renaming IndexOutOfRangeException to RangeError.

runtime/lib/byte_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.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
 
   /* patch */ factory Int8List.view(ByteArray array,
@@ skipping 290 matching lines @@
 int _toInt64(int value) {
   return _toInt(value, 0xFFFFFFFFFFFFFFFF);
 }
 int _toUint64(int value) {
   return value & 0xFFFFFFFFFFFFFFFF;
 }
 
 
 void _rangeCheck(int listLength, int start, int length) {
   if (length < 0) {
-    throw new IndexOutOfRangeException(length);
+    throw new RangeError.value(length);
   }
   if (start < 0) {
-    throw new IndexOutOfRangeException(start);
+    throw new RangeError.value(start);
   }
   if (start + length > listLength) {
-    throw new IndexOutOfRangeException(start + length);
+    throw new RangeError.value(start + length);
   }
 }
 
 
 int _requireInteger(object) {
   if (object is int) {
     return object;
   }
   throw new ArgumentError("$object is not an integer");
 }
@@ skipping 1382 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getInt8(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setInt8(_offset + (index * _BYTES_PER_ELEMENT), _toInt8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getUint8(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setUint8(_offset + (index * _BYTES_PER_ELEMENT), _toUint8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getInt16(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setInt16(_offset + (index * _BYTES_PER_ELEMENT), _toInt16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getUint16(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setUint16(_offset + (index * _BYTES_PER_ELEMENT), _toUint16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getInt32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setInt32(_offset + (index * _BYTES_PER_ELEMENT), _toInt32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getUint32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setUint32(_offset + (index * _BYTES_PER_ELEMENT), _toUint32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getInt64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setInt64(_offset + (index * _BYTES_PER_ELEMENT), _toInt64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getUint64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setUint64(_offset + (index * _BYTES_PER_ELEMENT), _toUint64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   double operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getFloat32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setFloat32(_offset + (index * _BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 43 matching lines @@
     _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
   }
 
   get length {
     return _length;
   }
 
   double operator[](int index) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     return _array.getFloat64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= _length) {
       String message = "$index must be in the range [0..$_length)";
-      throw new IndexOutOfRangeException(message);
+      throw new RangeError(message);
     }
     _array.setFloat64(_offset + (index * _BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
@@ skipping 24 matching lines @@
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }