Format all dart: library files

sdk/lib/_internal/js_runtime/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
  * argument added to each member.
  */
 class JSString extends Interceptor implements String, JSIndexable {
   const JSString();
 
   @NoInline()
   int codeUnitAt(int index) {
-    if (index is !int) throw diagnoseIndexError(this, index);
+    if (index is! int) throw diagnoseIndexError(this, index);
     if (index < 0) throw diagnoseIndexError(this, index);
     return _codeUnitAt(index);
   }
 
   int _codeUnitAt(int index) {
     if (index >= length) throw diagnoseIndexError(this, index);
     return JS('JSUInt31', r'#.charCodeAt(#)', this, index);
   }
 
   Iterable<Match> allMatches(String string, [int start = 0]) {
@@ skipping 13 matching lines @@
     // TODO(lrn): See if this can be optimized.
     for (int i = 0; i < this.length; i++) {
       if (string.codeUnitAt(start + i) != this.codeUnitAt(i)) {
         return null;
       }
     }
     return new StringMatch(start, string, this);
   }
 
   String operator +(String other) {
-    if (other is !String) throw new ArgumentError.value(other);
+    if (other is! String) throw new ArgumentError.value(other);
     return JS('String', r'# + #', this, other);
   }
 
   bool endsWith(String other) {
     checkString(other);
     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)}) {
+      {String onMatch(Match match), String onNonMatch(String nonMatch)}) {
     return stringReplaceAllFuncUnchecked(this, from, onMatch, onNonMatch);
   }
 
   String replaceFirst(Pattern from, String to, [int startIndex = 0]) {
     checkString(to);
     checkInt(startIndex);
     RangeError.checkValueInInterval(startIndex, 0, this.length, "startIndex");
     return stringReplaceFirstUnchecked(this, from, to, startIndex);
   }
 
   String replaceFirstMapped(Pattern from, String replace(Match match),
-                            [int startIndex = 0]) {
+      [int startIndex = 0]) {
     checkNull(replace);
     checkInt(startIndex);
     RangeError.checkValueInInterval(startIndex, 0, this.length, "startIndex");
     return stringReplaceFirstMappedUnchecked(this, from, replace, startIndex);
   }
 
   List<String> split(Pattern pattern) {
     checkNull(pattern);
     if (pattern is String) {
       return JS('JSExtendableArray', r'#.split(#)', this, pattern);
@@ skipping 53 matching lines @@
       if (endIndex > length) return false;
       return other == JS('String', r'#.substring(#, #)', this, index, endIndex);
     }
     return pattern.matchAsPrefix(this, index) != null;
   }
 
   String substring(int startIndex, [int endIndex]) {
     checkInt(startIndex);
     if (endIndex == null) endIndex = length;
     checkInt(endIndex);
-    if (startIndex < 0 ) throw new RangeError.value(startIndex);
+    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 toLowerCase() {
-    return JS(
-        'returns:String;effects:none;depends:none;throws:null(1)',
+    return JS('returns:String;effects:none;depends:none;throws:null(1)',
         r'#.toLowerCase()', this);
   }
 
   String toUpperCase() {
-    return JS(
-        'returns:String;effects:none;depends:none;throws:null(1)',
+    return JS('returns:String;effects:none;depends:none;throws:null(1)',
         r'#.toUpperCase()', this);
   }
 
   // Characters with Whitespace property (Unicode 6.3).
   // 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
   // 2000..200A    ; White_Space # Zs       EN QUAD..HAIR SPACE
@@ skipping 158 matching lines @@
     } else {
       result = this;
       endIndex = _skipTrailingWhitespace(this, this.length);
     }
 
     if (endIndex == result.length) return result;
     if (endIndex == 0) return "";
     return JS('String', r'#.substring(#, #)', result, 0, endIndex);
   }
 
-  String operator*(int times) {
-    if (0 >= times) return '';  // Unnecessary but hoists argument type check.
+  String operator *(int times) {
+    if (0 >= times) return ''; // Unnecessary but hoists argument type check.
     if (times == 1 || this.length == 0) return this;
     if (times != JS('JSUInt32', '# >>> 0', times)) {
       // times >= 2^32. We can't create a string that big.
       throw const OutOfMemoryError();
     }
     var result = '';
     var s = this;
     while (true) {
       if (times & 1 == 1) result = s + result;
       times = JS('JSUInt31', '# >>> 1', times);
@@ skipping 67 matching lines @@
       throw new RangeError.range(startIndex, 0, this.length);
     }
     return stringContainsUnchecked(this, other, startIndex);
   }
 
   bool get isEmpty => length == 0;
 
   bool get isNotEmpty => !isEmpty;
 
   int compareTo(String other) {
-    if (other is !String) throw argumentErrorValue(other);
-    return this == other ? 0
-        : JS('bool', r'# < #', this, other) ? -1 : 1;
+    if (other is! String) throw argumentErrorValue(other);
+    return this == other ? 0 : JS('bool', r'# < #', this, other) ? -1 : 1;
   }
 
   // Note: if you change this, also change the function [S].
   String toString() => this;
 
   /**
    * This is the [Jenkins hash function][1] but using masking to keep
    * values in SMI range.
    *
    * [1]: http://en.wikipedia.org/wiki/Jenkins_hash_function
    */
   int get hashCode {
     // TODO(ahe): This method shouldn't have to use JS. Update when our
     // optimizations are smarter.
     int hash = 0;
     for (int i = 0; i < length; i++) {
       hash = 0x1fffffff & (hash + JS('int', r'#.charCodeAt(#)', this, i));
       hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
       hash = JS('int', '# ^ (# >> 6)', hash, hash);
     }
-    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) <<  3));
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = JS('int', '# ^ (# >> 11)', hash, hash);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   Type get runtimeType => String;
 
   int get length => JS('int', r'#.length', this);
 
   String operator [](int index) {
-    if (index is !int) throw diagnoseIndexError(this, index);
+    if (index is! int) throw diagnoseIndexError(this, index);
     if (index >= length || index < 0) throw diagnoseIndexError(this, index);
     return JS('String', '#[#]', this, index);
   }
 }