Redo "special-case ListMixin.setRange from same list"

sdk/lib/collection/list.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.
 
 part of dart.collection;
 
 /**
  * Abstract implementation of a list.
  *
  * `ListBase` can be used as a base class for implementing the `List` interface.
@@ skipping 238 matching lines @@
       assert(this.length == i || (throw new ConcurrentModificationError(this)));
       this.length = i + 1;
       this[i] = element;
       i++;
     }
   }
 
   bool remove(Object element) {
     for (int i = 0; i < this.length; i++) {
       if (this[i] == element) {
-        this.setRange(i, this.length - 1, this, i + 1);
-        this.length -= 1;
+        this._closeGap(i, i + 1);
         return true;
       }
     }
     return false;
   }
 
+  /// Removes elements from the list starting at [start] up to but not including
+  /// [end].  Arguments are pre-validated.
+  void _closeGap(int start, int end) {
+    int length = this.length;
+    assert(0 <= start);
+    assert(start < end);
+    assert(end <= length);
+    int size = end - start;
+    for (int i = end; i < length; i++) {
+      this[i - size] = this[i];
+    }
+    this.length = length - size;
+  }
+
   void removeWhere(bool test(E element)) {
     _filter(test, false);
   }
 
   void retainWhere(bool test(E element)) {
     _filter(test, true);
   }
 
   void _filter(bool test(var element), bool retainMatching) {
     List<E> retained = <E>[];
@@ skipping 66 matching lines @@
     return result;
   }
 
   Iterable<E> getRange(int start, int end) {
     RangeError.checkValidRange(start, end, this.length);
     return new SubListIterable<E>(this, start, end);
   }
 
   void removeRange(int start, int end) {
     RangeError.checkValidRange(start, end, this.length);
-    int length = end - start;
-    setRange(start, this.length - length, this, end);
-    this.length -= length;
+    if (end > start) {
+      _closeGap(start, end);
+    }
   }
 
   void fillRange(int start, int end, [E fill]) {
     RangeError.checkValidRange(start, end, this.length);
     for (int i = start; i < end; i++) {
       this[i] = fill;
     }
   }
 
   void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
@@ skipping 28 matching lines @@
   }
 
   void replaceRange(int start, int end, Iterable<E> newContents) {
     RangeError.checkValidRange(start, end, this.length);
     if (newContents is! EfficientLengthIterable) {
       newContents = newContents.toList();
     }
     int removeLength = end - start;
     int insertLength = newContents.length;
     if (removeLength >= insertLength) {
-      int delta = removeLength - insertLength;
       int insertEnd = start + insertLength;
-      int newLength = this.length - delta;
       this.setRange(start, insertEnd, newContents);
-      if (delta != 0) {
-        this.setRange(insertEnd, newLength, this, end);
-        this.length = newLength;
+      if (removeLength > insertLength) {
+        _closeGap(insertEnd, end);
       }
     } else {
       int delta = insertLength - removeLength;
       int newLength = this.length + delta;
       int insertEnd = start + insertLength; // aka. end + delta.
       this.length = newLength;
       this.setRange(insertEnd, newLength, this, end);
       this.setRange(start, insertEnd, newContents);
     }
   }
@@ skipping 42 matching lines @@
     // Array.copy could throw an exception, leaving the list in a bad state
     // (with a length that has been increased, but without a new element).
     if (index is! int) throw new ArgumentError(index);
     this.length++;
     setRange(index + 1, this.length, this, index);
     this[index] = element;
   }
 
   E removeAt(int index) {
     E result = this[index];
-    setRange(index, this.length - 1, this, index + 1);
-    length--;
+    _closeGap(index, index + 1);
     return result;
   }
 
   void insertAll(int index, Iterable<E> iterable) {
     RangeError.checkValueInInterval(index, 0, length, "index");
     if (iterable is! EfficientLengthIterable || identical(iterable, this)) {
       iterable = iterable.toList();
     }
     int insertionLength = iterable.length;
     // There might be errors after the length change, in which case the list
@@ skipping 17 matching lines @@
       for (E element in iterable) {
         this[index++] = element;
       }
     }
   }
 
   Iterable<E> get reversed => new ReversedListIterable<E>(this);
 
   String toString() => IterableBase.iterableToFullString(this, '[', ']');
 }