Move common logic into the base class.

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.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
 
   /* patch */ factory Int8List.transferable(int length) {
@@ skipping 1790 matching lines @@
     return _array._setFloat64(_offset + byteOffset, value);
   }
 
   final _ByteArrayBase _array;
   final int _offset;
   final int _length;
 }
 
 
 class _ByteArrayViewBase {
+  final ByteArray _array;

[cshapiro, 2013/01/07 23:25:58]

Can you move the private field declarations to the bottom of the class
definition for consistency with the rest of this file?

[Anton Muhin, 2013/01/09 15:35:57]

Done.

+  final int _offset;
+  final int length;
+
+  _ByteArrayViewBase(this._array, this._offset, this.length);
+
   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 16 matching lines @@
   }
 
   bool some(bool f(element)) {
     return Collections.some(this, f);;
   }
 
   bool get isEmpty {
     return this.length == 0;
   }
 
-  int get length;
-
   // Methods implementing the List interface.
 
   set length(newLength) {
     throw new UnsupportedError(
         "Cannot resize a non-extendable array");
   }
 
   void add(value) {
     throw new UnsupportedError(
         "Cannot add to a non-extendable array");
@@ skipping 47 matching lines @@
   }
 
   void insertRange(int start, int length, [initialValue]) {
     throw new UnsupportedError(
         "Cannot add to a non-extendable array");
   }
 }
 
 
 class _Int8ArrayView extends _ByteArrayViewBase implements Int8List {
-  _Int8ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
-    : _array = array,
-      _offset = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Int8ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getInt8(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Uint8ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getUint8(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Int16ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getInt16(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Uint16ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getUint16(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Int32ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getInt32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Uint32ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getUint32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Int64ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getInt64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Uint64ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   int operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getUint64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Float32ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   double operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getFloat32(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const 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 = _requireInteger(offsetInBytes),
-      _length = _requireIntegerOrNull(
-        length,
-        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT)) {
-    _rangeCheck(array.lengthInBytes(), _offset, _length * _BYTES_PER_ELEMENT);
-  }
-
-  get length {
-    return _length;
+  _Float64ArrayView(ByteArray array, [int offsetInBytes = 0, int _length])
+    : super(array, _requireInteger(offsetInBytes),
+      _requireIntegerOrNull(
+        _length,
+        ((array.lengthInBytes() - offsetInBytes) ~/ _BYTES_PER_ELEMENT))) {
+    _rangeCheck(array.lengthInBytes(), _offset, length * _BYTES_PER_ELEMENT);
   }
 
   double operator[](int index) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     return _array.getFloat64(_offset + (index * _BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
-    if (index < 0 || index >= _length) {
-      String message = "$index must be in the range [0..$_length)";
+    if (index < 0 || index >= length) {
+      String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _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.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;
+    return length * _BYTES_PER_ELEMENT;
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
     if (length == null) {
       length = this.lengthInBytes();
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
-  final ByteArray _array;
-  final int _offset;
-  final int _length;
 }