Revert "Add String.replaceFirstMapped."

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.
 
 const int _maxAscii = 0x7f;
 const int _maxLatin1 = 0xff;
 const int _maxUtf16 = 0xffff;
 const int _maxUnicode = 0x10ffff;
 
 patch class String {
@@ skipping 69 matching lines @@
 
   factory _StringBase._uninstantiable() {
     throw new UnsupportedError(
         "_StringBase can't be instaniated");
   }
 
   Type get runtimeType => String;
 
   int get hashCode native "String_getHashCode";
 
-  bool get _isOneByte {
-    // Alternatively return false and override it on one-byte string classes.
-    int id = ClassID.getID(this);
-    return id == ClassID.cidOneByteString ||
-           id == ClassID.cidExternalOneByteString;
-  }
-
   /**
    * Create the most efficient string representation for specified
    * [charCodes].
    *
    * Only uses the character codes betwen index [start] and index [end] of
    * `charCodes`. They must satisfy `0 <= start <= end <= charCodes.length`.
    *
    * The [limit] is an upper limit on the character codes in the iterable.
    * It's `null` if unknown.
    */
@@ skipping 452 matching lines @@
                       [int startIndex = 0]) {
     if (pattern is! Pattern) {
       throw new ArgumentError("${pattern} is not a Pattern");
     }
     if (replacement is! String) {
       throw new ArgumentError("${replacement} is not a String");
     }
     if (startIndex is! int) {
       throw new ArgumentError("${startIndex} is not an int");
     }
-    RangeError.checkValueInInterval(startIndex, 0, this.length, "startIndex");
+    if ((startIndex < 0) || (startIndex > this.length)) {
+      throw new RangeError.range(startIndex, 0, this.length);
+    }
     Iterator iterator =
         startIndex == 0 ? pattern.allMatches(this).iterator
                         : pattern.allMatches(this, startIndex).iterator;
     if (!iterator.moveNext()) return this;
     Match match = iterator.current;
     return "${this.substring(0, match.start)}"
            "$replacement"
            "${this.substring(match.end)}";
   }
 
@@ skipping 26 matching lines @@
       }
     } else {
       for (Match match in pattern.allMatches(this)) {
         length += _addReplaceSlice(matches, startIndex, match.start);
         matches.add(replacement);
         length += replacementLength;
         startIndex = match.end;
       }
     }
     length += _addReplaceSlice(matches, startIndex, this.length);
