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

sdk/lib/core/list.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.
 
 part of dart.core;
 
 /**
- * A [List] is an indexable collection with a length. It can be of
- * fixed size or extendable.
+ * A [List] is an indexable collection with a length.
+ *
+ * A `List` implementation can be choose not to support all methods
+ * of the `List` interface.
+ *
+ * The most common list types are:
+ * * Fixed length list. It is an error to use operations that can change
+ *   the list's length.
+ * * Growable list. Full implementation of the interface.
+ * * Unmodifiable list. It is an error to use operations that can change
+ *   the list's length, or that can change the values of the list.
+ *   If an unmodifable list is backed by another modifiable data structure,
+ *   the values read from it may still change over time.
+ *
+ * Example:
+ *
+ *    var fixedLengthList = new List(5);
+ *    fixedLengthList.length = 0;  // throws.
+ *    fixedLengthList.add(499);  // throws
+ *    fixedLengthList[0] = 87;
+ *    var growableList = [1, 2];
+ *    growableList.length = 0;
+ *    growableList.add(499);
+ *    growableList[0] = 87;
+ *    var unmodifiableList = const [1, 2];
+ *    unmodifiableList.length = 0;  // throws.
+ *    unmodifiableList.add(499);  // throws
+ *    unmodifiableList[0] = 87;  // throws.
  */
 abstract class List<E> implements Collection<E> {
   /**
    * Creates a list of the given [length].
    *
-   * The length of the returned list is not fixed.
+   * The list is a fixed-length list if [length] is provided, and an empty
+   * growable list if [length] is omitted.

[ngeoffray, 2013/02/27 08:59:12]

Shouldn't you say is omitted or null?

[floitsch, 2013/02/27 10:04:58]

No. null is an error.

[ngeoffray, 2013/02/27 12:02:32]

Maybe add that too in a comment?

    */
-  external factory List([int length = 0]);
+  external factory List([int length]);
 
   /**
-   * Creates a fixed-sized list of the given [length] where each entry is
-   * filled with [fill].
+   * Creates a fixed-length list of the given [length] where each entry
+   * contains [fill].
    */
-  external factory List.fixedLength(int length, {E fill: null});
+  external factory List.filled(int length, E fill);
+
+  /**
+   * *Deprecated*: Use `new List(count)` instead.
+   */
+  factory List.fixedLength(int count) => new List(count);
 
   /**
    * Creates an list with the elements of [other]. The order in
    * the list will be the order provided by the iterator of [other].
    *
    * The length of the returned list is not fixed.
    */
-  factory List.from(Iterable other) {
-    var list = new List<E>();
+  factory List.from(Iterable other, { bool growable: true }) {
+    List<E> list = new List<E>();
     for (E e in other) {
       list.add(e);
     }
-    return list;
+    if (growable) return list;
+    int length = list.length;
+    List<E> fixedList = new List<E>(length);
+    for (int i = 0; i < length; i++) {
+      fixedList[i] = list[i];
+    }
+    return fixedList;
   }
 
   /**
+   * Generate a `List` of elements.
+   *
+   * Generates a list of values, where the values are created by
+   * calling the [generator] function for each index in the range
+   * 0 .. [length] - 1.
+   *
+   * The created length's length is fixed unless [growable] is true.
+   */
+  factory List.generate(int length, E generator(int index),
+                       { bool growable: false }) {
+    List<E> result;
+    if (growable) {
+      result = <E>[]..length = length;
+    } else {
+      result = new List<E>(length);
+    }
+    for (int i = 0; i < length; i++) {
+      result[i] = generator(i);
+    }
+    return result;
+  }
+
+  /**
    * Returns the element at the given [index] in the list or throws
    * an [RangeError] if [index] is out of bounds.
    */
   E operator [](int index);
 
   /**
    * Sets the entry at the given [index] in the list to [value].
    * Throws an [RangeError] if [index] is out of bounds.
    */
   void operator []=(int index, E value);
@@ skipping 130 matching lines @@
    * not extendable.
    * If [length] is 0, this method does not do anything.
    * If [start] is the length of the list, this method inserts the
    * range at the end of the list.
    * Throws an [ArgumentError] if [length] is negative.
    * Throws an [RangeError] if [start] is negative or if
    * [start] is greater than the length of the list.
    */
   void insertRange(int start, int length, [E fill]);
 }