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");
     }
-    if ((startIndex < 0) || (startIndex > this.length)) {
-      throw new RangeError.range(startIndex, 0, this.length);
-    }
+    RangeError.checkValueInInterval(startIndex, 0, this.length, "startIndex");
     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 is _OneByteString) ||
-                                (replacement is _ExternalOneByteString);
-    if (replacementIsOneByte && length < _maxJoinReplaceOneByteStringLength) {
+    bool replacementIsOneByte = replacement._isOneByte;
+    if (replacementIsOneByte &&
+        length < _maxJoinReplaceOneByteStringLength &&
+        this._isOneByte) {
       // TODO(lrn): Is there a cut-off point, or is runtime always faster?
-      bool thisIsOneByte = (this is _OneByteString) ||
-                           (this is _ExternalOneByteString);
-      if (replacementIsOneByte && thisIsOneByte) {
-        return _joinReplaceAllOneByteResult(this, matches, length);
-      }
+      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);
-      String replacement = replace(match).toString();
+      var replacement = "${replace(match)}";
       matches.add(replacement);
       length += replacement.length;
-      replacementStringsAreOneByte = replacementStringsAreOneByte &&
-          (replacement is _OneByteString ||
-           replacement is _ExternalOneByteString);
+      replacementStringsAreOneByte =
+          replacementStringsAreOneByte && replacement._isOneByte;
       startIndex = match.end;
     }
+    if (matches.isEmpty) return this;
     length += _addReplaceSlice(matches, startIndex, this.length);
     if (replacementStringsAreOneByte &&
-        length < _maxJoinReplaceOneByteStringLength) {
-      bool thisIsOneByte = (this is _OneByteString) ||
-                           (this is _ExternalOneByteString);
-      if (thisIsOneByte) {
-        return _joinReplaceAllOneByteResult(this, matches, length);
-      }
+        length < _maxJoinReplaceOneByteStringLength &&
+        this._isOneByte) {
+      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 542 matching lines @@
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String input;
   final String pattern;
 }