anchor.diff:    void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]);
   
     /**
  -   * Removes the elements in the range [start] to [end] exclusive.
  -   *
  -   * It is an error if [start]..[end] is not a valid range pointing into the
  -   * `this`.
  +   * Removes the objects in the range [start] inclusive to [end] exclusive.
  +   *
  +   * An error occurs if [start]..[end] is not a valid range for `this`.
  +   * Throws an [UnsupportedError] if this is a fixed-length list.
      */
     void removeRange(int start, int end);
   
     /**
  -   * Sets the elements in the range [start] to [end] exclusive to the given
  -   * [fillValue].
  -   *
  -   * It is an error if [start]..[end] is not a valid range pointing into the
  -   * `this`.
  +   * Sets the objects in the range [start] inclusive to [end] exclusive
  +   * to the given [fillValue].
  +   *
  +   * An error occurs if [start]..[end] is not a valid range for `this`.
      */
     void fillRange(int start, int end, [E fillValue]);
   
     /**
  -   * Removes the elements in the range [start] to [end] exclusive and replaces
  -   * them with the contents of the [iterable].
  -   *
  -   * It is an error if [start]..[end] is not a valid range pointing into the
  -   * `this`.
  +   * Removes the objects in the range [start] inclusive to [end] exclusive
  +   * and replaces them with the contents of the [iterable].
  +   *
  +   * An error occurs if [start]..[end] is not a valid range for `this`.
      *
      * Example:
      *
  
positive.code:   }
  
    /**
     * Generate a `List` of values.
     *
     * Creates a list with [length] positions
     * and fills them by values created by calling [generator]
     * for each index in the range `0` .. `[length] - 1`
     * in increasing order.
     *
     * The created list's length is fixed unless [growable] is true.
     */
    factory List.generate(int length, E generator(int index),
                         { bool growable: true }) {
  
negative.code: part of dart.core;
  
  /**
   * An indexable collection of objects with a length.
   *
   * Subclasses of this class implement different kinds of lists.
   * The most common kinds of lists are:
   *
   * * Fixed-length list.
   *   An error occurs when attempting to use operations
   *   that can change the length of the list.
   *
   * * Growable list. Full implementation of the API defined in this class.
   *
   * The following code illustrates that some List implementations support
   * only a subset of the API.
   *
   *     var fixedLengthList = new List(5);
   *     fixedLengthList.length = 0;  // Error.
   *     fixedLengthList.add(499);    // Error.
   *     fixedLengthList[0] = 87;
   *
   *     var growableList = [1, 2];
   *     growableList.length = 0;
   *     growableList.add(499);
   *     growableList[0] = 87;
   *
   * Lists are [Iterable].
   * Iteration occurs over values in index order.
   * Changing the values does not affect iteration,
   * but changing the valid indices&mdash;that is,
   * changing the list's length&mdash;between
   * iteration steps
   * causes a [ConcurrentModificationError].
   * This means that only growable lists can throw ConcurrentModificationError.
   * If the length changes temporarily
   * and is restored before continuing the iteration,
   * the iterator does not detect it.
   */
  abstract class List<E> implements Iterable<E> {
    /**
     * Creates a list of the given _length_.
     *
     * The created list is fixed-length if _length_ is provided.
     * The list has length 0 and is growable if _length_ is omitted.
     *
     * An error occurs if _length_ is negative.
     */
    external factory List([int length]);
  
    /**
     * Creates a fixed-length list of the given _length_
     * and initializes the value at each position with [fill].
     */
    external factory List.filled(int length, E fill);
  
    /**
     * Creates a list and initializes it using the contents of [other].
     *
     * The [Iterator] of [other] provides the order of the objects.
     *
     * This constructor returns a growable list if [growable] is true;
     * otherwise, it returns a fixed-length list.
     */
    factory List.from(Iterable other, { bool growable: true }) {
      List<E> list = new List<E>();
  