Fix some warnings in the core library identified by the static analyzer.

runtime/lib/byte_array.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * A random-access sequence of bytes that also provides random access to
  * the fixed-width integers and floating point numbers represented by
  * those bytes. Byte arrays may be used to pack and unpack data from
  * external sources (such as networks or files systems), and to process
  * large quantities of numerical data more efficiently than would be possible
@@ skipping 667 matching lines @@
    */
   Float64List.view(ByteArray array, [int start, int length]);
 }
 
 
 class _Int8ArrayFactory {
   factory Int8List(int length) {
     return new _Int8Array(length);
   }
 
-  factory Int8List.view(ByteArray array, [int start, int length]) {
+  factory Int8List.view(ByteArray array, [int start = 0, int length]) {
     return new _Int8ArrayView(array, start, length);
   }
 }
 
 
 class _Uint8ArrayFactory {
   factory Uint8List(int length) {
     return new _Uint8Array(length);
   }
 
-  factory Uint8List.view(ByteArray array, [int start, int length]) {
+  factory Uint8List.view(ByteArray array, [int start = 0, int length]) {
     return new _Uint8ArrayView(array, start, length);
   }
 }
 
 
 class _Int16ArrayFactory {
   factory Int16List(int length) {
     return new _Int16Array(length);
   }
 
-  factory Int16List.view(ByteArray array, [int start, int length]) {
+  factory Int16List.view(ByteArray array, [int start = 0, int length]) {
     return new _Int16ArrayView(array, start, length);
   }
 }
 
 
 class _Uint16ArrayFactory {
   factory Uint16List(int length) {
     return new _Uint16Array(length);
   }
 
-  factory Uint16List.view(ByteArray array, [int start, int length]) {
+  factory Uint16List.view(ByteArray array, [int start = 0, int length]) {
     return new _Uint16ArrayView(array, start, length);
   }
 }
 
 
 class _Int32ArrayFactory {
   factory Int32List(int length) {
     return new _Int32Array(length);
   }
 
-  factory Int32List.view(ByteArray array, [int start, int length]) {
+  factory Int32List.view(ByteArray array, [int start = 0, int length]) {
     return new _Int32ArrayView(array, start, length);
   }
 }
 
 
 class _Uint32ArrayFactory {
   factory Uint32List(int length) {
     return new _Uint32Array(length);
   }
 
-  factory Uint32List.view(ByteArray array, [int start, int length]) {
+  factory Uint32List.view(ByteArray array, [int start = 0, int length]) {
     return new _Uint32ArrayView(array, start, length);
   }
 }
 
 
 class _Int64ArrayFactory {
   factory Int64List(int length) {
     return new _Int64Array(length);
   }
 
-  factory Int64List.view(ByteArray array, [int start, int length]) {
+  factory Int64List.view(ByteArray array, [int start = 0, int length]) {
     return new _Int64ArrayView(array, start, length);
   }
 }
 
 
 class _Uint64ArrayFactory {
   factory Uint64List(int length) {
     return new _Uint64Array(length);
   }
 
-  factory Uint64List.view(ByteArray array, [int start, int length]) {
+  factory Uint64List.view(ByteArray array, [int start = 0, int length]) {
     return new _Uint64ArrayView(array, start, length);
   }
 }
 
 
 class _Float32ArrayFactory {
   factory Float32List(int length) {
     return new _Float32Array(length);
   }
 
-  factory Float32List.view(ByteArray array, [int start, int length]) {
+  factory Float32List.view(ByteArray array, [int start = 0, int length]) {
     return new _Float32ArrayView(array, start, length);
   }
 }
 
 
 class _Float64ArrayFactory {
   factory Float64List(int length) {
     return new _Float64Array(length);
   }
 
-  factory Float64List.view(ByteArray array, [int start, int length]) {
+  factory Float64List.view(ByteArray array, [int start = 0, int length]) {
     return new _Float64ArrayView(array, start, length);
   }
 }
 
 
 abstract class _ByteArrayBase {
+  abstract int lengthInBytes();
+
+  abstract int bytesPerElement();
+
+  abstract operator[](int index);
 
   // Methods implementing the Collection interface.
 
   void forEach(void f(element)) {
     var len = this.length;
     for (var i = 0; i < len; i++) {
       f(this[i]);
     }
   }
 
   Collection map(f(element)) {
     return Collections.map(this,
                            new GrowableObjectArray.withCapacity(length),
                            f);
   }
 
   Collection filter(bool f(element)) {
     return Collections.filter(this, new GrowableObjectArray(), f);
   }
 
   bool every(bool f(element)) {
     return Collections.every(this, f);
   }
 
   bool some(bool f(element)) {
-    return Collections.some(this, f);;
+    return Collections.some(this, f);
   }
 
   bool isEmpty() {
     return this.length === 0;
   }
 
   int get length() {
     return _length();
   }
 
@@ skipping 51 matching lines @@
         "Cannot remove from a non-extendable array");
   }
 
   void insertRange(int start, int length, [initialValue]) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length === null) {
-      length = this.lengthInBytes();
+      length = this.length;
     }
-    return new _ByteArrayView(this, start, length);
+    _rangeCheck(this.length, start, length);
+    return new _ByteArrayView(this,
+                              start * this.bytesPerElement(),
+                              length * this.bytesPerElement());

[siva, 2012/06/21 23:33:08]

why not 
assert(this.bytesPerElement() === 1);
and leave it the way it was.

[cshapiro, 2012/06/22 04:27:00]

Good question.  Keeping the code exactly the same between all types makes it
easier to write the emacs keyboard macros I use to make changes to all 20 cases.
 I'd like to keep this stuff as structurally similar as possible until that
becomes impossible to do.

   }
 
   int _length() native "ByteArray_getLength";
 
   void _setRange(int startInBytes, int lengthInBytes,
                  _ByteArrayBase from, int startFromInBytes)
       native "ByteArray_setRange";
 
   int _getInt8(int byteOffset) native "ByteArray_getInt8";
   int _setInt8(int byteOffset, int value) native "ByteArray_setInt8";
@@ skipping 58 matching lines @@
 
 
 int _toInt64(int value) {
   return _toInt(value, 0xFFFFFFFFFFFFFFFF);
 }
 int _toUint64(int value) {
   return value & 0xFFFFFFFFFFFFFFFF;
 }
 
 
-void _rangeCheck(List a, int start, int length) {
+void _rangeCheck(int listLength, int start, int length) {
   if (length < 0) {
     throw new IllegalArgumentException("negative length $length");
   }
   if (start < 0) {
-    throw new IndexOutOfRangeException("negative start $start");
+    throw new IllegalArgumentException("negative start $start");
   }
-  if (start + length > a.length) {
+  if (start + length > listLength) {
     throw new IndexOutOfRangeException(start + length);
   }
 }
 
 
+int _requireInteger(object) {
+  if (object is int) {
+    return object;
+  }
+  throw new IllegalArgumentException("$object is not an integer");
+}
+
+
+int _requireIntegerOrNull(object, value) {
+  if (object is int) {
+    return object;
+  }
+  if (object === null) {
+    return _requireInteger(value);
+  }
+  throw new IllegalArgumentException("$object is not an integer or null");
+}
+
+
 class _Int8Array extends _ByteArrayBase implements Int8List {
   factory _Int8Array(int length) {
     return _new(length);
   }
 
   factory _Int8Array.view(ByteArray array, [int start = 0, int length]) {
     if (length === null) {
       length = array.lengthInBytes();
     }
     return new _Int8ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toInt8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int8Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toUint8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint8Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toInt16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int16Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toUint16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint16Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toInt32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int32Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toUint32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint32Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toInt64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int64Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, int value) {
     _setIndexed(index, _toUint64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint64Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<double> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _Float32Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 31 matching lines @@
 
   void operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<double> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _Float64Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 11 matching lines @@
   double _getIndexed(int index) native "Float64Array_getIndexed";
   void _setIndexed(int index, double value) native "Float64Array_setIndexed";
 }
 
 
 class _ExternalInt8Array extends _ByteArrayBase implements Int8List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toInt8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt8Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static final int _BYTES_PER_ELEMENT = 1;
 
   int _getIndexed(int index) native "ExternalInt8Array_getIndexed";
   void _setIndexed(int index, int value) native "ExternalInt8Array_setIndexed";
 }
 
 
 class _ExternalUint8Array extends _ByteArrayBase implements Uint8List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toUint8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint8Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static final int _BYTES_PER_ELEMENT = 1;
 
   int _getIndexed(int index) native "ExternalUint8Array_getIndexed";
   void _setIndexed(int index, int value) native "ExternalUint8Array_setIndexed";
 }
 
 
 class _ExternalInt16Array extends _ByteArrayBase implements Int16List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toInt16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt16Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static final int _BYTES_PER_ELEMENT = 2;
 
   int _getIndexed(int index) native "ExternalInt16Array_getIndexed";
   void _setIndexed(int index, int value) native "ExternalInt16Array_setIndexed";
 }
 
 
 class _ExternalUint16Array extends _ByteArrayBase implements Uint16List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toUint16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint16Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 11 matching lines @@
   void _setIndexed(int index, int value)
       native "ExternalUint16Array_setIndexed";
 }
 
 
 class _ExternalInt32Array extends _ByteArrayBase implements Int32List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toInt32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt32Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 11 matching lines @@
   void _setIndexed(int index, int value)
       native "ExternalInt32Array_setIndexed";
 }
 
 
 class _ExternalUint32Array extends _ByteArrayBase implements Uint32List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toUint32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint32Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 11 matching lines @@
   void _setIndexed(int index, int value)
       native "ExternalUint32Array_setIndexed";
 }
 
 
 class _ExternalInt64Array extends _ByteArrayBase implements Int64List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toInt64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt64Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
@@ skipping 11 matching lines @@
   void _setIndexed(int index, int value)
       native "ExternalInt64Array_setIndexed";
 }
 
 
 class _ExternalUint64Array extends _ByteArrayBase implements Uint64List {
   int operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, int value) {
+  void operator[]=(int index, int value) {
     _setIndexed(index, _toUint64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint64Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static final int _BYTES_PER_ELEMENT = 8;
 
   int _getIndexed(int index)
       native "ExternalUint64Array_getIndexed";
   void _setIndexed(int index, int value)
       native "ExternalUint64Array_setIndexed";
 }
 
 
 class _ExternalFloat32Array extends _ByteArrayBase implements Float32List {
-  int operator[](int index) {
+  double operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, double value) {
+  void operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<double> result = new Float32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _ExternalFloat32Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static final int _BYTES_PER_ELEMENT = 4;
 
   double _getIndexed(int index)
       native "ExternalFloat32Array_getIndexed";
   void _setIndexed(int index, double value)
       native "ExternalFloat32Array_setIndexed";
 }
 
 
 class _ExternalFloat64Array extends _ByteArrayBase implements Float64List {
-  int operator[](int index) {
+  double operator[](int index) {
     return _getIndexed(index);
   }
 
-  int operator[]=(int index, double value) {
+  void operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<double> result = new Float64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _ExternalFloat64Array) {
-      int startInBytes = start * _BYTES_PER_ELEMENT;
-      int lengthInBytes = length * _BYTES_PER_ELEMENT;
-      int startFromInBytes = startFrom * _BYTES_PER_ELEMENT;
-      _setRange(startInBytes, lengthInBytes, from, startFromInBytes);
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static final int _BYTES_PER_ELEMENT = 8;
 
   double _getIndexed(int index)
       native "ExternalFloat64Array_getIndexed";
   void _setIndexed(int index, double value)
       native "ExternalFloat64Array_setIndexed";
 }
 
 
 class _ByteArrayIterator<E> implements Iterator<E> {
-  _ByteArrayIterator(_ByteArrayBase array)
-    : _array = array, _length = array.length, _pos = 0;
+  _ByteArrayIterator(List array)
+    : _array = array, _length = array.length, _pos = 0 {
+    assert(array is _ByteArrayBase || array is _ByteArrayViewBase);
+  }
 
   bool hasNext() {
    return _length > _pos;
   }
 
   E next() {
     if (!hasNext()) {
       throw const NoMoreElementsException();
     }
     return _array[_pos++];
   }
 
   final List<E> _array;
-
   final int _length;
-
   int _pos;
 }
 
 
 class _ByteArrayView implements ByteArray {
   _ByteArrayView(this._array, this._offset, this._length) {
+    _rangeCheck(_array.lengthInBytes(), _offset, _length);
   }
 
   int lengthInBytes() {
     return _length;
   }
 
   ByteArray subByteArray([int start = 0, int length]) {
     if (length === null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
     return new _ByteArrayView(_array, _offset + start, length);
   }
 
   int getInt8(int byteOffset) {
     return _array._getInt8(_offset + byteOffset);
   }
-  void setInt8(int byteOffset, int value) {
-    _array._setInt8(_offset + byteOffset, value);
+  int setInt8(int byteOffset, int value) {

[siva, 2012/06/21 23:33:08]

Why do these set methods not return void like the others and instead return int

[cshapiro, 2012/06/22 04:27:00]

Another good question!  This is actually documented in the interface. 
Basically, the amount of bytes displaced is returned so you can write code like
this

  pos += dst.setInt8(pos, x);
  pos += dst.setFloat64(pos, y);
  pos += dst.setUint16(pos, z);
 
when writing formatted binary data

[siva, 2012/06/22 18:12:30]

dst.setInt8(pos, x); is equivalent to dst[pos] = x;

but 
pos += (dst[pos] = x);
is not quite the same, that is what makes it confusing 

On 2012/06/22 04:27:00, cshapiro wrote:

+    return _array._setInt8(_offset + byteOffset, value);
   }
 
   int getUint8(int byteOffset) {
     return _array._getUint8(_offset + byteOffset);
   }
-  void setUint8(int byteOffset, int value) {
-    _array._setUint8(_offset + byteOffset, value);
+  int setUint8(int byteOffset, int value) {
+    return _array._setUint8(_offset + byteOffset, value);
   }
 
   int getInt16(int byteOffset) {
     return _array._getInt16(_offset + byteOffset);
   }
-  void setInt16(int byteOffset, int value) {
-    _array._setInt16(_offset + byteOffset, value);
+  int setInt16(int byteOffset, int value) {
+    return _array._setInt16(_offset + byteOffset, value);
   }
 
   int getUint16(int byteOffset) {
     return _array._getUint16(_offset + byteOffset);
   }
-  void setUint16(int byteOffset, int value) {
-    _array._setUint16(_offset + byteOffset, value);
+  int setUint16(int byteOffset, int value) {
+    return _array._setUint16(_offset + byteOffset, value);
   }
 
   int getInt32(int byteOffset) {
     return _array._getInt32(_offset + byteOffset);
   }
-  void setInt32(int byteOffset, int value) {
-    _array._setInt32(_offset + byteOffset, value);
+  int setInt32(int byteOffset, int value) {
+    return _array._setInt32(_offset + byteOffset, value);
   }
 
   int getUint32(int byteOffset) {
     return _array._getUint32(_offset + byteOffset);
   }
-  void setUint32(int byteOffset, int value) {
-    _array._setUint32(_offset + byteOffset, value);
+  int setUint32(int byteOffset, int value) {
+    return _array._setUint32(_offset + byteOffset, value);
   }
 
   int getInt64(int byteOffset) {
     return _array._getInt64(_offset + byteOffset);
   }
-  void setInt64(int byteOffset, int value) {
-    _array._setInt64(_offset + byteOffset, value);
+  int setInt64(int byteOffset, int value) {
+    return _array._setInt64(_offset + byteOffset, value);
   }
 
   int getUint64(int byteOffset) {
     return _array._getUint64(_offset + byteOffset);
   }
-  void setUint64(int byteOffset, int value) {
-    _array._setUint64(_offset + byteOffset, value);
+  int setUint64(int byteOffset, int value) {
+    return _array._setUint64(_offset + byteOffset, value);
   }
 
   double getFloat32(int byteOffset) {
     return _array._getFloat32(_offset + byteOffset);
   }
-  void setFloat32(int byteOffset, double value) {
-    _array._setFloat32(_offset + byteOffset, value);
+  int setFloat32(int byteOffset, double value) {
+    return _array._setFloat32(_offset + byteOffset, value);
   }
 
   double getFloat64(int byteOffset) {
     return _array._getFloat64(_offset + byteOffset);
   }
-  void setFloat64(int byteOffset, double value) {
-    _array._setFloat64(_offset + byteOffset, value);
+  int setFloat64(int byteOffset, double value) {
+    return _array._setFloat64(_offset + byteOffset, value);
   }
 
   final _ByteArrayBase _array;
   final int _offset;
   final int _length;
 }
 
 
 class _ByteArrayViewBase {
+  abstract num operator[](int index);
 
   // Methods implementing the Collection interface.
 
   void forEach(void f(element)) {
     var len = this.length;
     for (var i = 0; i < len; i++) {
       f(this[i]);
     }
   }
 
@@ skipping 12 matching lines @@
   }
 
   bool some(bool f(element)) {
     return Collections.some(this, f);;
   }
 
   bool isEmpty() {
     return this.length === 0;
   }
 
-  int get length() {
-    return _length();
-  }
+  abstract int get length();
 
   // Methods implementing the List interface.
 
   set length(newLength) {
     throw const UnsupportedOperationException(
         "Cannot resize a non-extendable array");
   }
 
   void add(value) {
     throw const UnsupportedOperationException(
@@ skipping 45 matching lines @@
   void insertRange(int start, int length, [initialValue]) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 }
 
 
 class _Int8ArrayView extends _ByteArrayViewBase implements Int8List {
   _Int8ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getInt8(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setInt8(_offset + (index * _BYTES_PER_ELEMENT), _toInt8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 1;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Uint8ArrayView extends _ByteArrayViewBase implements Uint8List {
   _Uint8ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getUint8(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setUint8(_offset + (index * _BYTES_PER_ELEMENT), _toUint8(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 1;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Int16ArrayView extends _ByteArrayViewBase implements Int16List {
   _Int16ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getInt16(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setInt16(_offset + (index * _BYTES_PER_ELEMENT), _toInt16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 2;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Uint16ArrayView extends _ByteArrayViewBase implements Uint16List {
   _Uint16ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getUint16(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setUint16(_offset + (index * _BYTES_PER_ELEMENT), _toUint16(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 2;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Int32ArrayView extends _ByteArrayViewBase implements Int32List {
   _Int32ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getInt32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setInt32(_offset + (index * _BYTES_PER_ELEMENT), _toInt32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 4;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Uint32ArrayView extends _ByteArrayViewBase implements Uint32List {
   _Uint32ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getUint32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setUint32(_offset + (index * _BYTES_PER_ELEMENT), _toUint32(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 4;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Int64ArrayView extends _ByteArrayViewBase implements Int64List {
   _Int64ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getInt64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setInt64(_offset + (index * _BYTES_PER_ELEMENT), _toInt64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Int64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Uint64ArrayView extends _ByteArrayViewBase implements Uint64List {
   _Uint64ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }

[siva, 2012/06/21 23:33:08]

This check code seems identical in each of the views why not make a method in
ByteArrayViewBase and invoke it from here.

[cshapiro, 2012/06/22 04:27:00]

Yes, this is doing pretty much what _rangeCheck already does!  So, I have
replaced this call with a call to _rangeCheck.

   }
 
   get length() {
     return _length;
   }
 
   int operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getUint64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setUint64(_offset + (index * _BYTES_PER_ELEMENT), _toUint64(value));
   }
 
   Iterator<int> iterator() {
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<int> result = new Uint64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Float32ArrayView extends _ByteArrayViewBase implements Float32List {
   _Float32ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;  // TODO: broken
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   double operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getFloat32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setFloat32(_offset + (index * _BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<double> result = new Float32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 4;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }
 
 
 class _Float64ArrayView extends _ByteArrayViewBase implements Float64List {
   _Float64ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
-      _offset = offsetInBytes,
-      _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
-    : length {
+      _offset = _requireInteger(offsetInBytes),
+      _length = _requireIntegerOrNull(
+        length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
       throw new IndexOutOfRangeException(offsetInBytes);
     }
-    int lengthInBytes = length * _BYTES_PER_ELEMENT;
-    if (length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
-      throw new IndexOutOfRangeException(length);
+    int lengthInBytes = _length * _BYTES_PER_ELEMENT;
+    if (_length < 0 || (lengthInBytes + _offset) > array.lengthInBytes()) {
+      throw new IndexOutOfRangeException(_length);
     }
   }
 
   get length() {
     return _length;
   }
 
   double operator[](int index) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     return _array.getFloat64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= _length) {
       throw new IndexOutOfRangeException(index);
     }
     _array.setFloat64(_offset + (index * _BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> iterator() {
     return new _ByteArrayIterator<double>(this);
   }
 
   List<double> getRange(int start, int length) {
-    _rangeCheck(this, start, length);
+    _rangeCheck(this.length, start, length);
     List<double> result = new Float64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
-    _rangeCheck(start, length);
+    _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }