Remove deprecated string features.

sdk/lib/core/string.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.
 
 part of dart.core;
 
 /**
  * The String class represents sequences of characters. Strings are
  * immutable. A string is represented by a sequence of Unicode UTF-16
  * code units accessible through the [codeUnitAt] or the
@@ skipping 10 matching lines @@
   /**
    * Allocates a new String for the specified [charCodes].
    *
    * The [charCodes] can be UTF-16 code units or runes. If a char-code value is
    * 16-bit it is copied verbatim. If it is greater than 16 bits it is
    * decomposed into a surrogate pair.
    */
   external factory String.fromCharCodes(Iterable<int> charCodes);
 
   /**
-   * *Deprecated*. Use [String.fromCharCode] instead.
-   */
-  @deprecated
-  factory String.character(int charCode) => new String.fromCharCode(charCode);
-
-  /**
    * Allocates a new String for the specified [charCode].
    *
    * The new string contains a single code unit if the [charCode] can be
    * represented by a single UTF-16 code unit. Otherwise the [length] is 2 and
    * the code units form a surrogate pair.
    *
    * It is allowed (though generally discouraged) to create a String with only
    * one half of a surrogate pair.
    */
   factory String.fromCharCode(int charCode) {
@@ skipping 18 matching lines @@
    *     // thus invalid UTF-16 strings:
    *     clef[0];  // => "\uDBFF"
    *     clef[1];  // => "\uDFFD"
    *
    * This method is equivalent to
    * `new String.fromCharCode(this.codeUnitAt(index))`.
    */
   String operator [](int index);
 
   /**
-   * Gets the scalar character code at the given [index].
-   *
-   * *This method is deprecated. Please use [codeUnitAt] instead.*
-   */
-  @deprecated
-  int charCodeAt(int index);
-
-  /**
    * Returns the 16-bit UTF-16 code unit at the given [index].
    */
   int codeUnitAt(int index);
 
   /**
    * The length of the string.
    *
    * Returns the number of UTF-16 code units in this string. The number
    * of [runes] might be less, if the string contains characters outside
    * the basic multilingual plane (plane 0).
@@ skipping 119 matching lines @@
 
   /**
    * Splits the string around matches of [pattern]. Returns
    * a list of substrings.
    *
    * Splitting with an empty string pattern (`""`) splits at UTF-16 code unit
    * boundaries and not at rune boundaries. The following two expressions
    * are hence equivalent:
    *
    *     string.split("")
-   *     string.codeUnits.map((unit) => new String.character(unit))
+   *     string.codeUnits.map((unit) => new String.fromCharCode(unit))
    *
    * Unless it guaranteed that the string is in the basic multilingual plane
    * (meaning that each code unit represents a rune) it is often better to
    * map the runes instead:
    *
-   *     string.runes.map((rune) => new String.character(rune))
+   *     string.runes.map((rune) => new String.fromCharCode(rune))
    */
   List<String> split(Pattern pattern);
 
   /**
-   * Returns a list of the individual code-units converted to strings.
-   *
-   * *Deprecated*
-   * If you want to split on code-unit boundaries, use [split]. If you
-   * want to split on rune boundaries, use [runes] and map the result.
-   *
-   *     Iterable<String> characters =
-   *         string.runes.map((c) => new String.fromCharCode(c));
-   */
-  @deprecated
-  List<String> splitChars();
-
-  /**
    * Splits the string on the [pattern], then converts each part and each match.
    *
    * The pattern is used to split the string into parts and separating matches.
    *
    * Each match is converted to a string by calling [onMatch]. If [onMatch]
    * is omitted, the matched string is used.
    *
    * Each non-matched part is converted by a call to [onNonMatch]. If
    * [onNonMatch] is omitted, the non-matching part is used.
    *
    * Then all the converted parts are combined into the resulting string.
    */
   String splitMapJoin(Pattern pattern,
                       {String onMatch(Match match),
                        String onNonMatch(String nonMatch)});
 
   /**
-   * Returns a list of UTF-16 code units of this string.
-   *
-   * *This getter is deprecated. Use [codeUnits] instead.*
+   * Returns an unmodifiable list of the UTF-16 code units of this string.
    */
-  List<int> get charCodes;
-
-  /**
-   * Returns an iterable of the UTF-16 code units of this string.
-   */
-  // TODO(floitsch): should it return a list?
-  // TODO(floitsch): make it a bidirectional iterator.
-  Iterable<int> get codeUnits;
+  List<int> get codeUnits;
 
   /**
    * Returns an iterable of Unicode code-points of this string.
    *
    * If the string contains surrogate pairs, they will be combined and returned
    * as one integer by this iterator. Unmatched surrogate halves are treated
    * like valid 16-bit code-units.
    */
   Runes get runes;
 
@@ skipping 19 matching lines @@
   final String string;
   Runes(this.string);
 
   RuneIterator get iterator => new RuneIterator(string);
 
   int get last {
     if (string.length == 0) {
       throw new StateError("No elements.");
     }
     int length = string.length;
-    int code = string.charCodeAt(length - 1);
+    int code = string.codeUnitAt(length - 1);
     if (_isTrailSurrogate(code) && string.length > 1) {
-      int previousCode = string.charCodeAt(length - 2);
+      int previousCode = string.codeUnitAt(length - 2);
       if (_isLeadSurrogate(previousCode)) {
         return _combineSurrogatePair(previousCode, code);
       }
     }
     return code;
   }
 
 }
 
 // Is then code (a 16-bit unsigned integer) a UTF-16 lead surrogate.
