Clean up (most) uses of Array. Still more to come in the VM corelib code base.

runtime/lib/string.dart

 // Copyright (c) 2011, 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.
 
 /**
  * [StringBase] contains common methods used by concrete String implementations,
  * e.g., OneByteString.
  */
 class StringBase {
 
   int hashCode() native "String_hashCode";
 
   /**
    *  Create the most efficient string representation for specified
    *  [codePoints].
    */
   static String createFromCharCodes(List<int> charCodes) {
     ObjectArray objectArray;
     if (charCodes is ObjectArray) {
       objectArray = charCodes;
     } else {
       int len = charCodes.length;
-      objectArray = new Array(len);
+      objectArray = new ObjectArray(len);
       for (int i = 0; i < len; i++) {
         objectArray[i] = charCodes[i];
       }
     }
     return _createFromCodePoints(objectArray);
   }
 
   static String _createFromCodePoints(ObjectArray<int> codePoints)
       native "StringBase_createFromCodePoints";
 
@@ skipping 110 matching lines @@
       throw new IndexOutOfRangeException(endIndex);
     }
     if (startIndex > endIndex) {
       throw new IndexOutOfRangeException(startIndex);
     }
     return substringUnchecked_(startIndex, endIndex);
   }
 
   String substringUnchecked_(int startIndex, int endIndex) {
     int len = endIndex - startIndex;
-    Array<int> charCodes = new Array<int>(len);
+    List<int> charCodes = new List<int>(len);
     for (int i = 0; i < len; i++) {
       charCodes[i] = this.charCodeAt(startIndex + i);
     }
     return StringBase.createFromCharCodes(charCodes);
   }
 
   String trim() {
     int len = this.length;
     int first = 0;
     for (; first < len; first++) {
@@ skipping 80 matching lines @@
    * Returns concatenated string.
    */
   String operator +(Object obj) {
     return this.concat(obj.toString());
   }
 
   /**
    * Convert all objects in [values] to strings and concat them
    * into a result string.
    */
-  static String _interpolate(Array values) {
+  static String _interpolate(List values) {
     int numValues = values.length;
-    Array<String> stringArray = new Array<String>(numValues);
+    List<String> stringList = new List<String>(numValues);
     int resultLength = 0;
     for (int i = 0; i < numValues; i++) {
       String str = values[i].toString();
       resultLength += str.length;
-      stringArray[i] = str;
+      stringList[i] = str;
     }
-    Array<int> codepoints = new Array<int>(resultLength);
+    List<int> codepoints = new List<int>(resultLength);
     int intArrayIx = 0;
     for (int i = 0; i < numValues; i++) {
-      String str = stringArray[i];
+      String str = stringList[i];
       int strLength = str.length;
       for (int k = 0; k < strLength; k++) {
         codepoints[intArrayIx++] = str.charCodeAt(k);
       }
     }
     return StringBase.createFromCharCodes(codepoints);
   }
 
   Iterable<Match> allMatches(String str) {
-    GrowableObjectArray<Match> result = new GrowableObjectArray<Match>();
+    List<Match> result = new List<Match>();
     if (this.isEmpty()) return result;
     int length = this.length;
 
     int ix = 0;
     while (ix < str.length) {
       int foundIx = str.indexOf(this, ix);
       if (foundIx < 0) break;
       result.add(new _StringMatch(foundIx, str, this));
       ix = foundIx + length;
     }
     return result;
   }
 
-  Array<String> split(Pattern pattern) {
+  List<String> split(Pattern pattern) {
     if (pattern is RegExp) {
       throw "Unimplemented split with RegExp";
     }
-    GrowableObjectArray<String> result = new GrowableObjectArray<String>();
+    List<String> result = new List<String>();
     if (pattern.isEmpty()) {
       for (int i = 0; i < this.length; i++) {
         result.add(this.substring(i, i+1));
       }
       return result;
     }
     int ix = 0;
     while (ix < this.length) {
       int foundIx = this.indexOf(pattern, ix);
       if (foundIx < 0) {
         // Not found, add remaining.
         result.add(this.substring(ix, this.length));
         break;
       }
       result.add(this.substring(ix, foundIx));
       ix = foundIx + pattern.length;
     }
     if (ix == this.length) {
       result.add("");
     }
     return result;
   }
 
-  Array<String> splitChars() {
+  List<String> splitChars() {
     int len = this.length;
-    final result = new Array<String>(len);
+    final result = new List<String>(len);
     for (int i = 0; i < len; i++) {
       result[i] = this[i];
     }
     return result;
   }
 
-  Array<int> charCodes() {
+  List<int> charCodes() {
     int len = this.length;
-    final result = new Array<int>(len);
+    final result = new List<int>(len);
     for (int i = 0; i < len; i++) {
       result[i] = this.charCodeAt(i);
     }
     return result;
   }
 
   String toLowerCase() {
     final int aCode = "A".charCodeAt(0);
     final int zCode = "Z".charCodeAt(0);
     final int delta = aCode - "a".charCodeAt(0);
@@ skipping 10 matching lines @@
   static String _convert(String str, int startCode, int endCode, int delta) {
     final int len = str.length;
     int i = 0;
     // Check if we can just return the string.
     for (; i < len; i++) {
       int code = str.charCodeAt(i);
       if ((startCode <= code) && (code <= endCode)) break;
     }
     if (i == len) return str;
 
-    Array<int> charCodes = new Array<int>(len);
+    List<int> charCodes = new List<int>(len);
     for (i = 0; i < len; i++) {
       int code = str.charCodeAt(i);
       if ((startCode <= code) && (code <= endCode)) {
         code = code - delta;
       }
       charCodes[i] = code;
     }
     return StringBase.createFromCharCodes(charCodes);
   }
 
 
 
   // Implementations of Strings methods follow below.
-  static String join(Array<String> strings, String separator) {
+  static String join(List<String> strings, String separator) {
     final int length = strings.length;
     if (length === 0) {
       return "";
     }
 
-    Array strings_array = strings;
+    List stringsList = strings;
     if (separator.length != 0) {
-      strings_array = new Array(2 * length - 1);
-      strings_array[0] = strings[0];
+      stringsList = new List(2 * length - 1);
+      stringsList[0] = strings[0];
       int j = 1;
       for (int i = 1; i < length; i++) {
-        strings_array[j++] = separator;
-        strings_array[j++] = strings[i];
+        stringsList[j++] = separator;
+        stringsList[j++] = strings[i];
       }
     }
-    return concatAll(strings_array);
+    return concatAll(stringsList);
   }
 
-  static String concatAll(Array<String> strings) {
-    ObjectArray strings_array;
+  static String concatAll(List<String> strings) {
+    ObjectArray stringsArray;
     if (strings is ObjectArray) {
-      strings_array = strings;
+      stringsArray = strings;
     } else {
       int len = strings.length;
-      strings_array = new Array(len);
+      stringsArray = new ObjectArray(len);
       for (int i = 0; i < len; i++) {
-        strings_array[i] = strings[i];
+        stringsArray[i] = strings[i];
       }
     }
-    return _concatAll(strings_array);
+    return _concatAll(stringsArray);
   }
 
   static String _concatAll(ObjectArray<String> strings)
       native "Strings_concatAll";
 }
 
 
 class OneByteString extends StringBase implements String {
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
@@ skipping 40 matching lines @@
   String operator[](int g) => group(g);
   int groupCount() => 0;
 
   String group(int group) {
     if (group != 0) {
       throw new IndexOutOfRangeException(group);
     }
     return pattern;
   }
 
-  Array<String> groups(Array<int> groups) {
-    Array<String> result = new Array<String>();
+  List<String> groups(List<int> groups) {
+    List<String> result = new List<String>();
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int _start;
   final String str;
   final String pattern;
 }