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

compiler/lib/implementation/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.
 
 class StringImplementation implements String native "String" {
-  factory StringImplementation.fromValues(Array<int> values) {
+  factory StringImplementation.fromValues(List<int> values) {
     return _newFromValues(values);
   }
 
   String operator[](int index) {
     if (0 <= index && index < length) {
       return _indexOperator(index);
     }
     throw new IndexOutOfRangeException(index);
   }
 
@@ skipping 104 matching lines @@
         return _replaceAll(from, to);
       }
     } else if (from is JSSyntaxRegExp) {
       return _replaceAll(from, to);
     } else {
       // TODO(floitsch): implement generic String.replace (with patterns).
       throw "StringImplementation.replaceAll(Pattern) UNIMPLEMENTED";
     }
   }
 
-  Array<String> split(Pattern pattern) {
+  List<String> split(Pattern pattern) {
     if (pattern is String || pattern is JSSyntaxRegExp) {
       return _split(pattern);
     } else {
       throw "StringImplementation.split(Pattern) UNIMPLEMENTED";
     }
   }
 
   Iterable<Match> allMatches(String str) {
     List<Match> result = [];
     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;
       // Call "toString" to coerce the "this" back to a primitive string.
       result.add(new _StringMatch(foundIx, str, this.toString()));
       ix = foundIx + length;
     }
     return result;
   }
 
-  Array<String> splitChars() {
+  List<String> splitChars() {
     return _split("");
   }
 
-  Array<int> charCodes() {
+  List<int> charCodes() {
     int len = length;
-    Array<int> result = new Array<int>(len);
+    List<int> result = new List<int>(len);
     for (int i = 0; i < len; i++) {
       // It is safe to call the private function (which doesn't do
       // range-checks).
       result[i] = _charCodeAt(i);
     }
     return result;
   }
 
   String toLowerCase() native;
   String toUpperCase() native;
 
   int hashCode() native;
 
   // Note: we can't just return 'this', because we want the primitive string
   // and not the wrapped String object.
   String toString() native;
 
   int compareTo(String other) native;
 
-  static String _newFromValues(Array<int> values) native;
+  static String _newFromValues(List<int> values) native;
   String _indexOperator(int index) native;
   int _charCodeAt(int index) native;
   String _substringUnchecked(int startIndex, int endIndex) native;
   String _replace(Pattern from, String to) native;
   String _replaceAll(Pattern from, String to) native;
-  Array<String> _split(Pattern pattern) native;
+  List<String> _split(Pattern pattern) native;
 
   get dynamic() { return toString(); }
 }
 
 class _StringJsUtil {
   static String toDartString(o) native {
     if (o === null) return "null";
     return o.toString();
   }
 }
 
 class _StringMatch implements Match {
   const _StringMatch(int this._start,
                      String this.str,
                      String this.pattern);
 
   int start() => _start;
   int end() => _start + pattern.length;
   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;
 }