@@ skipping 42 matching lines @@
       : string = string, _position = index, _nextPosition = index {
     if (index < 0 || index > string.length) {
       throw new RangeError.range(index, 0, string.length);
     }
     _checkSplitSurrogate(index);
   }
 
   /** Throw an error if the index is in the middle of a surrogate pair. */
   void _checkSplitSurrogate(int index) {
     if (index > 0 && index < string.length &&
-        _isLeadSurrogate(string.charCodeAt(index - 1)) &&
-        _isTrailSurrogate(string.charCodeAt(index))) {
+        _isLeadSurrogate(string.codeUnitAt(index - 1)) &&
+        _isTrailSurrogate(string.codeUnitAt(index))) {
       throw new ArgumentError("Index inside surrogate pair: $index");
     }
   }
 
   /**
    * Returns the starting position of the current rune in the string.
    *
    * Returns null if the [current] rune is null.
    */
   int get rawIndex => (_position != _nextPosition) ? _position : null;
@@ skipping 57 matching lines @@
     if (_position + 1 == _nextPosition) return string[_position];
     return string.substring(_position, _nextPosition);
   }
 
   bool moveNext() {
     _position = _nextPosition;
     if (_position == string.length) {
       _currentCodePoint = null;
       return false;
     }
-    int codeUnit = string.charCodeAt(_position);
+    int codeUnit = string.codeUnitAt(_position);
     int nextPosition = _position + 1;
     if (_isLeadSurrogate(codeUnit) && nextPosition < string.length) {
-      int nextCodeUnit = string.charCodeAt(nextPosition);
+      int nextCodeUnit = string.codeUnitAt(nextPosition);
       if (_isTrailSurrogate(nextCodeUnit)) {
         _nextPosition = nextPosition + 1;
         _currentCodePoint = _combineSurrogatePair(codeUnit, nextCodeUnit);
         return true;
       }
     }
     _nextPosition = nextPosition;
     _currentCodePoint = codeUnit;
     return true;
   }
 
   bool movePrevious() {
     _nextPosition = _position;
     if (_position == 0) {
       _currentCodePoint = null;
       return false;
     }
     int position = _position - 1;
-    int codeUnit = string.charCodeAt(position);
+    int codeUnit = string.codeUnitAt(position);
     if (_isTrailSurrogate(codeUnit) && position > 0) {
-      int prevCodeUnit = string.charCodeAt(position - 1);
+      int prevCodeUnit = string.codeUnitAt(position - 1);
       if (_isLeadSurrogate(prevCodeUnit)) {
         _position = position - 1;
         _currentCodePoint = _combineSurrogatePair(prevCodeUnit, codeUnit);
         return true;
       }
     }
     _position = position;
     _currentCodePoint = codeUnit;
     return true;
   }
 }
-
-/**
- * An [Iterable] of the UTF-16 code units of a [String] in index order.
- */
-class CodeUnits extends ListIterable<int> {
-  /** The string that this is the code units of. */
-  String string;
-
-  CodeUnits(this.string);
-
-  int get length => string.length;
-  int elementAt(int i) => string.codeUnitAt(i);
-}