Moving ListBase, FixedLengthListMixin and UmodifiableListMixin to collection.

sdk/lib/_collection_dev/list.dart

 // Copyright (c) 2013, 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.dev;
 
 /**
  * Base implementation of a [List] class.
  *
  * This class can be used as a mixin.
@@ skipping 601 matching lines @@
     throw new UnsupportedError(
         "Cannot remove from an unmodifiable list");
   }
 
   void insertRange(int start, int length, [E initialValue]) {
     throw new UnsupportedError(
         "Cannot insert range in an unmodifiable list");
   }
 }
 
-
-/**
- * Abstract implementation of a list.
- *
- * All operations are defined in terms of `length`, `operator[]`,
- * `operator[]=` and `length=`, which need to be implemented.
- */
-abstract class ListBase<E> extends ListMixin<E> implements List<E> {}
-
-/**
- * Abstract implementation of a fixed-length list.
- *
- * All operations are defined in terms of `length`, `operator[]` and
- * `operator[]=`, which need to be implemented.
- */
-abstract class FixedLengthListBase<E> extends ListBase<E>
-                                      with FixedLengthListMixin<E> {}
-
-/**
- * Abstract implementation of an unmodifiable list.
- *
- * All operations are defined in terms of `length` and `operator[]`,
- * which need to be implemented.
- */
-abstract class UnmodifiableListBase<E> extends ListBase<E>
-                                       with UnmodifiableListMixin<E> {}
-
-/** An empty fixed-length (and therefore unmodifiable) list. */
-class EmptyList<E> extends FixedLengthListBase<E> {
-  int get length => 0;
-  E operator[](int index) { throw new RangeError.value(index); }
-  void operator []=(int index, E value) { throw new RangeError.value(index); }
-  Iterable<E> skip(int count) => const EmptyIterable();
-  Iterable<E> take(int count) => const EmptyIterable();
-  Iterable<E> get reversed => const EmptyIterable();
-  void sort([int compare(E a, E b)]) {}
-}
-
 class ReversedListIterable<E> extends ListIterable<E> {
   Iterable<E> _source;
   ReversedListIterable(this._source);
 
   int get length => _source.length;
 
   E elementAt(int index) => _source.elementAt(_source.length - 1 - index);
 }
 
 /**
  * An [Iterable] of the UTF-16 code units of a [String] in index order.
  */
-class CodeUnits extends UnmodifiableListBase<int> {
+class CodeUnits extends ListMixin<int> with UnmodifiableListMixin<int> {
   /** The string that this is the code units of. */
   String _string;
 
   CodeUnits(this._string);
 
   int get length => _string.length;
   int operator[](int i) => _string.codeUnitAt(i);
 }
 
 class _ListIndicesIterable extends ListIterable<int> {
@@ skipping 44 matching lines @@
   }
 
   E remove(int key) {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 }