Revert "Fix observatory tests broken by running dartfmt."

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 {
-  @patch
-  factory String.fromCharCodes(Iterable<int> charCodes,
-      [int start = 0, int end]) {
-    if (charCodes is! Iterable)
-      throw new ArgumentError.value(charCodes, "charCodes");
+@patch class String {
+  @patch factory String.fromCharCodes(Iterable<int> charCodes,
+                                      [int start = 0, int end]) {
+    if (charCodes is! Iterable) throw new ArgumentError.value(charCodes, "charCodes");
     if (start is! int) throw new ArgumentError.value(start, "start");
     if (end != null && end is! int) throw new ArgumentError.value(end, "end");
     return _StringBase.createFromCharCodes(charCodes, start, end, null);
   }
 
-  @patch
-  factory String.fromCharCode(int charCode) {
+  @patch factory String.fromCharCode(int charCode) {
     if (charCode >= 0) {
       if (charCode <= 0xff) {
         return _OneByteString._allocate(1).._setAt(0, charCode);
       }
       if (charCode <= 0xffff) {
-        return _StringBase._createFromCodePoints(
-            new _List(1)..[0] = charCode, 0, 1);
+        return _StringBase._createFromCodePoints(new _List(1)..[0] = charCode,
+                                                 0, 1);
       }
       if (charCode <= 0x10ffff) {
         var low = 0xDC00 | (charCode & 0x3ff);
         int bits = charCode - 0x10000;
         var high = 0xD800 | (bits >> 10);
-        return _StringBase._createFromCodePoints(
-            new _List(2)
-              ..[0] = high
-              ..[1] = low,
-            0,
-            2);
+        return  _StringBase._createFromCodePoints(new _List(2)..[0] = high
+                                                              ..[1] = low,
+                                                  0, 2);
       }
     }
     throw new RangeError.range(charCode, 0, 0x10ffff);
   }
 
-  @patch
-  const factory String.fromEnvironment(String name, {String defaultValue})
+  @patch const factory String.fromEnvironment(String name,
+                                              {String defaultValue})
       native "String_fromEnvironment";
 }
 
+
 /**
  * [_StringBase] contains common methods used by concrete String
  * implementations, e.g., _OneByteString.
  */
 abstract class _StringBase {
   // Constants used by replaceAll encoding of string slices between matches.
   // A string slice (start+length) is encoded in a single Smi to save memory
   // overhead in the common case.
   // We use fewer bits for length (11 bits) than for the start index (19+ bits).
   // For long strings, it's possible to have many large indices,
@@ skipping 16 matching lines @@
   // We pick 30 as a safe lower bound on available bits in a negative smi.
   // TODO(lrn): Consider allowing more bits for start on 64-bit systems.
   static const int _maxUnsignedSmiBits = 30;
 
   // For longer strings, calling into C++ to create the result of a
   // [replaceAll] is faster than [_joinReplaceAllOneByteResult].
   // TODO(lrn): See if this limit can be tweaked.
   static const int _maxJoinReplaceOneByteStringLength = 500;
 
   factory _StringBase._uninstantiable() {
-    throw new UnsupportedError("_StringBase can't be instaniated");
+    throw new UnsupportedError(
+        "_StringBase can't be instaniated");
   }
 
   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;
+           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.
    */
-  static String createFromCharCodes(
-      Iterable<int> charCodes, int start, int end, int limit) {
+  static String createFromCharCodes(Iterable<int> charCodes,
+                                    int start, int end,
+                                    int limit) {
     if (start == null) throw new ArgumentError.notNull("start");
     if (charCodes == null) throw new ArgumentError(charCodes);
     // TODO(srdjan): Also skip copying of wide typed arrays.
     final ccid = ClassID.getID(charCodes);
     bool isOneByteString = false;
     if ((ccid != ClassID.cidArray) &&
         (ccid != ClassID.cidGrowableObjectArray) &&
         (ccid != ClassID.cidImmutableArray)) {
       if (charCodes is Uint8List) {
         end = RangeError.checkValidRange(start, end, charCodes.length);
@@ skipping 27 matching lines @@
   static int _scanCodeUnits(List<int> charCodes, int start, int end) {
     int bits = 0;
     for (int i = start; i < end; i++) {
       int code = charCodes[i];
       if (code is! _Smi) throw new ArgumentError(charCodes);
       bits |= code;
     }
     return bits;
   }
 
-  static String _createStringFromIterable(
-      Iterable<int> charCodes, int start, int end) {
+  static String _createStringFromIterable(Iterable<int> charCodes,
+                                          int start, int end) {
     // Treat charCodes as Iterable.
     if (charCodes is EfficientLengthIterable) {
       int length = charCodes.length;
       end = RangeError.checkValidRange(start, end, length);
-      List charCodeList =
-          new List.from(charCodes.take(end).skip(start), growable: false);
+      List charCodeList = new List.from(charCodes.take(end).skip(start),
+                                        growable: false);
       return createFromCharCodes(charCodeList, 0, charCodeList.length, null);
     }
     // Don't know length of iterable, so iterate and see if all the values
     // are there.
     if (start < 0) throw new RangeError.range(start, 0, charCodes.length);
     var it = charCodes.iterator;
     for (int i = 0; i < start; i++) {
       if (!it.moveNext()) {
         throw new RangeError.range(start, 0, i);
       }
     }
     List charCodeList;
-    int bits = 0; // Bitwise-or of all char codes in list.
+    int bits = 0;  // Bitwise-or of all char codes in list.
     if (end == null) {
       var list = [];
       while (it.moveNext()) {
         int code = it.current;
         bits |= code;
         list.add(code);
       }
       charCodeList = makeListFixedLength(list);
     } else {
       if (end < start) {
@@ skipping 29 matching lines @@
       s._setAt(i, charCodes[start + i]);
     }
     return s;
   }
 
   static String _createFromCodePoints(List<int> codePoints, int start, int end)
       native "StringBase_createFromCodePoints";
 
   String operator [](int index) native "String_charAt";
 
-  int codeUnitAt(int index); // Implemented in the subclasses.
+  int codeUnitAt(int index);  // Implemented in the subclasses.
 
   int get length native "String_getLength";
 
   bool get isEmpty {
     return this.length == 0;
   }
 
   bool get isNotEmpty => !isEmpty;
 
   String operator +(String other) native "String_concat";
 
   String toString() {
     return this;
   }
 
   bool operator ==(Object other) {
     if (identical(this, other)) {
       return true;
     }
-    if ((other is! String) || (this.length != other.length)) {
+    if ((other is! String) ||
+        (this.length != other.length)) {
       return false;
     }
     final len = this.length;
     for (int i = 0; i < len; i++) {
       if (this.codeUnitAt(i) != other.codeUnitAt(i)) {
         return false;
       }
     }
     return true;
   }
@@ skipping 125 matching lines @@
     }
     return _substringUncheckedNative(startIndex, endIndex);
   }
 
   String _substringUncheckedNative(int startIndex, int endIndex)
       native "StringBase_substringUnchecked";
 
   // Checks for one-byte whitespaces only.
   static bool _isOneByteWhitespace(int codeUnit) {
     if (codeUnit <= 32) {
-      return ((codeUnit == 32) || // Space.
-          ((codeUnit <= 13) && (codeUnit >= 9))); // CR, LF, TAB, etc.
+      return ((codeUnit == 32) ||  // Space.
+              ((codeUnit <= 13) && (codeUnit >= 9)));  // CR, LF, TAB, etc.
     }
-    return (codeUnit == 0x85) || (codeUnit == 0xA0); // NEL, NBSP.
+    return (codeUnit == 0x85) || (codeUnit == 0xA0);  // NEL, NBSP.
   }
 
   // Characters with Whitespace property (Unicode 6.2).
   // 0009..000D    ; White_Space # Cc       <control-0009>..<control-000D>
   // 0020          ; White_Space # Zs       SPACE
   // 0085          ; White_Space # Cc       <control-0085>
   // 00A0          ; White_Space # Zs       NO-BREAK SPACE
   // 1680          ; White_Space # Zs       OGHAM SPACE MARK
   // 180E          ; White_Space # Zs       MONGOLIAN VOWEL SEPARATOR
   // 2000..200A    ; White_Space # Zs       EN QUAD..HAIR SPACE
   // 2028          ; White_Space # Zl       LINE SEPARATOR
   // 2029          ; White_Space # Zp       PARAGRAPH SEPARATOR
   // 202F          ; White_Space # Zs       NARROW NO-BREAK SPACE
   // 205F          ; White_Space # Zs       MEDIUM MATHEMATICAL SPACE
   // 3000          ; White_Space # Zs       IDEOGRAPHIC SPACE
   //
   // BOM: 0xFEFF
   static bool _isTwoByteWhitespace(int codeUnit) {
     if (codeUnit <= 32) {
-      return (codeUnit == 32) || ((codeUnit <= 13) && (codeUnit >= 9));
+      return (codeUnit == 32) ||
+             ((codeUnit <= 13) && (codeUnit >= 9));
     }
     if (codeUnit < 0x85) return false;
     if ((codeUnit == 0x85) || (codeUnit == 0xA0)) return true;
     return (codeUnit <= 0x200A)
-        ? ((codeUnit == 0x1680) || (codeUnit == 0x180E) || (0x2000 <= codeUnit))
-        : ((codeUnit == 0x2028) ||
-            (codeUnit == 0x2029) ||
-            (codeUnit == 0x202F) ||
-            (codeUnit == 0x205F) ||
-            (codeUnit == 0x3000) ||
-            (codeUnit == 0xFEFF));
+            ? ((codeUnit == 0x1680) ||
+               (codeUnit == 0x180E) ||
+               (0x2000 <= codeUnit))
+            : ((codeUnit == 0x2028) ||
+               (codeUnit == 0x2029) ||
+               (codeUnit == 0x202F) ||
+               (codeUnit == 0x205F) ||
+               (codeUnit == 0x3000) ||
+               (codeUnit == 0xFEFF));
   }
 
   int _firstNonWhitespace() {
     final len = this.length;
     int first = 0;
     for (; first < len; first++) {
       if (!_isWhitespace(this.codeUnitAt(first))) {
         break;
       }
     }
@@ skipping 58 matching lines @@
       // String contains only whitespaces.
       return "";
     }
     if (last == (len - 1)) {
       // Returns this string since it does not have trailing whitespaces.
       return this;
     }
     return _substringUnchecked(0, last + 1);
   }
 
-  String operator *(int times) {
+  String operator*(int times) {
     if (times <= 0) return "";
     if (times == 1) return this;
     StringBuffer buffer = new StringBuffer(this);
     for (int i = 1; i < times; i++) {
       buffer.write(this);
     }
     return buffer.toString();
   }
 
   String padLeft(int width, [String padding = ' ']) {
@@ skipping 20 matching lines @@
   bool contains(Pattern pattern, [int startIndex = 0]) {
     if (pattern is String) {
       if (startIndex < 0 || startIndex > this.length) {
         throw new RangeError.range(startIndex, 0, this.length);
       }
       return indexOf(pattern, startIndex) >= 0;
     }
     return pattern.allMatches(this.substring(startIndex)).isNotEmpty;
   }
 
-  String replaceFirst(Pattern pattern, String replacement,
-      [int startIndex = 0]) {
+  String replaceFirst(Pattern pattern,
+                      String replacement,
+                      [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");
-    Iterator iterator = startIndex == 0
-        ? pattern.allMatches(this).iterator
-        : pattern.allMatches(this, startIndex).iterator;
+    Iterator iterator =
+        startIndex == 0 ? pattern.allMatches(this).iterator
+                        : pattern.allMatches(this, startIndex).iterator;
     if (!iterator.moveNext()) return this;
     Match match = iterator.current;
     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;
     if (start == 0 && end == length) return replacement;
     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);
+    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 24 matching lines @@
       }
     }
     length += _addReplaceSlice(matches, startIndex, this.length);
     bool replacementIsOneByte = replacement._isOneByte;
     if (replacementIsOneByte &&
         length < _maxJoinReplaceOneByteStringLength &&
         this._isOneByte) {
       // TODO(lrn): Is there a cut-off point, or is runtime always faster?
       return _joinReplaceAllOneByteResult(this, matches, length);
     }
-    return _joinReplaceAllResult(this, matches, length, replacementIsOneByte);
+    return _joinReplaceAllResult(this, matches, length,
+                                 replacementIsOneByte);
   }
 
   /**
    * As [_joinReplaceAllResult], but knowing that the result
    * is always a [_OneByteString].
    */
-  static String _joinReplaceAllOneByteResult(
-      String base, List matches, int length) {
+  static String _joinReplaceAllOneByteResult(String base,
+                                             List matches,
+                                             int length) {
     _OneByteString result = _OneByteString._allocate(length);
     int writeIndex = 0;
     for (int i = 0; i < matches.length; i++) {
       var entry = matches[i];
       if (entry is _Smi) {
         int sliceStart = entry;
         int sliceEnd;
         if (sliceStart < 0) {
           int bits = -sliceStart;
           int sliceLength = bits & _lengthMask;
@@ skipping 26 matching lines @@
    * Combine the results of a [replaceAll] match into a new string.
    *
    * The [matches] lists contains Smi index pairs representing slices of
    * [base] and [String]s to be put in between the slices.
    *
    * The total [length] of the resulting string is known, as is
    * whether the replacement strings are one-byte strings.
    * If they are, then we have to check the base string slices to know
    * whether the result must be a one-byte string.
    */
-  static String
-      _joinReplaceAllResult(String base, List matches, int length,
-          bool replacementStringsAreOneByte)
+  static String _joinReplaceAllResult(String base, List matches, int length,
+                                      bool replacementStringsAreOneByte)
       native "StringBase_joinReplaceAllResult";
 
   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)}";
       matches.add(replacement);
       length += replacement.length;
       replacementStringsAreOneByte =
           replacementStringsAreOneByte && replacement._isOneByte;
       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);
     }
-    return _joinReplaceAllResult(
-        this, matches, length, replacementStringsAreOneByte);
+    return _joinReplaceAllResult(this, matches, length,
+                                 replacementStringsAreOneByte);
   }
 
   String replaceFirstMapped(Pattern pattern, String replace(Match match),
-      [int startIndex = 0]) {
+                            [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)}";
     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)) {
+  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(""));
     while (i < length) {
       buffer.write(onMatch(new _StringMatch(i, this, "")));
       // Special case to avoid splitting a surrogate pair.
       int code = this.codeUnitAt(i);
       if ((code & ~0x3FF) == 0xD800 && length > i + 1) {
         // Leading surrogate;
         code = this.codeUnitAt(i + 1);
         if ((code & ~0x3FF) == 0xDC00) {
           // Matching trailing surrogate.
           buffer.write(onNonMatch(this.substring(i, i + 2)));
           i += 2;
           continue;
         }
       }
       buffer.write(onNonMatch(this[i]));
       i++;
     }
     buffer.write(onMatch(new _StringMatch(i, this, "")));
     buffer.write(onNonMatch(""));
     return buffer.toString();
   }
 
   String splitMapJoin(Pattern pattern,
-      {String onMatch(Match match), String onNonMatch(String nonMatch)}) {
+                      {String onMatch(Match match),
+                       String onNonMatch(String nonMatch)}) {
     if (pattern is! Pattern) {
       throw new ArgumentError("${pattern} is not a Pattern");
     }
     if (onMatch == null) onMatch = _matchString;
     if (onNonMatch == null) onNonMatch = _stringIdentity;
     if (pattern is String) {
       String stringPattern = pattern;
       if (stringPattern.isEmpty) {
         return _splitMapJoinEmptyString(onMatch, onNonMatch);
       }
@@ skipping 98 matching lines @@
         result.add(this.substring(previousIndex, length));
         break;
       }
       Match match = iterator.current;
       if (match.start == length) {
         result.add(this.substring(previousIndex, length));
         break;
       }
       int endIndex = match.end;
       if (startIndex == endIndex && endIndex == previousIndex) {
-        ++startIndex; // empty match, advance and restart
+        ++startIndex;  // empty match, advance and restart
         continue;
       }
       result.add(this.substring(previousIndex, match.start));
       startIndex = previousIndex = endIndex;
     }
     return result;
   }
 
   List<int> get codeUnits => new CodeUnits(this);
 
@@ skipping 11 matching lines @@
     }
     return _concatRangeNative(strings, start, end);
   }
 
   // Call this method if not all list elements are known to be OneByteString(s).
   // 'strings' must be an _List or _GrowableList.
   static String _concatRangeNative(List<String> strings, int start, int end)
       native "String_concatRange";
 }
 
+
 class _OneByteString extends _StringBase implements String {
+
   factory _OneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_OneByteString can only be allocated by the VM");
   }
 
   int get hashCode native "String_getHashCode";
 
   int codeUnitAt(int index) native "String_codeUnitAt";
 
   bool _isWhitespace(int codeUnit) {
@@ skipping 76 matching lines @@
           if (this.codeUnitAt(i) == patternCu0) {
             return true;
           }
         }
         return false;
       }
     }
     return super.contains(pattern, start);
   }
 
