Refactor List.setRange function.

sdk/lib/collection/queue.dart

 // Copyright (c) 2011, 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;
 
 /**
  * A [Queue] is a collection that can be manipulated at both ends. One
  * can iterate over the elements of a queue through [forEach] or with
  * an [Iterator].
@@ skipping 440 matching lines @@
   }
 
   void addAll(Iterable<E> elements) {
     if (elements is List) {
       List list = elements;
       int addCount = list.length;
       int length = this.length;
       if (length + addCount >= _table.length) {
         _preGrow(length + addCount);
         // After preGrow, all elements are at the start of the list.
-        _table.setRange(length, addCount, list, 0);
+        _table.setRange(length, length + addCount, list, 0);
         _tail += addCount;
       } else {
         // Adding addCount elements won't reach _head.
         int endSpace = _table.length - _tail;
         if (addCount < endSpace) {
-          _table.setRange(_tail, addCount, list, 0);
+          _table.setRange(_tail, _tail + addCount, list, 0);
           _tail += addCount;
         } else {
           int preSpace = addCount - endSpace;
-          _table.setRange(_tail, endSpace, list, 0);
+          _table.setRange(_tail, _tail + endSpace, list, 0);
           _table.setRange(0, preSpace, list, endSpace);
           _tail = preSpace;
         }
       }
       _modificationCount++;
     } else {
       for (E element in elements) _add(element);
     }
   }
 
@@ skipping 164 matching lines @@
     }
   }
 
   /**
    * Grow the table when full.
    */
   void _grow() {
     List<E> newTable = new List<E>(_table.length * 2);
     int split = _table.length - _head;
     newTable.setRange(0, split, _table, _head);
-    newTable.setRange(split, _head, _table, 0);
+    newTable.setRange(split, split + _head, _table, 0);
     _head = 0;
     _tail = _table.length;
     _table = newTable;
   }
 
   int _writeToList(List<E> target) {
     assert(target.length >= length);
     if (_head <= _tail) {
       int length = _tail - _head;
       target.setRange(0, length, _table, _head);
       return length;
     } else {
       int firstPartSize = _table.length - _head;
       target.setRange(0, firstPartSize, _table, _head);
-      target.setRange(firstPartSize, _tail, _table, 0);
+      target.setRange(firstPartSize, firstPartSize + _tail, _table, 0);
       return _tail + firstPartSize;
     }
   }
 
   /** Grows the table even if it is not full. */
   void _preGrow(int newElementCount) {
     assert(newElementCount >= length);
     int newCapacity = _nextPowerOf2(newElementCount);
     List<E> newTable = new List<E>(newCapacity);
     _tail = _writeToList(newTable);
@@ skipping 26 matching lines @@
     _queue._checkModification(_modificationCount);
     if (_position == _end) {
       _current = null;
       return false;
     }
     _current = _queue._table[_position];
     _position = (_position + 1) & (_queue._table.length - 1);
     return true;
   }
 }