Adapt remaining dart:scalarlist tests to use dart:typeddata

runtime/lib/typeddata.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.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
@@ skipping 575 matching lines @@
       length = buffer.lengthInBytes;
     }
     return new _Int8ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setInt8(index, _toInt8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
@@ skipping 29 matching lines @@
     if (length == null) {
       length = buffer.lengthInBytes;
     }
     return new _Uint8ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Methods implementing List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setUint8(index, _toUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Methods implementing TypedData interface.
@@ skipping 29 matching lines @@
       length = buffer.lengthInBytes;
     }
     return new _Uint8ClampedArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Methods implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setUint8(index, _toClampedUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Methods implementing TypedData interface.
@@ skipping 31 matching lines @@
                Int16List.BYTES_PER_ELEMENT;
     }
     return new _Int16ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedInt16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedInt16(index, _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
@@ skipping 39 matching lines @@
                 Uint16List.BYTES_PER_ELEMENT;
     }
     return new _Uint16ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedUint16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedUint16(index, _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 39 matching lines @@
                 Int32List.BYTES_PER_ELEMENT;
     }
     return new _Int32ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedInt32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedInt32(index, _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
@@ skipping 39 matching lines @@
                 Uint32List.BYTES_PER_ELEMENT;
     }
     return new _Uint32ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedUint32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedUint32(index, _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 39 matching lines @@
                 Int32List.BYTES_PER_ELEMENT;
     }
     return new _Int64ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedInt64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedInt64(index, _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 39 matching lines @@
                Uint64List.BYTES_PER_ELEMENT;
     }
     return new _Uint64ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedUint64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedUint64(index, _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 39 matching lines @@
                Float32List.BYTES_PER_ELEMENT;
     }
     return new _Float32ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedFloat32(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedFloat32(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 39 matching lines @@
                Float64List.BYTES_PER_ELEMENT;
     }
     return new _Float64ArrayView(buffer, offsetInBytes, length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedFloat64(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedFloat64(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 36 matching lines @@
     if (length == null) {
       length = (buffer.lengthInBytes - offsetInBytes) ~/
                Float32x4List.BYTES_PER_ELEMENT;
     }
     return new _Float32x4ArrayView(buffer, offsetInBytes, length);
   }
 
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedFloat32x4(index, value);
   }
 
   Iterator<Float32x4> get iterator {
     return new _TypedListIterator<Float32x4>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 29 matching lines @@
       String message = "$length must be greater than 0";
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setInt8(index, value);
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 23 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setUint8(index, _toUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 23 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setUint8(index, _toClampedUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 23 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedInt16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedInt16(index, _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedUint16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedUint16(index, _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedInt32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedInt32(index, _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedUint32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedUint32(index, _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedInt64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedInt64(index, _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedUint64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedUint64(index, _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedFloat32(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedFloat32(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedFloat64(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedFloat64(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 31 matching lines @@
       throw new ArgumentError(message);
     }
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _setIndexedFloat32x4(index, value);
   }
 
   Iterator<Float32x4> get iterator {
     return new _TypedListIterator<Float32x4>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
@@ skipping 225 matching lines @@
 
 class _Int8ArrayView extends _TypedListView implements Int8List {
   // Constructor.
   _Int8ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
-                _length * Int8List.BYTES_PER_ELEMENT);
+                length * Int8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getInt8(offsetInBytes +
                                (index * Int8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
                         _toInt8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Int8List _createList(int length) {
+    return new Int8List(length);
+  }
 }
 
 
 class _Uint8ArrayView extends _TypedListView implements Uint8List {
   // Constructor.
   _Uint8ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
-                _length * Uint8List.BYTES_PER_ELEMENT);
+                length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getUint8(offsetInBytes +
                                 (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Uint8List _createList(int length) {
+    return new Uint8List(length);
+  }
 }
 
 
 class _Uint8ClampedArrayView extends _TypedListView implements Uint8List {
   // Constructor.
   _Uint8ClampedArrayView(ByteBuffer buffer,
                          [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             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) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getUint8(offsetInBytes +
                                 (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toClampedUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Uint8ClampedList _createList(int length) {
+    return new Uint8ClampedList(length);
+  }
 }
 
 
 class _Int16ArrayView extends _TypedListView implements Int16List {
   // Constructor.
   _Int16ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int16List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int16List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getInt16(offsetInBytes +
                                 (index * Int16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
                          _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Int16List _createList(int length) {
+    return new Int16List(length);
+  }
 }
 
 
 class _Uint16ArrayView extends _TypedListView implements Uint16List {
   // Constructor.
   _Uint16ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint16List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint16List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getUint16(offsetInBytes +
                                  (index * Uint16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
                           _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Uint16List _createList(int length) {
+    return new Uint16List(length);
+  }
 }
 
 
 class _Int32ArrayView extends _TypedListView implements Int32List {
   // Constructor.
   _Int32ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int32List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getInt32(offsetInBytes +
                                 (index * Int32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
                          _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Int32List _createList(int length) {
+    return new Int32List(length);
+  }
 }
 
 
 class _Uint32ArrayView extends _TypedListView implements Uint32List {
   // Constructor.
   _Uint32ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint32List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getUint32(offsetInBytes +
                                  (index * Uint32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
                           _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Uint32List _createList(int length) {
+    return new Uint32List(length);
+  }
 }
 
 
 class _Int64ArrayView extends _TypedListView implements Int64List {
   // Constructor.
   _Int64ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int64List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getInt64(offsetInBytes +
                                 (index * Int64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
                          _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Int64List _createList(int length) {
+    return new Int64List(length);
+  }
 }
 
 
 class _Uint64ArrayView extends _TypedListView implements Uint64List {
   // Constructor.
   _Uint64ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint64List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getUint64(offsetInBytes +
                                  (index * Uint64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
                           _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Uint64List _createList(int length) {
+    return new Uint64List(length);
+  }
 }
 
 
 class _Float32ArrayView extends _TypedListView implements Float32List {
   // Constructor.
   _Float32ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Float32List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getFloat32(offsetInBytes +
                                   (index * Float32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setFloat32(offsetInBytes +
                            (index * Float32List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Float32List _createList(int length) {
+    return new Float32List(length);
+  }
 }
 
 
 class _Float64ArrayView extends _TypedListView implements Float64List {
   // Constructor.
   _Float64ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Float64List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getFloat64(offsetInBytes +
                                   (index * Float64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setFloat64(offsetInBytes +
                           (index * Float64List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Float64List _createList(int length) {
+    return new Float64List(length);
+  }
 }
 
 
 class _Float32x4ArrayView extends _TypedListView implements Float32x4List {
   // Constructor.
   _Float32x4ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Float32x4List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float32x4List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     return _typeddata._getFloat32x4(offsetInBytes +
                                   (index * Float32x4List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
-      String message = "$index must be in the range [0..$length)";
-      throw new RangeError(message);
+      _throwRangeError(index, length);
     }
     _typeddata._setFloat32x4(offsetInBytes +
                              (index * Float32x4List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<Float32x4> get iterator {
     return new _TypedListIterator<Float32x4>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
+
+
+  // Internal utility methods.
+
+  Float32x4List _createList(int length) {
+    return new Float32x4List(length);
+  }
 }
 
 
 class _ByteDataView implements ByteData {
   _ByteDataView(ByteBuffer _buffer, int _offsetInBytes, int _lengthInBytes)
-    : _typeddata = _buffer as TypedData,
+    : _typeddata = _buffer,  // _buffer is guaranteed to be a TypedData here.
       _offset = _offsetInBytes,
       length = _lengthInBytes {
     _rangeCheck(_buffer.lengthInBytes, _offset, length);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   ByteBuffer get buffer {
     return _typeddata.buffer;
   }
 
   int get lengthInBytes {
     return length;
   }
 
   int get offsetInBytes {
     return _offset;
   }
 
   // Method(s) implementing ByteData interface.
 
   int getInt8(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getInt8(_offset + byteOffset);
   }
   void setInt8(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setInt8(_offset + byteOffset, value);
   }
 
   int getUint8(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getUint8(_offset + byteOffset);
   }
   void setUint8(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setUint8(_offset + byteOffset, value);
   }
 
   int getInt16(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getInt16(_offset + byteOffset);
   }
   void setInt16(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setInt16(_offset + byteOffset, value);
   }
 
   int getUint16(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getUint16(_offset + byteOffset);
   }
   void setUint16(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setUint16(_offset + byteOffset, value);
   }
 
   int getInt32(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getInt32(_offset + byteOffset);
   }
   void setInt32(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setInt32(_offset + byteOffset, value);
   }
 
   int getUint32(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getUint32(_offset + byteOffset);
   }
   void setUint32(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setUint32(_offset + byteOffset, value);
   }
 
   int getInt64(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getInt64(_offset + byteOffset);
   }
   void setInt64(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setInt64(_offset + byteOffset, value);
   }
 
   int getUint64(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getUint64(_offset + byteOffset);
   }
   void setUint64(int byteOffset, int value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setUint64(_offset + byteOffset, value);
   }
 
   double getFloat32(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getFloat32(_offset + byteOffset);
   }
   void setFloat32(int byteOffset, double value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setFloat32(_offset + byteOffset, value);
   }
 
   double getFloat64(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getFloat64(_offset + byteOffset);
   }
   void setFloat64(int byteOffset, double value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setFloat64(_offset + byteOffset, value);
   }
 
   Float32x4 getFloat32x4(int byteOffset) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     return _typeddata._getFloat32x4(_offset + byteOffset);
   }
   void setFloat32x4(int byteOffset, Float32x4 value) {
+    if (byteOffset < 0 || byteOffset >= length) {
+      _throwRangeError(byteOffset, length);
+    }
     _typeddata._setFloat32x4(_offset + byteOffset, value);
 
   }
 
   final TypedData _typeddata;
   final int _offset;
   final int length;
 }
 
 
@@ skipping 64 matching lines @@
   }
 }
 
 
 int _defaultIfNull(object, value) {
   if (object == null) {
     return value;
   }
   return object;
 }
+
+
+void _throwRangeError(int index, int length) {
+  String message = "$index must be in the range [0..$length)";
+  throw new RangeError(message);
+}