Tweaks in the VM's typed_data implementations.

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 406 matching lines @@
     int 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)) {
-      _throwRangeError(start, length + 1);
+      throw _newRangeError(start, length + 1);
     }
     if ((end < 0) || (end > length)) {
-      _throwRangeError(end, length + 1);
+      throw _newRangeError(end, length + 1);
     }
     if (start > end) {
-      _throwRangeError(start, end + 1);
+      throw _newRangeError(start, end + 1);
     }
     if (skipCount < 0) {
       throw new ArgumentError(skipCount);
     }
 
     final count = end - start;
     if ((from.length - skipCount) < count) {
       throw new StateError("Not enough elements");
     }
 
@@ skipping 393 matching lines @@
 
   factory _Int8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setInt8(index, _toInt8(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
@@ skipping 13 matching lines @@
   // Factory constructors.
 
   factory _Uint8Array(int length) {
     return _new(length);
   }
 
 
   // Methods implementing List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setUint8(index, _toUint8(value));
   }
 
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
@@ skipping 12 matching lines @@
   // Factory constructors.
 
   factory _Uint8ClampedArray(int length) {
     return _new(length);
   }
 
   // Methods implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setUint8(index, _toClampedUint8(value));
   }
 
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
@@ skipping 14 matching lines @@
 
   factory _Int16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt16(index, _toInt16(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
@@ skipping 22 matching lines @@
 
   factory _Uint16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedUint16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedUint16(index, _toUint16(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
@@ skipping 22 matching lines @@
 
   factory _Int32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt32(index, _toInt32(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
@@ skipping 22 matching lines @@
 
   factory _Uint32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedUint32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedUint32(index, _toUint32(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
@@ skipping 22 matching lines @@
 
   factory _Int64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt64(index, _toInt64(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
@@ skipping 22 matching lines @@
 
   factory _Uint64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedUint64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedUint64(index, _toUint64(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
@@ skipping 22 matching lines @@
 
   factory _Float32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat32(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat32(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
@@ skipping 22 matching lines @@
 
   factory _Float64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat64(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat64(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
@@ skipping 20 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat32x4(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
@@ skipping 20 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt32x4(index);
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt32x4(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
@@ skipping 20 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat64x2(index);
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat64x2(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
@@ skipping 21 matching lines @@
   // Factory constructors.
 
   factory _ExternalInt8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setInt8(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
@@ skipping 15 matching lines @@
 
   factory _ExternalUint8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setUint8(index, _toUint8(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
@@ skipping 14 matching lines @@
   // Factory constructors.
 
   factory _ExternalUint8ClampedArray(int length) {
     return _new(length);
   }
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setUint8(index, _toClampedUint8(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
@@ skipping 15 matching lines @@
 
   factory _ExternalInt16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt16(index, _toInt16(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalUint16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedUint16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedUint16(index, _toUint16(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalInt32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt32(index, _toInt32(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalUint32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedUint32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedUint32(index, _toUint32(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalInt64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt64(index, _toInt64(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalUint64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedUint64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedUint64(index, _toUint64(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalFloat32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat32(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat32(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalFloat64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat64(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat64(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalFloat32x4Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat32x4(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalInt32x4Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Int32x4 operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedInt32x4(index);
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedInt32x4(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
@@ skipping 23 matching lines @@
 
   factory _ExternalFloat64x2Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Float64x2 operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _getIndexedFloat64x2(index);
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _setIndexedFloat64x2(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
@@ skipping 300 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
                 length * Int8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getInt8(offsetInBytes +
                                (index * Int8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
                         _toInt8(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
@@ skipping 18 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
+      
     }
     return _typedData._getUint8(offsetInBytes +
                                 (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toUint8(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getUint8(offsetInBytes +
                                 (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toClampedUint8(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getInt16(offsetInBytes +
                                 (index * Int16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
                          _toInt16(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getUint16(offsetInBytes +
                                  (index * Uint16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
                           _toUint16(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getInt32(offsetInBytes +
                                 (index * Int32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
                          _toInt32(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getUint32(offsetInBytes +
                                  (index * Uint32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
                           _toUint32(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getInt64(offsetInBytes +
                                 (index * Int64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
                          _toInt64(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getUint64(offsetInBytes +
                                  (index * Uint64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
                           _toUint64(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getFloat32(offsetInBytes +
                                   (index * Float32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setFloat32(offsetInBytes +
                            (index * Float32List.BYTES_PER_ELEMENT), value);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getFloat64(offsetInBytes +
                                   (index * Float64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setFloat64(offsetInBytes +
                           (index * Float64List.BYTES_PER_ELEMENT), value);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getFloat32x4(offsetInBytes +
                                   (index * Float32x4List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setFloat32x4(offsetInBytes +
                              (index * Float32x4List.BYTES_PER_ELEMENT), value);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getInt32x4(offsetInBytes +
                                    (index * Int32x4List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setInt32x4(offsetInBytes +
                             (index * Int32x4List.BYTES_PER_ELEMENT), value);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
@@ skipping 19 matching lines @@
                 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) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     return _typedData._getFloat64x2(offsetInBytes +
                                     (index * Float64x2List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
-      _throwRangeError(index, length);
+      throw _newRangeError(index, length);
     }
     _typedData._setFloat64x2(offsetInBytes +
                              (index * Float64x2List.BYTES_PER_ELEMENT), value);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
@@ skipping 32 matching lines @@
   }
 
   int get elementSizeInBytes {
     return 1;
   }
 
   // Method(s) implementing ByteData interface.
 
   int getInt8(int byteOffset) {
     if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+      throw _newRangeError(byteOffset, length);
     }
     return _typedData._getInt8(_offset + byteOffset);
   }
   void setInt8(int byteOffset, int value) {
     if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+      throw _newRangeError(byteOffset, length);
     }
     _typedData._setInt8(_offset + byteOffset, _toInt8(value));
   }
 
   int getUint8(int byteOffset) {
     if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+      throw _newRangeError(byteOffset, length);
     }
     return _typedData._getUint8(_offset + byteOffset);
   }
   void setUint8(int byteOffset, int value) {
     if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+      throw _newRangeError(byteOffset, length);
     }
     _typedData._setUint8(_offset + byteOffset, _toUint8(value));
   }
 
   int getInt16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
-      _throwRangeError(byteOffset + 1, length);
+      throw _newRangeError(byteOffset + 1, length);
     }
     var result = _typedData._getInt16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt16(result, endian._littleEndian);
   }
   void setInt16(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
-      _throwRangeError(byteOffset + 1, length);
+      throw _newRangeError(byteOffset + 1, length);
     }
     var set_value = _toInt16(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt16(set_value, endian._littleEndian);
     }
     _typedData._setInt16(_offset + byteOffset, set_value);
   }
 
   int getUint16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
-      _throwRangeError(byteOffset + 1, length);
+      throw _newRangeError(byteOffset + 1, length);
     }
     var result = _typedData._getUint16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint16(result, endian._littleEndian);
   }
   void setUint16(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
-      _throwRangeError(byteOffset + 1, length);
+      throw _newRangeError(byteOffset + 1, length);
     }
     var set_value = _toUint16(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint16(set_value, endian._littleEndian);
     }
     _typedData._setUint16(_offset + byteOffset, set_value);
   }
 
   int getInt32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getInt32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt32(result, endian._littleEndian);
   }
   void setInt32(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     var set_value = _toInt32(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt32(set_value, endian._littleEndian);
     }
     _typedData._setInt32(_offset + byteOffset, set_value);
   }
 
   int getUint32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getUint32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint32(result, endian._littleEndian);
   }
   void setUint32(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     var set_value = _toUint32(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint32(set_value, endian._littleEndian);
     }
     _typedData._setUint32(_offset + byteOffset, set_value);
   }
 
   int getInt64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
-      _throwRangeError(byteOffset + 7, length);
+      throw _newRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getInt64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt64(result, endian._littleEndian);
   }
   void setInt64(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
-      _throwRangeError(byteOffset + 7, length);
+      throw _newRangeError(byteOffset + 7, length);
     }
     var set_value = _toInt64(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt64(set_value, endian._littleEndian);
     }
     _typedData._setInt64(_offset + byteOffset, set_value);
   }
 
   int getUint64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
-      _throwRangeError(byteOffset + 7, length);
+      throw _newRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getUint64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint64(result, endian._littleEndian);
   }
   void setUint64(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
-      _throwRangeError(byteOffset + 7, length);
+      throw _newRangeError(byteOffset + 7, length);
     }
     var set_value = _toUint64(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint64(set_value, endian._littleEndian);
     }
     _typedData._setUint64(_offset + byteOffset, set_value);
   }
 
   double getFloat32(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getFloat32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianFloat32(result, endian._littleEndian);
   }
   void setFloat32(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     var set_value = value;
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianFloat32(set_value, endian._littleEndian);
     }
     _typedData._setFloat32(_offset + byteOffset, set_value);
   }
 
   double getFloat64(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
-      _throwRangeError(byteOffset + 7, length);
+      throw _newRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getFloat64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianFloat64(result, endian._littleEndian);
   }
   void setFloat64(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
-      _throwRangeError(byteOffset + 7, length);
+      throw _newRangeError(byteOffset + 7, length);
     }
     var set_value = value;
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianFloat64(set_value, endian._littleEndian);
     }
     _typedData._setFloat64(_offset + byteOffset, set_value);
   }
 
   Float32x4 getFloat32x4(int byteOffset,
                          [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
     return _typedData._getFloat32x4(_offset + byteOffset);
   }
   void setFloat32x4(int byteOffset,
                     Float32x4 value,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
-      _throwRangeError(byteOffset + 3, length);
+      throw _newRangeError(byteOffset + 3, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
     _typedData._setFloat32x4(_offset + byteOffset, value);
 
   }
 
 
   // Internal utility methods.
 
   static int _toEndianInt16(int host_value, bool little_endian)
@@ skipping 97 matching lines @@
 
 
 int _defaultIfNull(object, value) {
   if (object == null) {
     return value;
   }
   return object;
 }
 
 
-void _throwRangeError(int index, int length) {
+void _newRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
-  throw new RangeError(message);
+  return new RangeError(message);
 }