-  String operator *(int times) {
+  String operator*(int times) {
     if (times <= 0) return "";
     if (times == 1) return this;
     int length = this.length;
-    if (this.isEmpty) return this; // Don't clone empty string.
+    if (this.isEmpty) return this;  // Don't clone empty string.
     _OneByteString result = _OneByteString._allocate(length * times);
     int index = 0;
-    for (int i = 0; i < times; i++) {
+    for (int i = 0; i < times; i ++) {
       for (int j = 0; j < length; j++) {
         result._setAt(index++, this.codeUnitAt(j));
       }
     }
     return result;
   }
 
   String padLeft(int width, [String padding = ' ']) {
     int padCid = ClassID.getID(padding);
     if ((padCid != ClassID.cidOneByteString) &&
@@ skipping 147 matching lines @@
       }
       return result;
     }
     return this;
   }
 
   // Allocates a string of given length, expecting its content to be
   // set using _setAt.
   static _OneByteString _allocate(int length) native "OneByteString_allocate";
 
-  static _OneByteString _allocateFromOneByteList(List<int> list, int start,
-      int end) native "OneByteString_allocateFromOneByteList";
+
+  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)
       native "TwoByteString_allocateFromTwoByteList";
 
   bool _isWhitespace(int codeUnit) {
     return _StringBase._isTwoByteWhitespace(codeUnit);
   }
 
   int codeUnitAt(int index) native "String_codeUnitAt";
 
   bool operator ==(Object other) {
     return super == other;
   }
 }
 
