Don't always call _copyFromObjectArray.

runtime/lib/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.
 
 
 // TODO(srdjan): Use shared array implementation.
 class _List<E> implements List<E> {
 
   factory _List(length) native "List_allocate";
 
@@ skipping 48 matching lines @@
   // List interface.
   void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
     if (start < 0 || start > this.length) {
       throw new RangeError.range(start, 0, this.length);
     }
     if (end < start || end > this.length) {
       throw new RangeError.range(end, start, this.length);
     }
     int length = end - start;
     if (length == 0) return;
-
-    if (ClassID.getID(iterable) == ClassID.cidOneByteString) {
+    if (identical(this, iterable)) {
+      Lists.copy(iterable, skipcount, this, start, length);
+    } else if (ClassID.getID(iterable) == ClassID.cidArray && length > 128) {

[srdjan, 2014/09/02 18:33:58]

Please add parentheses.

       _copyFromObjectArray(iterable, skipCount, start, length);

[Lasse Reichstein Nielsen, 2014/09/02 14:29:09]

Good thing this wasn't called before due to the incorrect ClassID - it could do
the wrong thing if called with itself.

Currently, I'm not sure this call ever pays for itself, I'll have to check it
again when _copyFromObjectArray has been optimized.

+    } else if (iterable is List) {
+      Lists.copy(iterable, skipCount, this, start, length);
     } else {
-      if (iterable is List) {
-        Lists.copy(iterable, skipCount, this, start, length);
-      } else {
-        Iterator it = iterable.iterator;
-        while (skipCount > 0) {
-          if (!it.moveNext()) return;
-          skipCount--;
-        }
-        for (int i = start; i < end; i++) {
-          if (!it.moveNext()) return;
-          this[i] = it.current;
-        }
+      Iterator it = iterable.iterator;
+      while (skipCount > 0) {
+        if (!it.moveNext()) return;
+        skipCount--;
+      }
+      for (int i = start; i < end; i++) {
+        if (!it.moveNext()) return;
+        this[i] = it.current;
       }
     }
   }
 
   void removeRange(int start, int end) {
     throw NonGrowableListError.remove();
   }
 
   void replaceRange(int start, int end, Iterable<E> iterable) {
     throw NonGrowableListError.remove();
   }
 
   void fillRange(int start, int end, [E fillValue]) {
     IterableMixinWorkaround.fillRangeList(this, start, end, fillValue);
   }
 
   List<E> sublist(int start, [int end]) {
     Lists.indicesCheck(this, start, end);
     if (end == null) end = this.length;
     int length = end - start;
     if (start == end) return <E>[];
     List list = new _List(length);
-    list._copyFromObjectArray(this, start, 0, length);
+    if (length < 128) {

[Vyacheslav Egorov (Google), 2014/09/02 14:31:15]

I don't like that this is repeated. 

Can we have a _copyArray() somewhere that does

if (length < ...) {
  // ... do this ...
} else {
  list._copyFromObjectArray(...)
}

?

This will open possibilities for uniform optimizations instead of searching for
other places that use it...

+      for (int i = 0; i < length; i++) {
+        list[i] = this[start + i];
+      }
+    } else {
+      list._copyFromObjectArray(this, start, 0, length);
+    }
     var result = new _GrowableList<E>.withData(list);
     result._setLength(length);
     return result;
   }
 
   // Iterable interface.
 
   bool contains(Object element) {
     return IterableMixinWorkaround.contains(this, element);
   }
@@ skipping 132 matching lines @@
   E get single {
     if (length == 1) return this[0];
     if (length == 0) throw IterableElementError.noElement();
     throw IterableElementError.tooMany();
   }
 
   List<E> toList({ bool growable: true }) {
     var length = this.length;
     if (length > 0) {
       var result = growable ? new _List(length) : new _List<E>(length);
-      result._copyFromObjectArray(this, 0, 0, length);
+      if (length < 128) {
+        for (int i = 0; i < length; i++) {
+          result[i] = this[i];
+        }
+      } else {
+        result._copyFromObjectArray(this, 0, 0, length);
+      }
       if (growable) {
         result = new _GrowableList<E>.withData(result);
         result._setLength(length);
       }
       return result;
     }
     // _GrowableList.withData must not be called with empty list.
     return growable ? <E>[] : new List<E>(0);
   }
 
@@ skipping 287 matching lines @@
   bool moveNext() {
     if (_index >= _length) {
       _current = null;
       return false;
     }
     _current = _array[_index];
     _index++;
     return true;
   }
 }