Use offsetInBytes and not index in the get/set accessors of views.

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 457 matching lines @@
   }
 
 
   // Methods implementing the collection interface.
 
   int get length native "TypedData_length";
 
 
   // Internal utility methods.
 
-  int _getInt8(int index) native "TypedData_GetInt8";
-  void _setInt8(int index, int value) native "TypedData_SetInt8";
+  int _getInt8(int offsetInBytes) native "TypedData_GetInt8";
+  void _setInt8(int offsetInBytes, int value) native "TypedData_SetInt8";
 
-  int _getUint8(int index) native "TypedData_GetUint8";
-  void _setUint8(int index, int value) native "TypedData_SetUint8";
+  int _getUint8(int offsetInBytes) native "TypedData_GetUint8";
+  void _setUint8(int offsetInBytes, int value) native "TypedData_SetUint8";
 
-  int _getInt16(int index) native "TypedData_GetInt16";
-  void _setInt16(int index, int value) native "TypedData_SetInt16";
+  int _getInt16(int offsetInBytes) native "TypedData_GetInt16";
+  void _setInt16(int offsetInBytes, int value) native "TypedData_SetInt16";
 
-  int _getUint16(int index) native "TypedData_GetUint16";
-  void _setUint16(int index, int value) native "TypedData_SetUint16";
+  int _getUint16(int offsetInBytes) native "TypedData_GetUint16";
+  void _setUint16(int offsetInBytes, int value) native "TypedData_SetUint16";
 
-  int _getInt32(int index) native "TypedData_GetInt32";
-  void _setInt32(int index, int value) native "TypedData_SetInt32";
+  int _getInt32(int offsetInBytes) native "TypedData_GetInt32";
+  void _setInt32(int offsetInBytes, int value) native "TypedData_SetInt32";
 
-  int _getUint32(int index) native "TypedData_GetUint32";
-  void _setUint32(int index, int value) native "TypedData_SetUint32";
+  int _getUint32(int offsetInBytes) native "TypedData_GetUint32";
+  void _setUint32(int offsetInBytes, int value) native "TypedData_SetUint32";
 
-  int _getInt64(int index) native "TypedData_GetInt64";
-  void _setInt64(int index, int value) native "TypedData_SetInt64";
+  int _getInt64(int offsetInBytes) native "TypedData_GetInt64";
+  void _setInt64(int offsetInBytes, int value) native "TypedData_SetInt64";
 
-  int _getUint64(int index) native "TypedData_GetUint64";
-  void _setUint64(int index, int value) native "TypedData_SetUint64";
+  int _getUint64(int offsetInBytes) native "TypedData_GetUint64";
+  void _setUint64(int offsetInBytes, int value) native "TypedData_SetUint64";
 
-  double _getFloat32(int index) native "TypedData_GetFloat32";
-  void _setFloat32(int index, double value) native "TypedData_SetFloat32";
+  double _getFloat32(int offsetInBytes) native "TypedData_GetFloat32";
+  void _setFloat32(int offsetInBytes, double value)
+      native "TypedData_SetFloat32";
 
-  double _getFloat64(int index) native "TypedData_GetFloat64";
-  void _setFloat64(int index, double value) native "TypedData_SetFloat64";
+  double _getFloat64(int offsetInBytes) native "TypedData_GetFloat64";
+  void _setFloat64(int offsetInBytes, double value)
+      native "TypedData_SetFloat64";
 }
 
 
 class _Int8Array extends _TypedList implements Int8List {
   // Factory constructors.
 
   factory _Int8Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
       throw new ArgumentError(message);
@@ skipping 189 matching lines @@
   }
 
 
   // 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);
     }
-    return _getInt16(index);
+    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);
     }