-    bool replacementIsOneByte = replacement._isOneByte;
-    if (replacementIsOneByte &&
-        length < _maxJoinReplaceOneByteStringLength &&
-        this._isOneByte) {
+    bool replacementIsOneByte = (replacement is _OneByteString) ||
+                                (replacement is _ExternalOneByteString);
+    if (replacementIsOneByte && length < _maxJoinReplaceOneByteStringLength) {
       // TODO(lrn): Is there a cut-off point, or is runtime always faster?
-      return _joinReplaceAllOneByteResult(this, matches, length);
+      bool thisIsOneByte = (this is _OneByteString) ||
+                           (this is _ExternalOneByteString);
+      if (replacementIsOneByte && thisIsOneByte) {
+        return _joinReplaceAllOneByteResult(this, matches, length);
+      }
     }
     return _joinReplaceAllResult(this, matches, length,
                                  replacementIsOneByte);
   }
 
   /**
    * As [_joinReplaceAllResult], but knowing that the result
    * is always a [_OneByteString].
    */
   static String _joinReplaceAllOneByteResult(String base,
@@ skipping 51 matching lines @@
 
   String replaceAllMapped(Pattern pattern, String replace(Match match)) {
     if (pattern == null) throw new ArgumentError.notNull("pattern");
     if (replace == null) throw new ArgumentError.notNull("replace");
     List matches = [];
     int length = 0;
     int startIndex = 0;
     bool replacementStringsAreOneByte = true;
     for (Match match in pattern.allMatches(this)) {
       length += _addReplaceSlice(matches, startIndex, match.start);
-      var replacement = "${replace(match)}";
+      String replacement = replace(match).toString();
       matches.add(replacement);
       length += replacement.length;
-      replacementStringsAreOneByte =
-          replacementStringsAreOneByte && replacement._isOneByte;
+      replacementStringsAreOneByte = replacementStringsAreOneByte &&
+          (replacement is _OneByteString ||
+           replacement is _ExternalOneByteString);
       startIndex = match.end;
     }
-    if (matches.isEmpty) return this;
     length += _addReplaceSlice(matches, startIndex, this.length);
     if (replacementStringsAreOneByte &&
-        length < _maxJoinReplaceOneByteStringLength &&
-        this._isOneByte) {
-      return _joinReplaceAllOneByteResult(this, matches, length);
+        length < _maxJoinReplaceOneByteStringLength) {
+      bool thisIsOneByte = (this is _OneByteString) ||
+                           (this is _ExternalOneByteString);
+      if (thisIsOneByte) {
+        return _joinReplaceAllOneByteResult(this, matches, length);
+      }
     }
     return _joinReplaceAllResult(this, matches, length,
                                  replacementStringsAreOneByte);
   }
 
-  String replaceFirstMapped(Pattern pattern, String replace(Match match),
-                            [int startIndex = 0]) {
-    if (pattern == null) throw new ArgumentError.notNull("pattern");
-    if (replace == null) throw new ArgumentError.notNull("replace");
-    if (startIndex == null) throw new ArgumentError.notNull("startIndex");
-    RangeError.checkValueInInterval(startIndex, 0, this.length, "startIndex");
-
-    var matches = pattern.allMatches(this, startIndex).iterator;
-    if (!matches.moveNext()) return this;
-    var match = matches.current;
-    var replacement = "${replace(match)}";
-    var slices = [];
-    int length = 0;
-    if (match.start > 0) {
-      length += _addReplaceSlice(slices, 0, match.start);
-    }
-    slices.add(replacement);
-    length += replacement.length;
-    if (match.end < this.length) {
-      length += _addReplaceSlice(slices, match.end, this.length);
-    }
-    bool replacementIsOneByte = _replacement._isOneByte;
-    if (replacementIsOneByte &&
-        length < _maxJoinReplaceOneByteStringLength &&
-        this._isOneByte) {
-      return _joinReplaceAllOneByteResult(this, matches, length);
-    }
-    return _joinReplaceAllResult(this, slices, length, replacementIsOneByte);
-  }
-
   static String _matchString(Match match) => match[0];
   static String _stringIdentity(String string) => string;
 
   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.write(onNonMatch(""));
@@ skipping 41 matching lines @@
       startIndex = match.end;
     }
     buffer.write(onNonMatch(this.substring(startIndex)));
     return buffer.toString();
   }
 
   // Convert single object to string.
   static String _interpolateSingle(Object o) {
     final s = o.toString();
     if (s is! String) {
-      throw new ArgumentError(Error.safeToString(o));
+      throw new ArgumentError(o);
     }
     return s;
   }
 
   /**
    * Convert all objects in [values] to strings and concat them
    * into a result string.
    * Modifies the input list if it contains non-`String` values.
    */
   static String _interpolate(final List values) {
     final numValues = values.length;
     int totalLength = 0;
     int i = 0;
     while (i < numValues) {
       final e = values[i];
       final s = e.toString();
       values[i] = s;
       if (ClassID.getID(s) == ClassID.cidOneByteString) {
         totalLength += s.length;
         i++;
       } else if (s is! String) {
-        throw new ArgumentError(Error.safeToString(e));
+        throw new ArgumentError(s);
       } else {
         // Handle remaining elements without checking for one-byte-ness.
         while (++i < numValues) {
           final e = values[i];
           final s = e.toString();
           values[i] = s;
           if (s is! String) {
-            throw new ArgumentError(Error.safeToString(e));
+            throw new ArgumentError(s);
           }
         }
         return _concatRangeNative(values, 0, numValues);
       }
     }
     // All strings were one-byte strings.
     return _OneByteString._concatAll(values, totalLength);
   }
 
   Iterable<Match> allMatches(String string, [int start = 0]) {
@@ skipping 450 matching lines @@
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String input;
   final String pattern;
 }