- Rename arrays to lists:

runtime/lib/array.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.
 
 
 // TODO(srdjan): Use shared array implementation.
-class _ObjectArray<E> implements List<E> {
-  static final int _classId = (new _ObjectArray(0))._cid;
+class _List<E> implements List<E> {
+  static final int _classId = (new _List(0))._cid;
 
-  factory _ObjectArray(length) native "ObjectArray_allocate";
+  factory _List(length) native "List_allocate";
 
-  E operator [](int index) native "ObjectArray_getIndexed";
+  E operator [](int index) native "List_getIndexed";
 
-  void operator []=(int index, E value) native "ObjectArray_setIndexed";
+  void operator []=(int index, E value) native "List_setIndexed";
 
   String toString() {
     return IterableMixinWorkaround.toStringIterable(this,'[' , ']');
   }
 
-  int get length native "ObjectArray_getLength";
+  int get length native "List_getLength";
 
-  void _copyFromObjectArray(_ObjectArray src,
+  void _copyFromObjectArray(_List src,
                             int srcStart,
                             int dstStart,
                             int count)
-      native "ObjectArray_copyFromObjectArray";
+      native "List_copyFromObjectArray";
 
   void insert(int index, E element) {
     throw new UnsupportedError(
         "Cannot add to a non-extendable array");
   }
 
   void insertAll(int index, Iterable<E> iterable) {
     throw new UnsupportedError(
         "Cannot add to a non-extendable array");
   }
@@ skipping 30 matching lines @@
   void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
     if (start < 0 || start > this.length) {
       throw new RangeError.range(start, 0, this.length);
     }
     if (end < start || end > this.length) {
       throw new RangeError.range(end, start, this.length);
     }
     int length = end - start;
     if (length == 0) return;
 
-    if (iterable is _ObjectArray) {
+    if (iterable is _List) {
       _copyFromObjectArray(iterable, skipCount, start, length);
     } else {
       List otherList;
       int otherStart;
       if (iterable is List) {
         otherList = iterable;
         otherStart = skipCount;
       } else {
         otherList =
             iterable.skip(skipCount).take(length).toList(growable: false);
@@ skipping 15 matching lines @@
 
   void fillRange(int start, int end, [E fillValue]) {
     IterableMixinWorkaround.fillRangeList(this, start, end, fillValue);
   }
 
   List<E> sublist(int start, [int end]) {
     Arrays.indicesCheck(this, start, end);
     if (end == null) end = this.length;
     int length = end - start;
     if (start == end) return [];
-    List list = new _GrowableObjectArray<E>.withCapacity(length);
+    List list = new _GrowableList<E>.withCapacity(length);
     list.length = length;
     Arrays.copy(this, start, list, 0, length);
     return list;
   }
 
   // Iterable interface.
 
   bool contains(Object element) {
     return IterableMixinWorkaround.contains(this, element);
   }
@@ skipping 139 matching lines @@
   Set<E> toSet() {
     return new Set<E>.from(this);
   }
 
   Map<int, E> asMap() {
     return IterableMixinWorkaround.asMapList(this);
   }
 }
 
 
-// This is essentially the same class as _ObjectArray, but it does not
+// This is essentially the same class as _List, but it does not
 // permit any modification of array elements from Dart code. We use
 // this class for arrays constructed from Dart array literals.
 // TODO(hausner): We should consider the trade-offs between two
 // classes (and inline cache misses) versus a field in the native
 // implementation (checks when modifying). We should keep watching
 // the inline cache misses.
-class _ImmutableArray<E> implements List<E> {
+class _ImmutableList<E> implements List<E> {
   static final int _classId = (const [])._cid;
 
-  factory _ImmutableArray._uninstantiable() {
+  factory _ImmutableList._uninstantiable() {
     throw new UnsupportedError(
         "ImmutableArray can only be allocated by the VM");
   }
 
-  E operator [](int index) native "ObjectArray_getIndexed";
+  E operator [](int index) native "List_getIndexed";
 
   void operator []=(int index, E value) {
     throw new UnsupportedError(
         "Cannot modify an immutable array");
   }
 
-  int get length native "ObjectArray_getLength";
+  int get length native "List_getLength";
 
   void insert(int index, E element) {
     throw new UnsupportedError(
         "Cannot add to an immutable array");
   }
 
   void insertAll(int index, Iterable<E> iterable) {
     throw new UnsupportedError(
         "Cannot add to an immutable array");
   }
@@ skipping 224 matching lines @@
 
 // Iterator for arrays with fixed size.
 class _FixedSizeArrayIterator<E> implements Iterator<E> {
   final List<E> _array;
   final int _length;  // Cache array length for faster access.
   int _position;
   E _current;
 
   _FixedSizeArrayIterator(List array)
       : _array = array, _length = array.length, _position = -1 {
-    assert(array is _ObjectArray || array is _ImmutableArray);
+    assert(array is _List || array is _ImmutableList);
   }
 
   bool moveNext() {
     int nextPosition = _position + 1;
     if (nextPosition < _length) {
       _current = _array[nextPosition];
       _position = nextPosition;
       return true;
     }
     _position = _length;
     _current = null;
     return false;
   }
 
   E get current {
     return _current;
   }
 }