-    _setInt16(index, _toInt16(value));
+    _setIndexedInt16(index, _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.
 
   _Int16Array _createList(int length) {
     return _new(length);
   }
 
+  int _getIndexedInt16(int index) {
+    return _getInt16(index * Int16List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedInt16(int index, int value) {
+    _setInt16(index * Int16List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Int16Array _new(int length) native "TypedData_Int16Array_new";
 }
 
 
 class _Uint16Array extends _TypedList implements Uint16List {
   // Factory constructors.
 
   factory _Uint16Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 12 matching lines @@
   }
 
 
   // 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);
     }
-    return _getUint16(index);
+    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);
     }
-    _setUint16(index, _toUint16(value));
+    _setIndexedUint16(index, _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint16Array _createList(int length) {
     return _new(length);
   }
 
+  int _getIndexedUint16(int index) {
+    return _getUint16(index * Uint16List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint16(int index, int value) {
+    _setUint16(index * Uint16List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Uint16Array _new(int length) native "TypedData_Uint16Array_new";
 }
 
 
 class _Int32Array extends _TypedList implements Int32List {
   // Factory constructors.
 
   factory _Int32Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 12 matching lines @@
   }
 
 
   // 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);
     }
-    return _getInt32(index);
+    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);
     }
-    _setInt32(index, _toInt32(value));
+    _setIndexedInt32(index, _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.
 
   _Int32Array _createList(int length) {
     return _new(length);
   }
 
+  int _getIndexedInt32(int index) {
+    return _getInt32(index * Int32List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedInt32(int index, int value) {
+    _setInt32(index * Int32List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Int32Array _new(int length) native "TypedData_Int32Array_new";
 }
 
 
 class _Uint32Array extends _TypedList implements Uint32List {
   // Factory constructors.
 
   factory _Uint32Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 12 matching lines @@
   }
 
 
   // 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);
     }
-    return _getUint32(index);
+    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);
     }
-    _setUint32(index, _toUint32(value));
+    _setIndexedUint32(index, _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint32Array _createList(int length) {
     return _new(length);
   }
 
+  int _getIndexedUint32(int index) {
+    return _getUint32(index * Uint32List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint32(int index, int value) {
+    _setInt32(index * Uint32List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Uint32Array _new(int length) native "TypedData_Uint32Array_new";
 }
 
 
 class _Int64Array extends _TypedList implements Int64List {
   // Factory constructors.
 
   factory _Int64Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 12 matching lines @@
   }
 
 
   // 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);
     }
-    return _getInt64(index);
+    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);
     }
-    _setInt64(index, _toInt64(value));
+    _setIndexedInt64(index, _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int64Array _createList(int length) {
     return _new(length);
   }
 
+  int _getIndexedInt64(int index) {
+    return _getInt64(index * Int64List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedInt64(int index, int value) {
+    _setInt64(index * Int64List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Int64Array _new(int length) native "TypedData_Int64Array_new";
 }
 
 
 class _Uint64Array extends _TypedList implements Uint64List {
   // Factory constructors.
 
   factory _Uint64Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 12 matching lines @@
   }
 
 
   // 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);
     }
-    return _getUint64(index);
+    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);
     }
-    _setUint64(index, _toUint64(value));
+    _setIndexedUint64(index, _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint64Array _createList(int length) {
     return _new(length);
   }
 
+  int _getIndexedUint64(int index) {
+    return _getUint64(index * Uint64List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint64(int index, int value) {
+    _setUint64(index * Uint64List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Uint64Array _new(int length) native "TypedData_Uint64Array_new";
 }
 
 
 class _Float32Array extends _TypedList implements Float32List {
   // Factory constructors.
 
   factory _Float32Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 12 matching lines @@
   }
 
 
   // 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);
     }
-    return _getFloat32(index);
+    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);
     }
-    _setFloat32(index, value);
+    _setIndexedFloat32(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float32Array _createList(int length) {
     return _new(length);
   }
 
+  double _getIndexedFloat32(int index) {
+    return _getFloat32(index * Float32List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedFloat32(int index, double value) {
+    _setFloat32(index * Float32List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Float32Array _new(int length) native "TypedData_Float32Array_new";
 }
 
 
 class _Float64Array extends _TypedList implements Float64List {
   // Factory constructors.
 
   factory _Float64Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 12 matching lines @@
   }
 
 
   // 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);
     }
-    return _getFloat64(index);
+    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);
     }
-    _setFloat64(index, value);
+    _setIndexedFloat64(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float64Array _createList(int length) {
     return _new(length);
   }
 
+  double _getIndexedFloat64(int index) {
+    return _getFloat64(index * Float64List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedFloat64(int index, double value) {
+    _setFloat64(index * Float64List.BYTES_PER_ELEMENT, value);
+  }
+
   static _Float64Array _new(int length) native "TypedData_Float64Array_new";
 }
 
 
 class _ExternalInt8Array extends _TypedList implements Int8List {
   // Factory constructors.
 
   factory _ExternalInt8Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
@@ skipping 161 matching lines @@
   }
 
 
   // 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);
     }
-    return _getInt16(index);
+    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);
     }
-    _setInt16(index, _toInt16(value));
+    _setIndexedInt16(index, _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int16List _createList(int length) {
     return new Int16List(length);
   }
 
+  int _getIndexedInt16(int index) {
+    return _getInt16(index * Int16List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedInt16(int index, int value) {
+    _setInt16(index * Int16List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalInt16Array _new(int length) native
       "ExternalTypedData_Int16Array_new";
 }
 
 
 class _ExternalUint16Array extends _TypedList implements Uint16List {
   // Factory constructors.
 
   factory _ExternalUint16Array(int length) {
     if (length < 0) {
       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);
     }
-    return _getUint16(index);
+    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);
     }
-    _setUint16(index, _toUint16(value));
+    _setIndexedUint16(index, _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint16List _createList(int length) {
     return new Uint16List(length);
   }
 
+  int _getIndexedUint16(int index) {
+    return _getUint16(index * Uint16List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint16(int index, int value) {
+    _setUint16(index * Uint16List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalUint16Array _new(int length) native
       "ExternalTypedData_Uint16Array_new";
 }
 
 
 class _ExternalInt32Array extends _TypedList implements Int32List {
   // Factory constructors.
   
   factory _ExternalInt32Array(int length) {
     if (length < 0) {
       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);
     }
-    return _getInt32(index);
+    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);
     }
-    _setInt32(index, _toInt32(value));
+    _setIndexedInt32(index, _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int32List _createList(int length) {
     return new Int32List(length);
   }
 
+  int _getIndexedInt32(int index) {
+    return _getInt32(index * Int32List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedInt32(int index, int value) {
+    _setInt32(index * Int32List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalInt32Array _new(int length) native
       "ExternalTypedData_Int32Array_new";
 }
 
 
 class _ExternalUint32Array extends _TypedList implements Uint32List {
   // Factory constructors.
 
   factory _ExternalUint32Array(int length) {
     if (length < 0) {
       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);
     }
-    return _getUint32(index);
+    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);
     }
-    _setUint32(index, _toUint32(value));
+    _setIndexedUint32(index, _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint32List _createList(int length) {
     return new Uint32List(length);
   }
 
+  int _getIndexedUint32(int index) {
+    return _getUint32(index * Uint32List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint32(int index, int value) {
+    _setInt32(index * Uint32List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalUint32Array _new(int length) native
       "ExternalTypedData_Uint32Array_new";
 }
 
 
 class _ExternalInt64Array extends _TypedList implements Int64List {
   // Factory constructors.
 
   factory _ExternalInt64Array(int length) {
     if (length < 0) {
       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);
     }
-    return _getInt64(index);
+    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);
     }
-    _setInt64(index, _toInt64(value));
+    _setIndexedInt64(index, _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int64List _createList(int length) {
     return new Int64List(length);
   }
 
+  int _getIndexedInt64(int index) {
+    return _getInt64(index * Int64List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedInt64(int index, int value) {
+    _setInt64(index * Int64List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalInt64Array _new(int length) native
       "ExternalTypedData_Int64Array_new";
 }
 
 
 class _ExternalUint64Array extends _TypedList implements Uint64List {
   // Factory constructors.
 
   factory _ExternalUint64Array(int length) {
     if (length < 0) {
       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);
     }
-    return _getUint64(index);
+    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);
     }
-    _setUint64(index, _toUint64(value));
+    _setIndexedUint64(index, _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
-  Uint64List _createList(int length) {
-    return new Uint64List(length);
-  }
-
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
+  Uint64List _createList(int length) {
+    return new Uint64List(length);
+  }
+
+  int _getIndexedUint64(int index) {
+    return _getUint64(index * Uint64List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint64(int index, int value) {
+    _setUint64(index * Uint64List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalUint64Array _new(int length) native
       "ExternalTypedData_Uint64Array_new";
 }
 
 
 class _ExternalFloat32Array extends _TypedList implements Float32List {
   // Factory constructors.
 
   factory _ExternalFloat32Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
       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);
     }
-    return _getFloat32(index);
+    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);
     }
-    _setFloat32(index, value);
+    _setIndexedFloat32(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float32List _createList(int length) {
     return new Float32List(length);
   }
 
+  double _getIndexedFloat32(int index) {
+    return _getFloat32(index * Float32List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedFloat32(int index, double value) {
+    _setFloat32(index * Float32List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalFloat32Array _new(int length) native
       "ExternalTypedData_Float32Array_new";
 }
 
 
 class _ExternalFloat64Array extends _TypedList implements Float64List {
   // Factory constructors.
 
   factory _ExternalFloat64Array(int length) {
     if (length < 0) {
       String message = "$length must be greater than 0";
       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);
     }
-    return _getFloat64(index);
+    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);
     }
-    _setFloat64(index, value);
+    _setIndexedFloat64(index, value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float64List _createList(int length) {
     return new Float64List(length);
   }
 
+  double _getIndexedFloat64(int index) {
+    return _getFloat64(index * Float64List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedFloat64(int index, double value) {
+    _setFloat64(index * Float64List.BYTES_PER_ELEMENT, value);
+  }
+
   static _ExternalFloat64Array _new(int length) native
       "ExternalTypedData_Float64Array_new";
 }
 
 
 class _TypedListIterator<E> implements Iterator<E> {
   final List<E> _array;
   final int _length;
   int _position;
   E _current;
@@ skipping 718 matching lines @@
   }
 }
 
 
 int _defaultIfNull(object, value) {
   if (object == null) {
     return value;
   }
   return object;
 }