+
 class _ExternalOneByteString extends _StringBase implements String {
   factory _ExternalOneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalOneByteString can only be allocated by the VM");
   }
 
   bool _isWhitespace(int codeUnit) {
     return _StringBase._isOneByteWhitespace(codeUnit);
   }
 
   int codeUnitAt(int index) native "String_codeUnitAt";
 
   bool operator ==(Object other) {
     return super == other;
   }
 
   static int _getCid() native "ExternalOneByteString_getCid";
 }
 
+
 class _ExternalTwoByteString extends _StringBase implements String {
   factory _ExternalTwoByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalTwoByteString can only be allocated by the VM");
   }
 
   bool _isWhitespace(int codeUnit) {
     return _StringBase._isTwoByteWhitespace(codeUnit);
   }
 
   int codeUnitAt(int index) native "String_codeUnitAt";
 
   bool operator ==(Object other) {
     return super == other;
   }
 }
 
+
 class _StringMatch implements Match {
   const _StringMatch(this.start, this.input, this.pattern);
 
   int get end => start + pattern.length;
-  String operator [](int g) => group(g);
+  String operator[](int g) => group(g);
   int get groupCount => 0;
 
   String group(int group) {
     if (group != 0) {
       throw new RangeError.value(group);
     }
     return pattern;
   }
 
   List<String> groups(List<int> groups) {
     List<String> result = new List<String>();
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String input;
   final String pattern;
 }
 
+
 class _StringAllMatchesIterable extends Iterable<Match> {
   final String _input;
   final String _pattern;
   final int _index;
 
   _StringAllMatchesIterable(this._input, this._pattern, this._index);
 
   Iterator<Match> get iterator =>
       new _StringAllMatchesIterator(_input, _pattern, _index);
 
@@ skipping 28 matching lines @@
     int end = index + _pattern.length;
     _current = new _StringMatch(index, _input, _pattern);
     // Empty match, don't start at same location again.
     if (end == _index) end++;
     _index = end;
     return true;
   }
 
   Match get current => _current;
 }