Change getRange to sublist. Make getRange deprecated.

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 538 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt8(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int8Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
          this, start, length, from, startFrom);
     }
@@ skipping 37 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint8Array || from is _ExternalUint8Array ||
         from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
@@ skipping 39 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toClampedUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint8Array || from is _ExternalUint8Array ||
         from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
@@ skipping 38 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int16Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 37 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint16Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 37 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int32Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 38 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint32Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 37 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Int64Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 37 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _Uint64Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 37 matching lines @@
   }
 
   int operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> get iterator {
     return new _ByteArrayIterator<double>(this);
   }
 
-  List<double> getRange(int start, int length) {
+  List<double> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<double> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<double> getRange(int start, int length) =>
+      sublist(start, start + length);
+
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _Float32Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 37 matching lines @@
   }
 
   int operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> get iterator {
     return new _ByteArrayIterator<double>(this);
   }
 
-  List<double> getRange(int start, int length) {
+  List<double> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<double> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<double> getRange(int start, int length) =>
+      sublist(start, start + length);
+
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _Float64Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 26 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt8(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt8Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 24 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint8Array || from is _Uint8Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
     }
   }
@@ skipping 25 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toClampedUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint8ClampedList(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint8ClampedArray || from is _Uint8ClampedArray) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 24 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt16Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 24 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint16Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 26 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt32Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 26 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint32Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 26 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalInt64Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 26 matching lines @@
   }
 
   int operator[]=(int index, int value) {
     _setIndexed(index, _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     if (from is _ExternalUint64Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 26 matching lines @@
   }
 
   int operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> get iterator {
     return new _ByteArrayIterator<double>(this);
   }
 
-  List<double> getRange(int start, int length) {
+  List<double> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<double> result = new Float32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<double> getRange(int start, int length) =>
+      sublist(start, start + length);
+
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _ExternalFloat32Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 26 matching lines @@
   }
 
   int operator[]=(int index, double value) {
     _setIndexed(index, value);
   }
 
   Iterator<double> get iterator {
     return new _ByteArrayIterator<double>(this);
   }
 
-  List<double> getRange(int start, int length) {
+  List<double> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<double> result = new Float64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<double> getRange(int start, int length) =>
+      sublist(start, start + length);
+
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     if (from is _ExternalFloat64Array) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       IterableMixinWorkaround.setRangeList(
           this, start, length, from, startFrom);
     }
@@ skipping 302 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint16List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Int64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       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> get iterator {
     return new _ByteArrayIterator<int>(this);
   }
 
-  List<int> getRange(int start, int length) {
+  List<int> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<int> result = new Uint64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<int> getRange(int start, int length) => sublist(start, start + length);
+
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _array.setFloat32(_offset + (index * _BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _ByteArrayIterator<double>(this);
   }
 
-  List<double> getRange(int start, int length) {
+  List<double> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<double> result = new Float32List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<double> getRange(int start, int length) =>
+      sublist(start, start + length);
+
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
@@ skipping 37 matching lines @@
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
     _array.setFloat64(_offset + (index * _BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _ByteArrayIterator<double>(this);
   }
 
-  List<double> getRange(int start, int length) {
+  List<double> sublist(int start, [int end]) {
+    if (end == null) end = this.length;
+    int length = end - start;
     _rangeCheck(this.length, start, length);
     List<double> result = new Float64List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
+  List<double> getRange(int start, int length) =>
+      sublist(start, start + length);
+
   void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
     IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
   }
 
   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(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
 }