Change new List(n) to return fixed length list.

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 332 matching lines @@
    * If [initialCapacity] is given, prepare the queue for at least that many
    * elements.
    */
   ListQueue([int initialCapacity]) : _head = 0, _tail = 0 {
     if (initialCapacity == null || initialCapacity < _INITIAL_CAPACITY) {
       initialCapacity = _INITIAL_CAPACITY;
     } else if (!_isPowerOf2(initialCapacity)) {
       initialCapacity = _nextPowerOf2(initialCapacity);
     }
     assert(_isPowerOf2(initialCapacity));
-    _table = new List<E>.fixedLength(initialCapacity);
+    _table = new List<E>(initialCapacity);
   }
 
   /**
    * Create a queue initially containing the elements of [source].
    */
   factory ListQueue.from(Iterable<E> source) {
     if (source is List) {
       int length = source.length;
       ListQueue<E> queue = new ListQueue(length + 1);
       assert(queue._table.length > length);
@@ skipping 38 matching lines @@
     return _table[_head];
   }
 
   E elementAt(int index) {
     if (index < 0 || index > length) {
       throw new RangeError.range(index, 0, length);
     }
     return _table[(_head + index) & (_table.length - 1)];
   }
 
-  List<E> toList() {
-    List<E> list = new List<E>(length);
+  List<E> toList({ bool growable: false }) {
+    List<E> list;
+    if (growable) {
+      list = new List<E>()..length = length;
+    } else {
+      list = new List<E>(length);
+    }
     _writeToList(list);
     return list;
   }
 
   // Collection interface.
 
   void add(E element) {
     _add(element);
   }
 
@@ skipping 198 matching lines @@
       }
       _table[_tail] = null;
       return offset;
     }
   }
 
   /**
    * Grow the table when full.
    */
   void _grow() {
-    List<E> newTable = new List<E>.fixedLength(_table.length * 2);
+    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);
     _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);
       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>.fixedLength(newCapacity);
+    List<E> newTable = new List<E>(newCapacity);
     _tail = _writeToList(newTable);
     _table = newTable;
     _head = 0;
   }
 }
 
 /**
  * Iterator for a [ListQueue].
  *
  * Considers any add or remove operation a concurrent modification.
@@ skipping 17 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;
   }
 }