Change RangeError instances to use RangeError.range.

runtime/lib/typed_data.dart

 // Copyright (c) 2013, 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 classes for Int8List ..... Float64List and ByteData implementations.
 
 import "dart:_internal";
 import 'dart:math' show Random;
 
 patch class Int8List {
@@ skipping 468 matching lines @@
   List sublist(int start, [int end]) {
     if (end == null) end = this.length;
     var length = end - start;
     _rangeCheck(this.length, start, length);
     List result = _createList(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int end, Iterable from, [int skipCount = 0]) {
-    // Check ranges.
-    if ((start < 0) || (start > length)) {
-      throw _newRangeError(start, length + 1);
-    }
-    if ((end < 0) || (end > length)) {
-      throw _newRangeError(end, length + 1);
-    }
-    if (start > end) {
-      throw _newRangeError(start, end + 1);
-    }
-    if (skipCount < 0) {

[Ivan Posva, 2015/05/14 18:13:18]

This part is missed in the new code.

[Lasse Reichstein Nielsen, 2015/05/18 12:21:09]

Acknowledged.

-      throw new ArgumentError(skipCount);
-    }
+    if (0 <= start && start <= end && end <= length) {

[Ivan Posva, 2015/05/14 18:13:18]

() around comparisons is generally the style we are using.

+      final count = end - start;
+      if (count == 0) return;
 
-    final count = end - start;
-    if ((from.length - skipCount) < count) {

[Ivan Posva, 2015/05/14 18:13:18]

This part will be missed if count is 0 in the new code.

-      throw IterableElementError.tooFew();
-    }
-
-    if (from is _TypedListBase) {
-      if (this.elementSizeInBytes == from.elementSizeInBytes) {
-        if ((count < 10) && (from.buffer != this.buffer)) {
-          Lists.copy(from, skipCount, this, start, count);
-          return;
-        } else if (this.buffer._data._setRange(
-              start * elementSizeInBytes + this.offsetInBytes,
-              count * elementSizeInBytes,
-              from.buffer._data,
-              skipCount * elementSizeInBytes + from.offsetInBytes,
-              ClassID.getID(this), ClassID.getID(from))) {
+      if (from is _TypedListBase) {
+        if ((from.length - skipCount) < count) {
+          throw IterableElementError.tooFew();
+        }
+        if (this.elementSizeInBytes == from.elementSizeInBytes) {
+          if ((count < 10) && (from.buffer != this.buffer)) {
+            Lists.copy(from, skipCount, this, start, count);
+            return;
+          } else if (this.buffer._data._setRange(
+                start * elementSizeInBytes + this.offsetInBytes,
+                count * elementSizeInBytes,
+                from.buffer._data,
+                skipCount * elementSizeInBytes + from.offsetInBytes,
+                ClassID.getID(this), ClassID.getID(from))) {
+            return;
+          }
+        } else if (from.buffer == this.buffer) {
+          // Different element sizes, but same buffer means that we need
+          // an intermediate structure.
+          // TODO(srdjan): Optimize to skip copying if the range does not overlap.

[Søren Gjesse, 2015/05/13 11:22:08]

Long line.

[Lasse Reichstein Nielsen, 2015/05/18 12:21:09]

Done.

+          final temp_buffer = new List(count);
+          for (var i = 0; i < count; i++) {
+            temp_buffer[i] = from[skipCount + i];
+          }
+          for (var i = start; i < end; i++) {
+            this[i] = temp_buffer[i - start];
+          }
           return;
         }
-      } else if (from.buffer == this.buffer) {
-        // Different element sizes, but same buffer means that we need
-        // an intermediate structure.
-        // TODO(srdjan): Optimize to skip copying if the range does not overlap.
-        final temp_buffer = new List(count);
-        for (var i = 0; i < count; i++) {
-          temp_buffer[i] = from[skipCount + i];
-        }
-        for (var i = start; i < end; i++) {
-          this[i] = temp_buffer[i - start];
-        }
-        return;
       }
+
+      List otherList;
+      int otherStart;
+      if (from is List) {
+        otherList = from;
+        otherStart = skipCount;
+      } else {
+        otherList = from.skip(skipCount).take(count).toList(growable: false);
+        otherStart = 0;
+      }
+      if (otherStart + count > otherList.length) {
+        throw IterableElementError.tooFew();
+      }
+      Lists.copy(otherList, otherStart, this, start, count);
+      return;
     }
-
-    if (count == 0) return;
-    List otherList;
-    int otherStart;
-    if (from is List) {
-      otherList = from;
-      otherStart = skipCount;
-    } else {
-      otherList = from.skip(skipCount).toList(growable: false);
-      otherStart = 0;
-    }
-    if (otherStart + count > otherList.length) {
-      throw IterableElementError.tooFew();
-    }
-    Lists.copy(otherList, otherStart, this, start, count);
+    assert(end != null);

[Søren Gjesse, 2015/05/13 11:22:08]

assert(start != null) as well for completeness.

[Lasse Reichstein Nielsen, 2015/05/18 12:21:08]

The assert is only relevant because RangeError.checkValidRange accepts a null
end argument. 
The tests at the top of the method prevents this:
  0 <= start   implies start is a num (or it would have thrown)
  && start <= end   implies end is also a num, so the assert is just here as a
reminder.

+    // Guaranteed to fail.
+    RangeError.checkValidRange(start, end, length);

[Søren Gjesse, 2015/05/13 11:22:08]

Add assert(false)?

[Lasse Reichstein Nielsen, 2015/05/18 12:21:09]

Slightly icky, but ok.

   }
 
   void setAll(int index, Iterable iterable) {
     final end = iterable.length + index;
     setRange(index, end, iterable);
   }
 
   void fillRange(int start, int end, [fillValue]) {
     RangeError.checkValidRange(start, end, this.length);
     for (var i = start; i < end; ++i) {
@@ skipping 374 matching lines @@
   // Factory constructors.
 
   factory _Int8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {

[Ivan Posva, 2015/05/14 18:13:18]

Please do not change the style of the functions! Here and across the change.
Preference is on ending with a return.

[Lasse Reichstein Nielsen, 2015/05/18 12:21:09]

This was a, possibly premature, attempt to improve performance. The only
benchmark that was actually affected was TypedDataCopy.ByteSwap by 8.379%, the
remaining benchmarks were generally unaffected.

I'll undo these changes for this CL, and do some more experiments.

+      return _getInt8(index);
     }
-    return _getInt8(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setInt8(index, _toInt8(value));
+      return;
     }
-    _setInt8(index, _toInt8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 10 matching lines @@
 class _Uint8Array extends _TypedList with _IntListMixin implements Uint8List {
   // Factory constructors.
 
   factory _Uint8Array(int length) {
     return _new(length);
   }
 
 
   // Methods implementing List interface.
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getUint8(index);
     }
-    return _getUint8(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setUint8(index, _toUint8(value));
+      return;
     }
-    _setUint8(index, _toUint8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint8Array _createList(int length) {
     return _new(length);
   }
 
   static _Uint8Array _new(int length) native "TypedData_Uint8Array_new";
 }
 
 
 class _Uint8ClampedArray extends _TypedList with _IntListMixin implements Uint8ClampedList {
   // Factory constructors.
 
   factory _Uint8ClampedArray(int length) {
     return _new(length);
   }
 
   // Methods implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getUint8(index);
     }
-    return _getUint8(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setUint8(index, _toClampedUint8(value));
+      return;
     }
-    _setUint8(index, _toClampedUint8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
@@ skipping 11 matching lines @@
   // Factory constructors.
 
   factory _Int16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt16(index);
     }
-    return _getIndexedInt16(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt16(index, _toInt16(value));
+      return;
     }
-    _setIndexedInt16(index, _toInt16(value));
+    throw new RangeError.index(index, this, "index");
   }
 
   void setRange(int start, int end, Iterable iterable, [int skipCount = 0]) {
     if (ClassID.getID(iterable) == CodeUnits.cid) {
       end = RangeError.checkValidRange(start, end, this.length);
       int length = end - start;
       int byteStart = this.offsetInBytes + start * Int16List.BYTES_PER_ELEMENT;
       _setCodeUnits(iterable, byteStart, length, skipCount);
     } else {
       super.setRange(start, end, iterable, skipCount);
@@ skipping 29 matching lines @@
   // Factory constructors.
 
   factory _Uint16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedUint16(index);
     }
-    return _getIndexedUint16(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedUint16(index, _toUint16(value));
+      return;
     }
-    _setIndexedUint16(index, _toUint16(value));
+    throw new RangeError.index(index, this, "index");
   }
 
   void setRange(int start, int end, Iterable iterable, [int skipCount = 0]) {
     if (ClassID.getID(iterable) == CodeUnits.cid) {
       end = RangeError.checkValidRange(start, end, this.length);
       int length = end - start;
       int byteStart = this.offsetInBytes + start * Uint16List.BYTES_PER_ELEMENT;
       _setCodeUnits(iterable, byteStart, length, skipCount);
     } else {
       super.setRange(start, end, iterable, skipCount);
@@ skipping 29 matching lines @@
   // Factory constructors.
 
   factory _Int32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt32(index);
     }
-    return _getIndexedInt32(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt32(index, _toInt32(value));
+      return;
     }
-    _setIndexedInt32(index, _toInt32(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 19 matching lines @@
   // Factory constructors.
 
   factory _Uint32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedUint32(index);
     }
-    return _getIndexedUint32(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedUint32(index, _toUint32(value));
+      return;
     }
-    _setIndexedUint32(index, _toUint32(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 19 matching lines @@
   // Factory constructors.
 
   factory _Int64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt64(index);
     }
-    return _getIndexedInt64(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt64(index, _toInt64(value));
+      return;
     }
-    _setIndexedInt64(index, _toInt64(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 19 matching lines @@
   // Factory constructors.
 
   factory _Uint64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedUint64(index);
     }
-    return _getIndexedUint64(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedUint64(index, _toUint64(value));
+      return;
     }
-    _setIndexedUint64(index, _toUint64(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 19 matching lines @@
   // Factory constructors.
 
   factory _Float32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat32(index);
     }
-    return _getIndexedFloat32(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat32(index, value);
+      return;
     }
-    _setIndexedFloat32(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 19 matching lines @@
   // Factory constructors.
 
   factory _Float64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat64(index);
     }
-    return _getIndexedFloat64(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat64(index, value);
+      return;
     }
-    _setIndexedFloat64(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 17 matching lines @@
 
 class _Float32x4Array extends _TypedList with _Float32x4ListMixin implements Float32x4List {
   // Factory constructors.
 
   factory _Float32x4Array(int length) {
     return _new(length);
   }
 
 
   Float32x4 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat32x4(index);
     }
-    return _getIndexedFloat32x4(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Float32x4 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat32x4(index, value);
+      return;
     }
-    _setIndexedFloat32x4(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 17 matching lines @@
 
 class _Int32x4Array extends _TypedList with _Int32x4ListMixin implements Int32x4List {
   // Factory constructors.
 
   factory _Int32x4Array(int length) {
     return _new(length);
   }
 
 
   Int32x4 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt32x4(index);
     }
-    return _getIndexedInt32x4(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Int32x4 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt32x4(index, value);
+      return;
     }
-    _setIndexedInt32x4(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 17 matching lines @@
 
 class _Float64x2Array extends _TypedList with _Float64x2ListMixin implements Float64x2List {
   // Factory constructors.
 
   factory _Float64x2Array(int length) {
     return _new(length);
   }
 
 
   Float64x2 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat64x2(index);
     }
-    return _getIndexedFloat64x2(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Float64x2 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat64x2(index, value);
+      return;
     }
-    _setIndexedFloat64x2(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 18 matching lines @@
 class _ExternalInt8Array extends _TypedList with _IntListMixin implements Int8List {
   // Factory constructors.
 
   factory _ExternalInt8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getInt8(index);
     }
-    return _getInt8(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setInt8(index, value);
+      return;
     }
-    _setInt8(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 12 matching lines @@
   // Factory constructors.
 
   factory _ExternalUint8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getUint8(index);
     }
-    return _getUint8(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setUint8(index, _toUint8(value));
+      return;
     }
-    _setUint8(index, _toUint8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 11 matching lines @@
 class _ExternalUint8ClampedArray extends _TypedList with _IntListMixin implements Uint8ClampedList {
   // Factory constructors.
 
   factory _ExternalUint8ClampedArray(int length) {
     return _new(length);
   }
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getUint8(index);
     }
-    return _getUint8(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setUint8(index, _toClampedUint8(value));
+      return;
     }
-    _setUint8(index, _toClampedUint8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 12 matching lines @@
   // Factory constructors.
 
   factory _ExternalInt16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt16(index);
     }
-    return _getIndexedInt16(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt16(index, _toInt16(value));
+      return;
     }
-    _setIndexedInt16(index, _toInt16(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalUint16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedUint16(index);
     }
-    return _getIndexedUint16(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedUint16(index, _toUint16(value));
+      return;
     }
-    _setIndexedUint16(index, _toUint16(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalInt32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt32(index);
     }
-    return _getIndexedInt32(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt32(index, _toInt32(value));
+      return;
     }
-    _setIndexedInt32(index, _toInt32(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalUint32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedUint32(index);
     }
-    return _getIndexedUint32(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedUint32(index, _toUint32(value));
+      return;
     }
-    _setIndexedUint32(index, _toUint32(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalInt64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt64(index);
     }
-    return _getIndexedInt64(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt64(index, _toInt64(value));
+      return;
     }
-    _setIndexedInt64(index, _toInt64(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalUint64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedUint64(index);
     }
-    return _getIndexedUint64(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedUint64(index, _toUint64(value));
+      return;
     }
-    _setIndexedUint64(index, _toUint64(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalFloat32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat32(index);
     }
-    return _getIndexedFloat32(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat32(index, value);
+      return;
     }
-    _setIndexedFloat32(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalFloat64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat64(index);
     }
-    return _getIndexedFloat64(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat64(index, value);
+      return;
     }
-    _setIndexedFloat64(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalFloat32x4Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Float32x4 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat32x4(index);
     }
-    return _getIndexedFloat32x4(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Float32x4 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat32x4(index, value);
+      return;
     }
-    _setIndexedFloat32x4(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalInt32x4Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Int32x4 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedInt32x4(index);
     }
-    return _getIndexedInt32x4(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Int32x4 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedInt32x4(index, value);
+      return;
     }
-    _setIndexedInt32x4(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 20 matching lines @@
   // Factory constructors.
 
   factory _ExternalFloat64x2Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Float64x2 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _getIndexedFloat64x2(index);
     }
-    return _getIndexedFloat64x2(index);
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Float64x2 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _setIndexedFloat64x2(index, value);
+      return;
     }
-    _setIndexedFloat64x2(index, value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 297 matching lines @@
                             Int8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
                 length * Int8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getInt8(offsetInBytes +
+                               (index * Int8List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getInt8(offsetInBytes +
-                               (index * Int8List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
+                        _toInt8(value));
+      return;
     }
-    _typedData._setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
-                        _toInt8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 14 matching lines @@
                             Uint8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getUint8(offsetInBytes +
+                                (index * Uint8List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getUint8(offsetInBytes +
-                                (index * Uint8List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),

[Søren Gjesse, 2015/05/13 11:22:08]

Long line - more below.

[Lasse Reichstein Nielsen, 2015/05/18 12:21:09]

Done.

+                         _toUint8(value));
+      return;
     }
-    _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
-                         _toUint8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
                             Uint8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getUint8(offsetInBytes +
+                                (index * Uint8List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getUint8(offsetInBytes +
-                                (index * Uint8List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
+                         _toClampedUint8(value));
+      return;
     }
-    _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
-                         _toClampedUint8(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int16List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int16List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getInt16(offsetInBytes +
+                                (index * Int16List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getInt16(offsetInBytes +
-                                (index * Int16List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
+                         _toInt16(value));
+      return;
     }
-    _typedData._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
-                         _toInt16(value));
+    throw new RangeError.index(index, this, "index");
   }
 
   void setRange(int start, int end, Iterable iterable, [int skipCount = 0]) {
     if (ClassID.getID(iterable) == CodeUnits.cid) {
       end = RangeError.checkValidRange(start, end, this.length);
       int length = end - start;
       int byteStart = this.offsetInBytes + start * Int16List.BYTES_PER_ELEMENT;
       _typedData._setCodeUnits(iterable, byteStart, length, skipCount);
     } else {
       super.setRange(start, end, iterable, skipCount);
@@ skipping 25 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint16List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Uint16List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getUint16(offsetInBytes +
+                                 (index * Uint16List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getUint16(offsetInBytes +
-                                 (index * Uint16List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
+                          _toUint16(value));
+      return;
     }
-    _typedData._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
-                          _toUint16(value));
+    throw new RangeError.index(index, this, "index");
   }
 
   void setRange(int start, int end, Iterable iterable, [int skipCount = 0]) {
     if (ClassID.getID(iterable) == CodeUnits.cid) {
       end = RangeError.checkValidRange(start, end, this.length);
       int length = end - start;
       int byteStart = this.offsetInBytes + start * Uint16List.BYTES_PER_ELEMENT;
       _typedData._setCodeUnits(iterable, byteStart, length, skipCount);
     } else {
       super.setRange(start, end, iterable, skipCount);
@@ skipping 24 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int32List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getInt32(offsetInBytes +
+                                (index * Int32List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getInt32(offsetInBytes +
-                                (index * Int32List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
+                         _toInt32(value));
+      return;
     }
-    _typedData._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
-                         _toInt32(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint32List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Uint32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getUint32(offsetInBytes +
+                                 (index * Uint32List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getUint32(offsetInBytes +
-                                 (index * Uint32List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
+                          _toUint32(value));
+      return;
     }
-    _typedData._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
-                          _toUint32(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int64List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getInt64(offsetInBytes +
+                                (index * Int64List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getInt64(offsetInBytes +
-                                (index * Int64List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
+                         _toInt64(value));
+      return;
     }
-    _typedData._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
-                         _toInt64(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint64List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Uint64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getUint64(offsetInBytes +
+                                 (index * Uint64List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getUint64(offsetInBytes +
-                                 (index * Uint64List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
+                          _toUint64(value));
+      return;
     }
-    _typedData._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
-                          _toUint64(value));
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float32List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getFloat32(offsetInBytes +
+                                  (index * Float32List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getFloat32(offsetInBytes +
-                                  (index * Float32List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setFloat32(offsetInBytes +
+                           (index * Float32List.BYTES_PER_ELEMENT), value);
+      return;
     }
-    _typedData._setFloat32(offsetInBytes +
-                           (index * Float32List.BYTES_PER_ELEMENT), value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float64List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getFloat64(offsetInBytes +
+                                  (index * Float64List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getFloat64(offsetInBytes +
-                                  (index * Float64List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setFloat64(offsetInBytes +
+                          (index * Float64List.BYTES_PER_ELEMENT), value);
+      return;
     }
-    _typedData._setFloat64(offsetInBytes +
-                          (index * Float64List.BYTES_PER_ELEMENT), value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float32x4List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float32x4List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   Float32x4 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getFloat32x4(offsetInBytes +
+                                  (index * Float32x4List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getFloat32x4(offsetInBytes +
-                                  (index * Float32x4List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Float32x4 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setFloat32x4(offsetInBytes +
+                             (index * Float32x4List.BYTES_PER_ELEMENT), value);
+      return;
     }
-    _typedData._setFloat32x4(offsetInBytes +
-                             (index * Float32x4List.BYTES_PER_ELEMENT), value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int32x4List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int32x4List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   Int32x4 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getInt32x4(offsetInBytes +
+                                   (index * Int32x4List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getInt32x4(offsetInBytes +
-                                   (index * Int32x4List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Int32x4 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setInt32x4(offsetInBytes +
+                            (index * Int32x4List.BYTES_PER_ELEMENT), value);
+      return;
     }
-    _typedData._setInt32x4(offsetInBytes +
-                            (index * Int32x4List.BYTES_PER_ELEMENT), value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 15 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float64x2List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float64x2List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   Float64x2 operator[](int index) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      return _typedData._getFloat64x2(offsetInBytes +
+                                    (index * Float64x2List.BYTES_PER_ELEMENT));
     }
-    return _typedData._getFloat64x2(offsetInBytes +
-                                    (index * Float64x2List.BYTES_PER_ELEMENT));
+    throw new RangeError.index(index, this, "index");
   }
 
   void operator[]=(int index, Float64x2 value) {
-    if (index < 0 || index >= length) {
-      throw _newRangeError(index, length);
+    if (index >= 0 && index < length) {
+      _typedData._setFloat64x2(offsetInBytes +
+                             (index * Float64x2List.BYTES_PER_ELEMENT), value);
+      return;
     }
-    _typedData._setFloat64x2(offsetInBytes +
-                             (index * Float64x2List.BYTES_PER_ELEMENT), value);
+    throw new RangeError.index(index, this, "index");
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
 
 
@@ skipping 28 matching lines @@
     return _offset;
   }
 
   int get elementSizeInBytes {
     return 1;
   }
 
   // Method(s) implementing ByteData interface.
 
   int getInt8(int byteOffset) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      throw _newRangeError(byteOffset, length);
-    }
-    return _typedData._getInt8(_offset + byteOffset);
+    if (byteOffset >= 0 && byteOffset < length) {
+      return _typedData._getInt8(_offset + byteOffset);
+    }
+    throw new RangeError.index(byteOffset, this, "byteOffset");
   }
   void setInt8(int byteOffset, int value) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      throw _newRangeError(byteOffset, length);
-    }
-    _typedData._setInt8(_offset + byteOffset, value);
+    if (byteOffset >= 0 && byteOffset < length) {
+      _typedData._setInt8(_offset + byteOffset, value);
+      return;
+    }
+    throw new RangeError.index(byteOffset, this, "byteOffset");
   }
 
   int getUint8(int byteOffset) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      throw _newRangeError(byteOffset, length);
-    }
-    return _typedData._getUint8(_offset + byteOffset);
+    if (byteOffset >= 0 && byteOffset < length) {
+      return _typedData._getUint8(_offset + byteOffset);
+    }
+    throw new RangeError.index(byteOffset, this, "byteOffset");
   }
   void setUint8(int byteOffset, int value) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      throw _newRangeError(byteOffset, length);
-    }
-    _typedData._setUint8(_offset + byteOffset, value);
+    if (byteOffset >= 0 && byteOffset < length) {
+      _typedData._setUint8(_offset + byteOffset, value);
+      return;
+    }
+    throw new RangeError.index(byteOffset, this, "byteOffset");
   }
 
   int getInt16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 1 >= length) {
-      throw _newRangeError(byteOffset + 1, length);
-    }
-    var result = _typedData._getInt16(_offset + byteOffset);
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      return result;
-    }
-    return _byteSwap16(result).toSigned(16);
+    if (byteOffset >= 0 && byteOffset < length - 1) {
+      var result = _typedData._getInt16(_offset + byteOffset);
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        return result;
+      }
+      return _byteSwap16(result).toSigned(16);
+    }
+    throw new RangeError.range(byteOffset, 0, (length - 2), "byteOffset");
   }
   void setInt16(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 1 >= length) {
-      throw _newRangeError(byteOffset + 1, length);
-    }
-    _typedData._setInt16(_offset + byteOffset,
-        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap16(value));
+    if (byteOffset >= 0 && byteOffset < length - 1) {
+      _typedData._setInt16(_offset + byteOffset,
+          identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                    : _byteSwap16(value));
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, (length - 2), "byteOffset");
   }
 
   int getUint16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 1 >= length) {
-      throw _newRangeError(byteOffset + 1, length);
-    }
+    if (byteOffset >= 0 && byteOffset < length - 1) {
     var result = _typedData._getUint16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _byteSwap16(result);
+    }
+    throw new RangeError.range(byteOffset, 0, (length - 2), "byteOffset");
   }
   void setUint16(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 1 >= length) {
-      throw _newRangeError(byteOffset + 1, length);
-    }
-    _typedData._setUint16(_offset + byteOffset,
-        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap16(value));
+    if (byteOffset >= 0 && byteOffset < length - 1) {
+      _typedData._setUint16(_offset + byteOffset,
+          identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                    : _byteSwap16(value));
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, (length - 2), "byteOffset");
   }
 
   int getInt32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    var result = _typedData._getInt32(_offset + byteOffset);
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      return result;
-    }
-    return _byteSwap32(result).toSigned(32);
+    if (byteOffset >= 0 && byteOffset < length - 3) {
+      var result = _typedData._getInt32(_offset + byteOffset);
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        return result;
+      }
+      return _byteSwap32(result).toSigned(32);
+    }
+    throw new RangeError.range(byteOffset, 0, length - 4);
   }
   void setInt32(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    _typedData._setInt32(_offset + byteOffset,
-        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap32(value));
+    if (byteOffset >= 0 && byteOffset < length - 3) {
+      _typedData._setInt32(_offset + byteOffset,
+          identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                    : _byteSwap32(value));
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, length - 4);
   }
 
   int getUint32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    var result = _typedData._getUint32(_offset + byteOffset);
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      return result;
-    }
-    return _byteSwap32(result);
+    if (byteOffset >= 0 && byteOffset < length - 3) {
+      var result = _typedData._getUint32(_offset + byteOffset);
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        return result;
+      }
+      return _byteSwap32(result);
+    }
+    throw new RangeError.range(byteOffset, 0, length - 4);
   }
   void setUint32(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    _typedData._setUint32(_offset + byteOffset,
-        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap32(value));
+    if (byteOffset >= 0 && byteOffset < length - 3) {
+      _typedData._setUint32(_offset + byteOffset,
+          identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                    : _byteSwap32(value));
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, length - 4);
   }
 
   int getInt64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 7 >= length) {
-      throw _newRangeError(byteOffset + 7, length);
-    }
-    var result = _typedData._getInt64(_offset + byteOffset);
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      return result;
-    }
-    return _byteSwap64(result).toSigned(64);
+    if (byteOffset >= 0 && byteOffset < length - 7) {
+      var result = _typedData._getInt64(_offset + byteOffset);
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        return result;
+      }
+      return _byteSwap64(result).toSigned(64);
+    }
+    throw new RangeError.range(byteOffset, 0, length - 8, "byteOffset");
   }
   void setInt64(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 7 >= length) {
-      throw _newRangeError(byteOffset + 7, length);
-    }
-    _typedData._setInt64(_offset + byteOffset,
-        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap64(value));
+    if (byteOffset >= 0 && byteOffset < length - 7) {
+      _typedData._setInt64(_offset + byteOffset,
+          identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                    : _byteSwap64(value));
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, length - 8, "byteOffset");
   }
 
   int getUint64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 7 >= length) {
-      throw _newRangeError(byteOffset + 7, length);
-    }
-    var result = _typedData._getUint64(_offset + byteOffset);
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      return result;
-    }
-    return _byteSwap64(result);
+    if (byteOffset >= 0 && byteOffset < length - 7) {
+      var result = _typedData._getUint64(_offset + byteOffset);
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        return result;
+      }
+      return _byteSwap64(result);
+    }
+    throw new RangeError.range(byteOffset, 0, length - 8, "byteOffset");
   }
   void setUint64(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 7 >= length) {
-      throw _newRangeError(byteOffset + 7, length);
-    }
-    _typedData._setUint64(_offset + byteOffset,
-        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap64(value));
+    if (byteOffset >= 0 && byteOffset < length - 7) {
+      _typedData._setUint64(_offset + byteOffset,
+          identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                    : _byteSwap64(value));
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, length - 8, "byteOffset");
   }
 
   double getFloat32(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      return _typedData._getFloat32(_offset + byteOffset);
-    }
-    _convU32[0] = _byteSwap32(_typedData._getUint32(_offset + byteOffset));
-    return _convF32[0];
+    if (byteOffset >= 0 && byteOffset < length - 3) {
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        return _typedData._getFloat32(_offset + byteOffset);
+      }
+      _convU32[0] = _byteSwap32(_typedData._getUint32(_offset + byteOffset));
+      return _convF32[0];
+    }
+    throw new RangeError(byteOffset, 0, length - 4, "byteOffset");
   }
   void setFloat32(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      _typedData._setFloat32(_offset + byteOffset, value);
-      return;
-    }
-    _convF32[0] = value;
-    _typedData._setUint32(_offset + byteOffset, _byteSwap32(_convU32[0]));
+    if (byteOffset >= 0 && byteOffset < length - 3) {
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        _typedData._setFloat32(_offset + byteOffset, value);
+        return;
+      }
+      _convF32[0] = value;
+      _typedData._setUint32(_offset + byteOffset, _byteSwap32(_convU32[0]));
+      return;
+    }
+    throw new RangeError(byteOffset, 0, length - 4, "byteOffset");
   }
 
   double getFloat64(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 7 >= length) {
-      throw _newRangeError(byteOffset + 7, length);
-    }
-    if (identical(endian, Endianness.HOST_ENDIAN)) {
-      return _typedData._getFloat64(_offset + byteOffset);
-    }
-    _convU64[0] = _byteSwap64(_typedData._getUint64(_offset + byteOffset));
-    return _convF64[0];
+    if (byteOffset >= 0 && byteOffset < length - 7) {
+      if (identical(endian, Endianness.HOST_ENDIAN)) {
+        return _typedData._getFloat64(_offset + byteOffset);
+      }
+      _convU64[0] = _byteSwap64(_typedData._getUint64(_offset + byteOffset));
+      return _convF64[0];
+    }
+    throw new RangeError.range(byteOffset, 0, length - 8, "byteOffset");
   }
   void setFloat64(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 7 >= length) {
-      throw _newRangeError(byteOffset + 7, length);
-    }
+    if (byteOffset >= 0 && byteOffset < length - 7) {
     if (identical(endian, Endianness.HOST_ENDIAN)) {
-      _typedData._setFloat64(_offset + byteOffset, value);
-      return;
-    }
-    _convF64[0] = value;
-    _typedData._setUint64(_offset + byteOffset, _byteSwap64(_convU64[0]));
+        _typedData._setFloat64(_offset + byteOffset, value);
+        return;
+      }
+      _convF64[0] = value;
+      _typedData._setUint64(_offset + byteOffset, _byteSwap64(_convU64[0]));
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, length - 8, "byteOffset");
   }
 
   Float32x4 getFloat32x4(int byteOffset,
                          [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    // TODO(johnmccutchan) : Need to resolve this for endianity.
-    return _typedData._getFloat32x4(_offset + byteOffset);
+    if (byteOffset >= 0 && byteOffset < length - 15) {
+      // TODO(johnmccutchan) : Need to resolve this for endianity.
+      return _typedData._getFloat32x4(_offset + byteOffset);
+    }
+    throw new RangeError.range(byteOffset, 0, length - 16, "byteOffset");
   }
   void setFloat32x4(int byteOffset,
                     Float32x4 value,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset + 3 >= length) {
-      throw _newRangeError(byteOffset + 3, length);
-    }
-    // TODO(johnmccutchan) : Need to resolve this for endianity.
-    _typedData._setFloat32x4(_offset + byteOffset, value);
-
+    if (byteOffset >= 0 && byteOffset < length - 15) {
+      // TODO(johnmccutchan) : Need to resolve this for endianity.
+      _typedData._setFloat32x4(_offset + byteOffset, value);
+      return;
+    }
+    throw new RangeError.range(byteOffset, 0, length - 16, "byteOffset");
   }
 
   final TypedData _typedData;
   final int _offset;
   final int length;
 }
 
 int _byteSwap16(int value) {
   return ((value & 0xFF00) >> 8) |
          ((value & 0x00FF) << 8);
@@ skipping 93 matching lines @@
   }
 }
 
 
 int _defaultIfNull(object, value) {
   if (object == null) {
     return value;
   }
   return object;
 }
-
-
-_newRangeError(int index, int length) {
-  String message = "$index must be in the range [0..$length)";
-  return new RangeError(message);
-}