Update number parsing.

tool/input_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;
 
 /**
  * An indexable collection of objects with a length.
  *
  * Subclasses of this class implement different kinds of lists.
@@ skipping 33 matching lines @@
  * temporarily and is restored before continuing the iteration, the iterator
  * does not detect it.
  *
  * It is generally not allowed to modify the list's length (adding or removing
  * elements) while an operation on the list is being performed,
  * for example during a call to [forEach] or [sort].
  * Changing the list's length while it is being iterated, either by iterating it
  * directly or through iterating an [Iterable] that is backed by the list, will
  * break the iteration.
  */
-abstract class List<E> implements Iterable<E> {
+abstract class List<E> implements Iterable<E>, EfficientLength {
   /**
    * Creates a list of the given length.
    *
    * The created list is fixed-length if [length] is provided.
    *
    *     List fixedLengthList = new List(3);
    *     fixedLengthList.length;     // 3
    *     fixedLengthList.length = 1; // Error
    *
    * The list has length 0 and is growable if [length] is omitted.
@@ skipping 10 matching lines @@
    * The [length] must not be negative or null, if it is provided.
    */
   external factory List([int length]);
 
   /**
    * Creates a fixed-length list of the given length, and initializes the
    * value at each position with [fill]:
    *
    *     new List<int>.filled(3, 0); // [0, 0, 0]
    *
-   * The [length] must not be negative or null.
+   * The [length] must be a non-negative integer.
+   *
+   * If the list is growable, changing its length will not initialize new
+   * entries with [fill]. After being created and filled, the list is
+   * no different from any other growable or fixed-length list
+   * created using [List].
    */
-  external factory List.filled(int length, E fill);
+  external factory List.filled(int length, E fill, {bool growable: false});
 
   /**
    * Creates a list containing all [elements].
    *
    * The [Iterator] of [elements] provides the order of the elements.
    *
    * This constructor returns a growable list when [growable] is true;
    * otherwise, it returns a fixed-length list.
    */
   external factory List.from(Iterable elements, { bool growable: true });
@@ skipping 81 matching lines @@
 
   /**
    * Returns an [Iterable] of the objects in this list in reverse order.
    */
   Iterable<E> get reversed;
 
   /**
    * Sorts this list according to the order specified by the [compare] function.
    *
    * The [compare] function must act as a [Comparator].
-   *     List<String> numbers = ['one', 'two', 'three', 'four'];
+   *
+   *     List<String> numbers = ['two', 'three', 'four'];
    *     // Sort from shortest to longest.
-   *     numbers.sort((x, y) => x.length.compareTo(y.length));
-   *     numbers.join(', '); // 'one, two, four, three'
+   *     numbers.sort((a, b) => a.length.compareTo(b.length));
+   *     print(numbers);  // [two, four, three]
    *
    * The default List implementations use [Comparable.compare] if
    * [compare] is omitted.
    *
    *     List<int> nums = [13, 2, -11];
    *     nums.sort();
-      nums.join(', '); // '-11, 2, 13'
+   *     print(nums);  // [-11, 2, 13]
+   *
+   * A [Comparator] may compare objects as equal (return zero), even if they
+   * are distinct objects.
+   * The sort function is not guaranteed to be stable, so distinct objects
+   * that compare as equal may occur in any order in the result:
+   *
+   *     List<String> numbers = ['one', 'two', 'three', 'four'];
+   *     numbers.sort((a, b) => a.length.compareTo(b.length));
+   *     print(numbers);  // [one, two, four, three] OR [two, one, four, three]
    */
   void sort([int compare(E a, E b)]);
 
   /**
    * Shuffles the elements of this list randomly.
    */
   void shuffle([Random random]);
 
   /**
    * Returns the first index of [element] in this list.
@@ skipping 255 matching lines @@
    * as values. The `Map.keys` [Iterable] iterates the indices of this list
    * in numerical order.
    *
    *     List<String> words = ['fee', 'fi', 'fo', 'fum'];
    *     Map<int, String> map = words.asMap();
    *     map[0] + map[1];   // 'feefi';
    *     map.keys.toList(); // [0, 1, 2, 3]
    */
   Map<int, E> asMap();
 }