Add String.replaceRange and use it in replaceFirst{,Mapped}.

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 554 matching lines @@
     }
     if (startIndex is! int) {
       throw new ArgumentError("${startIndex} is not an int");
     }
     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)}";
+    return replaceRange(match.start, match.end, replacement);
   }
 
+  String replaceRange(int start, int end, String replacement) {
+    int length = this.length;
+    end = RangeError.checkValidRange(start, end, length);
+    bool replacementIsOneByte = replacement._isOneByte;
+    int replacementLength = replacement.length;
+    int totalLength = start + (length - end) + replacementLength;
+    if (replacementIsOneByte && this._isOneByte) {
+      var result = _OneByteString._allocate(totalLength);
+      int index = 0;
+      index = result._setRange(index, this, 0, start);
+      index = result._setRange(start, replacement, 0, replacementLength);
+      result._setRange(index, this, end, length);
+      return result;
+    }
+    List slices = [];
+    _addReplaceSlice(slices, 0, start);
+    if (replacement.length > 0) slices.add(replacement);
+    _addReplaceSlice(slices, end, length);
+    return _joinReplaceAllResult(this, slices, totalLength,
+                                 replacementIsOneByte);
+  }
 
   static int _addReplaceSlice(List matches, int start, int end) {
     int length = end - start;
     if (length > 0) {
       if (length <= _maxLengthValue && start <= _maxStartValue) {
         matches.add(-((start << _lengthBits) | length));
       } else {
         matches.add(start);
         matches.add(end);
       }
@@ skipping 122 matching lines @@
                             [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, slices, length);
-    }
-    return _joinReplaceAllResult(this, slices, length, replacementIsOneByte);
+    return replaceRange(match.start, match.end, replacement);
   }
 
   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;
@@ skipping 460 matching lines @@
   static _OneByteString _allocate(int length) native "OneByteString_allocate";
 
 
   static _OneByteString _allocateFromOneByteList(List<int> list,
                                                  int start, int end)
       native "OneByteString_allocateFromOneByteList";
 
   // This is internal helper method. Code point value must be a valid
   // Latin1 value (0..0xFF), index must be valid.
   void _setAt(int index, int codePoint) native "OneByteString_setAt";
+
+  // Should be optimizable to a memory move.
+  // Accepts both _OneByteString and _ExternalOneByteString as argument.
+  // Returns index after last character written.
+  int _setRange(int index, String oneByteString, int start, int end) {
+    assert(oneByteString._isOneByte);
+    assert(0 <= start);
+    assert(start <= end);
+    assert(end <= oneByteString.length);
+    assert(0 <= index);
+    assert(index + (end - start) <= length);
+    for (int i = start; i < end; i++) {
+      _setAt(index, oneByteString.codeUnitAt(i));
+      index += 1;
+    }
+    return index;
+  }
 }
 
 
 class _TwoByteString extends _StringBase implements String {
   factory _TwoByteString._uninstantiable() {
     throw new UnsupportedError(
         "_TwoByteString can only be allocated by the VM");
   }
 
   static String _allocateFromTwoByteList(List list, int start, int end)
@@ skipping 64 matching lines @@
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String input;
   final String pattern;
 }