Big merge from experimental to bleeding edge.

sdk/lib/_internal/compiler/implementation/lib/js_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 _interceptors;
 
 /**
  * The interceptor class for [String]. The compiler recognizes this
  * class as an interceptor, and changes references to [:this:] to
  * actually use the receiver of the method, which is generated as an extra
@@ skipping 24 matching lines @@
     int otherLength = other.length;
     if (otherLength > length) return false;
     return other == substring(length - otherLength);
   }
 
   String replaceAll(Pattern from, String to) {
     checkString(to);
     return stringReplaceAllUnchecked(this, from, to);
   }
 
+  String replaceAllMapped(Pattern from, String convert(Match match)) {
+    return this.splitMapJoin(from, onMatch: convert);
+  }
+
+  String splitMapJoin(Pattern from,
+                      {String onMatch(Match match),
+                       String onNonMatch(String nonMatch)}) {
+    return stringReplaceAllFuncUnchecked(this, from, onMatch, onNonMatch);
+  }
+
   String replaceFirst(Pattern from, String to) {
     checkString(to);
     return stringReplaceFirstUnchecked(this, from, to);
   }
 
   List<String> split(Pattern pattern) {
     checkNull(pattern);
     if (pattern is String) {
       return JS('=List', r'#.split(#)', this, pattern);
     } else if (pattern is JSSyntaxRegExp) {
@@ skipping 19 matching lines @@
   String substring(int startIndex, [int endIndex]) {
     checkNum(startIndex);
     if (endIndex == null) endIndex = length;
     checkNum(endIndex);
     if (startIndex < 0 ) throw new RangeError.value(startIndex);
     if (startIndex > endIndex) throw new RangeError.value(startIndex);
     if (endIndex > length) throw new RangeError.value(endIndex);
     return JS('String', r'#.substring(#, #)', this, startIndex, endIndex);
   }
 
+  String slice([int startIndex, int endIndex]) {
+    int start, end;
+    if (startIndex == null) {
+      start = 0;
+    } else if (startIndex is! int) {
+      throw new ArgumentError("startIndex is not int");
+    } else if (startIndex >= 0) {
+      start = startIndex;
+    } else {
+      start = this.length + startIndex;
+    }
+    if (start < 0 || start > this.length) {
+      throw new RangeError(
+          "startIndex out of range: $startIndex (length: $length)");
+    }
+    if (endIndex == null) {
+      end = this.length;
+    } else if (endIndex is! int) {
+      throw new ArgumentError("endIndex is not int");
+    } else if (endIndex >= 0) {
+      end = endIndex;
+    } else {
+      end = this.length + endIndex;
+    }
+    if (end < 0 || end > this.length) {
+      throw new RangeError(
+          "endIndex out of range: $endIndex (length: $length)");
+    }
+    if (end < start) {
+      throw new ArgumentError(
+          "End before start: $endIndex < $startIndex (length: $length)");
+    }
+    return JS('String', '#.substring(#, #)', this, start, end);
+  }
+
+
   String toLowerCase() {
     return JS('String', r'#.toLowerCase()', this);
   }
 
   String toUpperCase() {
     return JS('String', r'#.toUpperCase()', this);
   }
 
   String trim() {
     return JS('String', r'#.trim()', this);
   }
 
   List<int> get charCodes  {
-    List<int> result = new List<int>(length);
+    List<int> result = new List<int>.fixedLength(length);
     for (int i = 0; i < length; i++) {
       result[i] = JS('int', '#.charCodeAt(#)', this, i);
     }
     return result;
   }
 
   int indexOf(String other, [int start = 0]) {
     checkNull(other);
     if (start is !int) throw new ArgumentError(start);
     if (other is !String) throw new ArgumentError(other);
@@ skipping 55 matching lines @@
   Type get runtimeType => String;
 
   int get length => JS('int', r'#.length', this);
 
   String operator [](int index) {
     if (index is !int) throw new ArgumentError(index);
     if (index >= length || index < 0) throw new RangeError.value(index);
     return JS('String', '#[#]', this, index);
   }
 }