Add typed data view creation functions on ByteBuffer.

runtime/lib/typed_data.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 import "dart:_internal";
 import 'dart:math' show Random;
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
 
   /* patch */ factory Int8List.fromList(List<int> elements) {
     return new _Int8Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Int8List.view(ByteBuffer buffer,
-                                    [int offsetInBytes = 0, int length]) {
-    return new _Int8ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Uint8List {
   /* patch */ factory Uint8List(int length) {
     return new _Uint8Array(length);
   }
 
   /* patch */ factory Uint8List.fromList(List<int> elements) {
     return new _Uint8Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Uint8List.view(ByteBuffer buffer,
-                                     [int offsetInBytes = 0, int length]) {
-    return new _Uint8ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Uint8ClampedList {
   /* patch */ factory Uint8ClampedList(int length) {
     return new _Uint8ClampedArray(length);
   }
 
   /* patch */ factory Uint8ClampedList.fromList(List<int> elements) {
     return new _Uint8ClampedArray(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Uint8ClampedList.view(ByteBuffer buffer,
-                                            [int offsetInBytes = 0,
-                                             int length]) {
-    return new _Uint8ClampedArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Int16List {
   /* patch */ factory Int16List(int length) {
     return new _Int16Array(length);
   }
 
   /* patch */ factory Int16List.fromList(List<int> elements) {
     return new _Int16Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Int16List.view(ByteBuffer buffer,
-                                     [int offsetInBytes = 0, int length]) {
-    return new _Int16ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Uint16List {
   /* patch */ factory Uint16List(int length) {
     return new _Uint16Array(length);
   }
 
   /* patch */ factory Uint16List.fromList(List<int> elements) {
     return new _Uint16Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Uint16List.view(ByteBuffer buffer,
-                                      [int offsetInBytes = 0, int length]) {
-    return new _Uint16ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Int32List {
   /* patch */ factory Int32List(int length) {
     return new _Int32Array(length);
   }
 
   /* patch */ factory Int32List.fromList(List<int> elements) {
     return new _Int32Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Int32List.view(ByteBuffer buffer,
-                                     [int offsetInBytes = 0, int length]) {
-    return new _Int32ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Uint32List {
   /* patch */ factory Uint32List(int length) {
     return new _Uint32Array(length);
   }
 
   /* patch */ factory Uint32List.fromList(List<int> elements) {
     return new _Uint32Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Uint32List.view(ByteBuffer buffer,
-                                      [int offsetInBytes = 0, int length]) {
-    return new _Uint32ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Int64List {
   /* patch */ factory Int64List(int length) {
     return new _Int64Array(length);
   }
 
   /* patch */ factory Int64List.fromList(List<int> elements) {
     return new _Int64Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Int64List.view(ByteBuffer buffer,
-                                     [int offsetInBytes = 0, int length]) {
-    return new _Int64ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Uint64List {
   /* patch */ factory Uint64List(int length) {
     return new _Uint64Array(length);
   }
 
   /* patch */ factory Uint64List.fromList(List<int> elements) {
     return new _Uint64Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Uint64List.view(ByteBuffer buffer,
-                                      [int offsetInBytes = 0, int length]) {
-    return new _Uint64ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Float32List {
   /* patch */ factory Float32List(int length) {
     return new _Float32Array(length);
   }
 
   /* patch */ factory Float32List.fromList(List<double> elements) {
     return new _Float32Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Float32List.view(ByteBuffer buffer,
-                                       [int offsetInBytes = 0, int length]) {
-    return new _Float32ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Float64List {
   /* patch */ factory Float64List(int length) {
     return new _Float64Array(length);
   }
 
   /* patch */ factory Float64List.fromList(List<double> elements) {
     return new _Float64Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
+}
 
-  /* patch */ factory Float64List.view(ByteBuffer buffer,
-                                       [int offsetInBytes = 0, int length]) {
-    return new _Float64ArrayView(buffer, offsetInBytes, length);
-  }
-}
 
 patch class Float32x4List {
   /* patch */ factory Float32x4List(int length) {
     return new _Float32x4Array(length);
   }
 
   /* patch */ factory Float32x4List.fromList(List<Float32x4> elements) {
     return new _Float32x4Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Float32x4List.view(ByteBuffer buffer,
-                                         [int offsetInBytes = 0, int length]) {
-    return new _Float32x4ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Int32x4List {
   /* patch */ factory Int32x4List(int length) {
     return new _Int32x4Array(length);
   }
 
   /* patch */ factory Int32x4List.fromList(List<Int32x4> elements) {
     return new _Int32x4Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
 
-  /* patch */ factory Int32x4List.view(ByteBuffer buffer,
-                                        [int offsetInBytes = 0, int length]) {
-    return new _Int32x4ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
-
 patch class Float64x2List {
   /* patch */ factory Float64x2List(int length) {
     return new _Float64x2Array(length);
   }
 
   /* patch */ factory Float64x2List.fromList(List<Float64x2> elements) {
     return new _Float64x2Array(elements.length)
         ..setRange(0, elements.length, elements);
   }
-
-  /* patch */ factory Float64x2List.view(ByteBuffer buffer,
-                                         [int offsetInBytes = 0, int length]) {
-    return new _Float64x2ArrayView(buffer, offsetInBytes, length);
-  }
 }
 
 
 patch class Float32x4 {
   /* patch */ factory Float32x4(double x, double y, double z, double w) {
     return new _Float32x4(x, y, z, w);
   }
   /* patch */ factory Float32x4.splat(double v) {
     return new _Float32x4.splat(v);
   }
@@ skipping 40 matching lines @@
   }
 }
 
 
 patch class ByteData {
   /* patch */ factory ByteData(int length) {
     var list = new _Uint8Array(length);
     return new _ByteDataView(list, 0, length);
   }
 
-  /* patch */ factory ByteData.view(ByteBuffer buffer,
-                                    [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = buffer.lengthInBytes - offsetInBytes;
-    }
-    return new _ByteDataView(buffer._data, offsetInBytes, length);
-  }
-
   // Called directly from C code.
   factory ByteData._view(TypedData typedData, int offsetInBytes, int length) {
     return new _ByteDataView(typedData, offsetInBytes, length);
   }
 }
 
 
 // Based class for _TypedList that provides common methods for implementing
 // the collection and list interfaces.
 
@@ skipping 291 matching lines @@
 class _ByteBuffer implements ByteBuffer {
   final _TypedList _data;
 
   _ByteBuffer(this._data);
 
   // Forward calls to _data.
   int get lengthInBytes => _data.lengthInBytes;
   int get hashCode => _data.hashCode;
   bool operator==(Object other) =>
       (other is _ByteBuffer) && identical(_data, other._data);
+
+  ByteData asByteData([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = this.lengthInBytes - offsetInBytes;
+    }
+    return new _ByteDataView(this._data, offsetInBytes, length);
+  }
+
+  Int8List asInt8List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = this.lengthInBytes - offsetInBytes;
+    }
+    return new _Int8ArrayView(this, offsetInBytes, length);
+  }
+
+  Uint8List asUint8List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = this.lengthInBytes - offsetInBytes;
+    }
+    return new _Uint8ArrayView(this, offsetInBytes, length);
+  }
+
+  Uint8ClampedList asUint8ClampedList([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = this.lengthInBytes - offsetInBytes;
+    }
+    return new _Uint8ClampedArrayView(this, offsetInBytes, length);
+  }
+
+  Int16List asInt16List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Int16List.BYTES_PER_ELEMENT;
+    }
+    return new _Int16ArrayView(this, offsetInBytes, length);
+  }
+
+  Uint16List asUint16List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Uint16List.BYTES_PER_ELEMENT;
+    }
+    return new _Uint16ArrayView(this, offsetInBytes, length);
+  }
+
+  Int32List asInt32List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Int32List.BYTES_PER_ELEMENT;
+    }
+    return new _Int32ArrayView(this, offsetInBytes, length);
+  }
+
+  Uint32List asUint32List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Uint32List.BYTES_PER_ELEMENT;
+    }
+    return new _Uint32ArrayView(this, offsetInBytes, length);
+  }
+
+  Int64List asInt64List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Int64List.BYTES_PER_ELEMENT;
+    }
+    return new _Int64ArrayView(this, offsetInBytes, length);
+  }
+
+  Uint64List asUint64List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Uint64List.BYTES_PER_ELEMENT;
+    }
+    return new _Uint64ArrayView(this, offsetInBytes, length);
+  }
+
+  Float32List asFloat32List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Float32List.BYTES_PER_ELEMENT;
+    }
+    return new _Float32ArrayView(this, offsetInBytes, length);
+  }
+
+  Float64List asFloat64List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Float64List.BYTES_PER_ELEMENT;
+    }
+    return new _Float64ArrayView(this, offsetInBytes, length);
+  }
+
+  Float32x4List asFloat32x4List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Float32x4List.BYTES_PER_ELEMENT;
+    }
+    return new _Float32x4ArrayView(this, offsetInBytes, length);
+  }
+
+  Int32x4List asInt32x4List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Int32x4List.BYTES_PER_ELEMENT;
+    }
+    return new _Int32x4ArrayView(this, offsetInBytes, length);
+  }
+
+  Float64x2List asFloat64x2List([int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (this.lengthInBytes - offsetInBytes) ~/
+               Float64x2List.BYTES_PER_ELEMENT;
+    }
+    return new _Float64x2ArrayView(this, offsetInBytes, length);
+  }
 }
 
 
 abstract class _TypedList extends _TypedListBase {
   // Default method implementing parts of the TypedData interface.
   int get offsetInBytes {
     return 0;
   }
 
   int get lengthInBytes {
@@ skipping 54 matching lines @@
 }
 
 
 class _Int8Array extends _TypedList implements Int8List {
   // Factory constructors.
 
   factory _Int8Array(int length) {
     return _new(length);
   }
 
-  factory _Int8Array.view(ByteBuffer buffer,
-                          [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = buffer.lengthInBytes - offsetInBytes;
-    }
-    return new _Int8ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getInt8(index);
   }
 
@@ skipping 26 matching lines @@
 }
 
 
 class _Uint8Array extends _TypedList implements Uint8List {
   // Factory constructors.
 
   factory _Uint8Array(int length) {
     return _new(length);
   }
 
-  factory _Uint8Array.view(ByteBuffer buffer,
-                           [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = buffer.lengthInBytes - offsetInBytes;
-    }
-    return new _Uint8ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Methods implementing List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
@@ skipping 24 matching lines @@
 }
 
 
 class _Uint8ClampedArray extends _TypedList implements Uint8ClampedList {
   // Factory constructors.
 
   factory _Uint8ClampedArray(int length) {
     return _new(length);
   }
 
-  factory _Uint8ClampedArray.view(ByteBuffer buffer,
-                                  [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = buffer.lengthInBytes - offsetInBytes;
-    }
-    return new _Uint8ClampedArrayView(buffer, offsetInBytes, length);
-  }
-
   // Methods implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
@@ skipping 25 matching lines @@
 }
 
 
 class _Int16Array extends _TypedList implements Int16List {
   // Factory constructors.
 
   factory _Int16Array(int length) {
     return _new(length);
   }
 
-  factory _Int16Array.view(ByteBuffer buffer,
-                           [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-               Int16List.BYTES_PER_ELEMENT;
-    }
-    return new _Int16ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt16(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Uint16Array extends _TypedList implements Uint16List {
   // Factory constructors.
 
   factory _Uint16Array(int length) {
     return _new(length);
   }
 
-  factory _Uint16Array.view(ByteBuffer buffer,
-                            [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-                Uint16List.BYTES_PER_ELEMENT;
-    }
-    return new _Uint16ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint16(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Int32Array extends _TypedList implements Int32List {
   // Factory constructors.
 
   factory _Int32Array(int length) {
     return _new(length);
   }
 
-  factory _Int32Array.view(ByteBuffer buffer,
-                           [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-                Int32List.BYTES_PER_ELEMENT;
-    }
-    return new _Int32ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt32(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Uint32Array extends _TypedList implements Uint32List {
   // Factory constructors.
 
   factory _Uint32Array(int length) {
     return _new(length);
   }
 
-  factory _Uint32Array.view(ByteBuffer buffer,
-                            [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-                Uint32List.BYTES_PER_ELEMENT;
-    }
-    return new _Uint32ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint32(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Int64Array extends _TypedList implements Int64List {
   // Factory constructors.
 
   factory _Int64Array(int length) {
     return _new(length);
   }
 
-  factory _Int64Array.view(ByteBuffer buffer,
-                           [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-                Int32List.BYTES_PER_ELEMENT;
-    }
-    return new _Int64ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt64(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Uint64Array extends _TypedList implements Uint64List {
   // Factory constructors.
 
   factory _Uint64Array(int length) {
     return _new(length);
   }
 
-  factory _Uint64Array.view(ByteBuffer buffer,
-                            [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-               Uint64List.BYTES_PER_ELEMENT;
-    }
-    return new _Uint64ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint64(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Float32Array extends _TypedList implements Float32List {
   // Factory constructors.
 
   factory _Float32Array(int length) {
     return _new(length);
   }
 
-  factory _Float32Array.view(ByteBuffer buffer,
-                             [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-               Float32List.BYTES_PER_ELEMENT;
-    }
-    return new _Float32ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat32(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Float64Array extends _TypedList implements Float64List {
   // Factory constructors.
 
   factory _Float64Array(int length) {
     return _new(length);
   }
 
-  factory _Float64Array.view(ByteBuffer buffer,
-                             [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-               Float64List.BYTES_PER_ELEMENT;
-    }
-    return new _Float64ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat64(index);
   }
 
@@ skipping 34 matching lines @@
 }
 
 
 class _Float32x4Array extends _TypedList implements Float32x4List {
   // Factory constructors.
 
   factory _Float32x4Array(int length) {
     return _new(length);
   }
 
-  factory _Float32x4Array.view(ByteBuffer buffer,
-                               [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-               Float32x4List.BYTES_PER_ELEMENT;
-    }
-    return new _Float32x4ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
@@ skipping 32 matching lines @@
 }
 
 
 class _Int32x4Array extends _TypedList implements Int32x4List {
   // Factory constructors.
 
   factory _Int32x4Array(int length) {
     return _new(length);
   }
 
-  factory _Int32x4Array.view(ByteBuffer buffer,
-                              [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-               Int32x4List.BYTES_PER_ELEMENT;
-    }
-    return new _Int32x4ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   Int32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt32x4(index);
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
@@ skipping 32 matching lines @@
 }
 
 
 class _Float64x2Array extends _TypedList implements Float64x2List {
   // Factory constructors.
 
   factory _Float64x2Array(int length) {
     return _new(length);
   }
 
-  factory _Float64x2Array.view(ByteBuffer buffer,
-                               [int offsetInBytes = 0, int length]) {
-    if (length == null) {
-      length = (buffer.lengthInBytes - offsetInBytes) ~/
-               Float64x2List.BYTES_PER_ELEMENT;
-    }
-    return new _Float64x2ArrayView(buffer, offsetInBytes, length);
-  }
-
 
   Float64x2 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat64x2(index);
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
@@ skipping 2142 matching lines @@
     return value;
   }
   return object;
 }
 
 
 void _throwRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   throw new RangeError(message);
 }