Remove deprecated string features.

runtime/lib/string_base.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.
 
 /**
  * [_StringBase] contains common methods used by concrete String
  * implementations, e.g., _OneByteString.
  */
 class _StringBase {
 
@@ skipping 20 matching lines @@
       }
     }
     return _createFromCodePoints(objectArray);
   }
 
   static String _createFromCodePoints(List<int> codePoints)
       native "StringBase_createFromCodePoints";
 
   String operator [](int index) native "String_charAt";
 
-  int charCodeAt(int index) native "String_charCodeAt";
-
-  int codeUnitAt(int index) {
-    return charCodeAt(index);
-  }
+  int codeUnitAt(int index) native "String_codeUnitAt";
 
   int get length native "String_getLength";
 
   bool get isEmpty {
     return this.length == 0;
   }
 
   String concat(String other) native "String_concat";
 
   String toString() {
@@ skipping 10 matching lines @@
       return false;
     }
     return this.compareTo(other) == 0;
   }
 
   int compareTo(String other) {
     int thisLength = this.length;
     int otherLength = other.length;
     int len = (thisLength < otherLength) ? thisLength : otherLength;
     for (int i = 0; i < len; i++) {
-      int thisCodePoint = this.charCodeAt(i);
-      int otherCodePoint = other.charCodeAt(i);
+      int thisCodePoint = this.codeUnitAt(i);
+      int otherCodePoint = other.codeUnitAt(i);
       if (thisCodePoint < otherCodePoint) {
         return -1;
       }
       if (thisCodePoint > otherCodePoint) {
         return 1;
       }
     }
     if (thisLength < otherLength) return -1;
     if (thisLength > otherLength) return 1;
     return 0;
   }
 
   bool _substringMatches(int start, String other) {
     if (other.isEmpty) return true;
     if ((start < 0) || (start >= this.length)) {
       return false;
     }
     final int len = other.length;
     if ((start + len) > this.length) {
       return false;
     }
     for (int i = 0; i < len; i++) {
-      if (this.charCodeAt(i + start) != other.charCodeAt(i)) {
+      if (this.codeUnitAt(i + start) != other.codeUnitAt(i)) {
         return false;
       }
     }
     return true;
   }
 
   bool endsWith(String other) {
     return _substringMatches(this.length - other.length, other);
   }
 
@@ skipping 98 matching lines @@
     return _substringUncheckedNative(startIndex, endIndex);
   }
 
   String _substringUncheckedNative(int startIndex, int endIndex)
       native "StringBase_substringUnchecked";
 
   String trim() {
     final int len = this.length;
     int first = 0;
     for (; first < len; first++) {
-      if (!_isWhitespace(this.charCodeAt(first))) {
+      if (!_isWhitespace(this.codeUnitAt(first))) {
         break;
       }
     }
     if (len == first) {
       // String contains only whitespaces.
       return "";
     }
     int last = len - 1;
     for (; last >= first; last--) {
-      if (!_isWhitespace(this.charCodeAt(last))) {
+      if (!_isWhitespace(this.codeUnitAt(last))) {
         break;
       }
     }
     if ((first == 0) && (last == (len - 1))) {
       // Returns this string if it does not have leading or trailing
       // whitespaces.
       return this;
     } else {
       return _substringUnchecked(first, last + 1);
     }
@@ skipping 53 matching lines @@
   String _splitMapJoinEmptyString(String onMatch(Match match),
                                   String onNonMatch(String nonMatch)) {
     // Pattern is the empty string.
     StringBuffer buffer = new StringBuffer();
     int length = this.length;
     int i = 0;
     buffer.add(onNonMatch(""));
     while (i < length) {
       buffer.add(onMatch(new _StringMatch(i, this, "")));
       // Special case to avoid splitting a surrogate pair.
-      int code = this.charCodeAt(i);
+      int code = this.codeUnitAt(i);
       if ((code & ~0x3FF) == 0xD800 && length > i + 1) {
         // Leading surrogate;
-        code = this.charCodeAt(i + 1);
+        code = this.codeUnitAt(i + 1);
         if ((code & ~0x3FF) == 0xDC00) {
           // Matching trailing surrogate.
           buffer.add(onNonMatch(this.substring(i, i + 2)));
           i += 2;
           continue;
         }
       }
       buffer.add(onNonMatch(this[i]));
       i++;
     }
@@ skipping 59 matching lines @@
         ++startIndex;  // empty match, advance and restart
       } else {
         startIndex = endIndex;
       }
     }
     return result;
   }
 
   List<String> split(Pattern pattern) {
     if ((pattern is String) && pattern.isEmpty) {
-      return splitChars();
+      List<String> result = new List<String>(length);
+      for (int i = 0; i < length; i++) {
+        result[i] = this[i];
+      }
+      return result;
     }
     int length = this.length;
     Iterator iterator = pattern.allMatches(this).iterator;
     if (length == 0 && iterator.moveNext()) {
       // A matched empty string input returns the empty list.
       return <String>[];
     }
     List<String> result = new List<String>();
     int startIndex = 0;
     int previousIndex = 0;
@@ skipping 11 matching lines @@
       if (startIndex == endIndex && endIndex == previousIndex) {
         ++startIndex;  // empty match, advance and restart
         continue;
       }
       result.add(this._substringUnchecked(previousIndex, match.start));
       startIndex = previousIndex = endIndex;
     }
     return result;
   }
 
-  List<String> splitChars() {
-    int len = this.length;
-    final result = new List<String>.fixedLength(len);
-    for (int i = 0; i < len; i++) {
-      result[i] = this[i];
-    }
-    return result;
-  }
-
-  List<int> get charCodes {
-    int len = this.length;
-    final result = new List<int>.fixedLength(len);
-    for (int i = 0; i < len; i++) {
-      result[i] = this.charCodeAt(i);
-    }
-    return result;
-  }
-
-  Iterable<int> get codeUnits => new CodeUnits(this);
+  List<int> get codeUnits => new CodeUnits(this);

[srdjan, 2013/02/19 17:28:44]

How does this work? Does it run in checked mode?

new CodeUnits produces an instance of CodeUnits:
CodeUnits extends ListIterable<int>
ListIterable<E> extends Iterable<E>

However:
List<E> implements Collection<E>
Collection<E> extends Iterable<E>

[Lasse Reichstein Nielsen, 2013/02/20 06:38:23]

Yes. CodeUnits was changed to be a List (extends UnmodifiableListBase, which
extends ListBase, which implements List).

 
   Runes get runes => new Runes(this);
 
   String toUpperCase() native "String_toUpperCase";
 
   String toLowerCase() native "String_toLowerCase";
 
   // Implementations of Strings methods follow below.
   static String join(Iterable<String> strings, String separator) {
     bool first = true;
@@ skipping 53 matching lines @@
   }
 
   String _substringUncheckedNative(int startIndex, int endIndex)
       native "OneByteString_substringUnchecked";
 
   List<String> _splitWithCharCode(int charCode)
       native "OneByteString_splitWithCharCode";
 
   List<String> split(Pattern pattern) {
     if ((pattern is _OneByteString) && (pattern.length == 1)) {
-      return _splitWithCharCode(pattern.charCodeAt(0));
+      return _splitWithCharCode(pattern.codeUnitAt(0));
     }
     return super.split(pattern);
   }
 }
 
 
 class _TwoByteString extends _StringBase implements String {
   factory _TwoByteString._uninstantiable() {
     throw new UnsupportedError(
         "_TwoByteString can only be allocated by the VM");
@@ skipping 99 matching lines @@
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String str;
   final String pattern;
 }