- Rename arrays to lists:

runtime/lib/string_patch.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.
 
 patch class String {
   /* patch */ factory String.fromCharCodes(Iterable<int> charCodes) {
     return _StringBase.createFromCharCodes(charCodes);
   }
 }
 
@@ skipping 12 matching lines @@
   int get hashCode native "String_getHashCode";
 
   /**
    *  Create the most efficient string representation for specified
    *  [codePoints].
    */
   static String createFromCharCodes(Iterable<int> charCodes) {
     if (charCodes != null) {
       // TODO(srdjan): Also skip copying of typed arrays.
       final ccid = charCodes._cid;
-      if ((ccid != _ObjectArray._classId) &&
-          (ccid != _GrowableObjectArray._classId) &&
-          (ccid != _ImmutableArray._classId)) {
+      if ((ccid != _List._classId) &&
+          (ccid != _GrowableList._classId) &&
+          (ccid != _ImmutableList._classId)) {
         charCodes = new List<int>.from(charCodes, growable: false);
       }
 
       bool isOneByteString = true;
       for (int i = 0; i < charCodes.length; i++) {
         int e = charCodes[i];
         if (e is! _Smi) throw new ArgumentError(e);
         // Is e Latin1?
         if ((e < 0) || (e > 0xFF)) {
           isOneByteString = false;
@@ skipping 344 matching lines @@
     return buffer.toString();
   }
 
 
   /**
    * Convert all objects in [values] to strings and concat them
    * into a result string.
    */
   static String _interpolate(List<String> values) {
     final int numValues = values.length;
-    _ObjectArray stringList = new List<String>(numValues);
+    _List stringList = new List<String>(numValues);
     bool isOneByteString = true;
     int totalLength = 0;
     for (int i = 0; i < numValues; i++) {
       var s = values[i].toString();
       if (isOneByteString && (s._cid == _OneByteString._classId)) {
         totalLength += s.length;
       } else {
         isOneByteString = false;
         if (s is! String) {
           throw new ArgumentError(s);
@@ skipping 83 matching lines @@
 
   List<int> get codeUnits => new _CodeUnits(this);
 
   Runes get runes => new Runes(this);
 
   String toUpperCase() native "String_toUpperCase";
 
   String toLowerCase() native "String_toLowerCase";
 
   // Call this method if not all list elements are known to be OneByteString(s).
-  // 'strings' must be an _ObjectArray or _GrowableObjectArray.
+  // 'strings' must be an _List or _GrowableList.
   static String _concatAllNative(List<String> strings, int start, int end)
       native "Strings_concatAll";
 }
 
 
 class _OneByteString extends _StringBase implements String {
   static final int _classId = "A"._cid;
 
   factory _OneByteString._uninstantiable() {
     throw new UnsupportedError(
@@ skipping 13 matching lines @@
       native "OneByteString_splitWithCharCode";
 
   List<String> split(Pattern pattern) {
     if ((pattern._cid == _OneByteString._classId) && (pattern.length == 1)) {
       return _splitWithCharCode(pattern.codeUnitAt(0));
     }
     return super.split(pattern);
   }
 
   // All element of 'strings' must be OneByteStrings.
-  static _concatAll(_ObjectArray<String> strings, int totalLength) {
+  static _concatAll(_List<String> strings, int totalLength) {
     // TODO(srdjan): Improve code below and raise or eliminate the limit.
     if (totalLength > 128) {
       // Native is quicker.
       return _StringBase._concatAllNative(strings, 0, strings.length);
     }
     var res = _OneByteString._allocate(totalLength);
     final stringsLength = strings.length;
     int rIx = 0;
     for (int i = 0; i < stringsLength; i++) {
       _OneByteString e = strings[i];
@@ skipping 89 matching lines @@
 class _CodeUnits extends Object with ListMixin<int>,
                                      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);
 }