Format all dart dev compiler files

pkg/dev_compiler/tool/input_sdk/private/js_number.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 dart._interceptors;
 
 /**
  * The implementation of Dart's int & double methods.
  * These are made available as extension methods on `Number` in JS.
  */
@@ skipping 22 matching lines @@
     } else {
       return -1;
     }
   }
 
   bool get isNegative => (this == 0) ? (1 / this) < 0 : this < 0;
 
   bool get isNaN => JS('bool', r'isNaN(#)', this);
 
   bool get isInfinite {
-    return JS('bool', r'# == (1/0)', this)
-        || JS('bool', r'# == (-1/0)', this);
+    return JS('bool', r'# == (1/0)', this) || JS('bool', r'# == (-1/0)', this);
   }
 
   bool get isFinite => JS('bool', r'isFinite(#)', this);
 
   JSNumber remainder(num b) {
     if (b is! num) throw argumentErrorValue(b);
     return JS('num', r'# % #', this, b);
   }
 
   JSNumber abs() => JS('num', r'Math.abs(#)', this);
 
   JSNumber get sign => this > 0 ? 1 : this < 0 ? -1 : this;
 
   static const int _MIN_INT32 = -0x80000000;
   static const int _MAX_INT32 = 0x7FFFFFFF;
 
   int toInt() {
     if (this >= _MIN_INT32 && this <= _MAX_INT32) {
       return JS('int', '# | 0', this);
     }
     if (JS('bool', r'isFinite(#)', this)) {
-      return JS('int', r'# + 0', truncateToDouble());  // Converts -0.0 to +0.0.
+      return JS('int', r'# + 0', truncateToDouble()); // Converts -0.0 to +0.0.
     }
     // This is either NaN, Infinity or -Infinity.
     throw new UnsupportedError(JS("String", '"" + #', this));
   }
 
   int truncate() => toInt();
 
   int ceil() => ceilToDouble().toInt();
 
   int floor() => floorToDouble().toInt();
@@ skipping 65 matching lines @@
     }
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toStringAsPrecision(int precision) {
     checkInt(precision);
     if (precision < 1 || precision > 21) {
       throw new RangeError.range(precision, 1, 21, "precision");
     }
-    String result = JS('String', r'#.toPrecision(#)',
-                       this, precision);
+    String result = JS('String', r'#.toPrecision(#)', this, precision);
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toRadixString(int radix) {
     checkInt(radix);
     if (radix < 2 || radix > 36) {
       throw new RangeError.range(radix, 2, 36, "radix");
     }
     String result = JS('String', r'#.toString(#)', this, radix);
     const int rightParenCode = 0x29;
     if (result.codeUnitAt(result.length - 1) != rightParenCode) {
       return result;
     }
     return _handleIEtoString(result);
   }
 
   static String _handleIEtoString(String result) {
     // Result is probably IE's untraditional format for large numbers,
     // e.g., "8.0000000000008(e+15)" for 0x8000000000000800.toString(16).
     var match = JS('List|Null',
-                   r'/^([\da-z]+)(?:\.([\da-z]+))?\(e\+(\d+)\)$/.exec(#)',
-                   result);
+        r'/^([\da-z]+)(?:\.([\da-z]+))?\(e\+(\d+)\)$/.exec(#)', result);
     if (match == null) {
       // Then we don't know how to handle it at all.
       throw new UnsupportedError("Unexpected toString result: $result");
     }
     result = JS('String', '#', match[1]);
     int exponent = JS("int", "+#", match[3]);
     if (match[2] != null) {
       result = JS('String', '# + #', result, match[2]);
       exponent -= JS('int', '#.length', match[2]);
     }
     return result + "0" * exponent;
   }
 
   // Note: if you change this, also change the function [S].
   String toString() {
     if (this == 0 && JS('bool', '(1 / #) < 0', this)) {
       return '-0.0';
     } else {
       return JS('String', r'"" + (#)', this);
     }
   }
 
   int get hashCode => JS('int', '# & 0x1FFFFFFF', this);
 
   JSNumber operator -() => JS('num', r'-#', this);
 
   JSNumber operator +(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('num', '# + #', this, other);
   }
 
   JSNumber operator -(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('num', '# - #', this, other);
   }
 
   double operator /(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('num', '# / #', this, other);
   }
 
   JSNumber operator *(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('num', '# * #', this, other);
   }
 
   JSNumber operator %(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     // Euclidean Modulo.
     num result = JS('num', r'# % #', this, other);
-    if (result == 0) return (0 as JSNumber);  // Make sure we don't return -0.0.
+    if (result == 0) return (0 as JSNumber); // Make sure we don't return -0.0.
     if (result > 0) return result;
     if (JS('num', '#', other) < 0) {
       return result - JS('num', '#', other);
     } else {
       return result + JS('num', '#', other);
     }
   }
 
   bool _isInt32(value) => JS('bool', '(# | 0) === #', value, value);
 
   int operator ~/(num other) {
     if (_isInt32(this) && _isInt32(other) && 0 != other && -1 != other) {
       return JS('int', r'(# / #) | 0', this, other);
     } else {
       return _tdivSlow(other);
     }
   }
 
   int _tdivSlow(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return (JS('num', r'# / #', this, other)).toInt();
   }
 
   // TODO(ngeoffray): Move the bit operations below to [JSInt] and
   // make them take an int. Because this will make operations slower,
   // we define these methods on number for now but we need to decide
   // the grain at which we do the type checks.
 
   int operator <<(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     if (JS('num', '#', other) < 0) throw argumentErrorValue(other);
     return _shlPositive(other);
   }
 
   int _shlPositive(num other) {
     // JavaScript only looks at the last 5 bits of the shift-amount. Shifting
     // by 33 is hence equivalent to a shift by 1.
     return JS('bool', r'# > 31', other)
         ? 0
         : JS('int', r'(# << #) >>> 0', this, other);
   }
 
   int operator >>(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     if (JS('num', '#', other) < 0) throw argumentErrorValue(other);
     return _shrOtherPositive(other);
   }
 
   int _shrOtherPositive(num other) {
     return JS('num', '#', this) > 0
         ? _shrBothPositive(other)
         // For negative numbers we just clamp the shift-by amount.
         // `this` could be negative but not have its 31st bit set.
         // The ">>" would then shift in 0s instead of 1s. Therefore
         // we cannot simply return 0xFFFFFFFF.
         : JS('int', r'(# >> #) >>> 0', this, other > 31 ? 31 : other);
   }
 
   int _shrBothPositive(num other) {
     return JS('bool', r'# > 31', other)
         // JavaScript only looks at the last 5 bits of the shift-amount. In JS
         // shifting by 33 is hence equivalent to a shift by 1. Shortcut the
         // computation when that happens.
         ? 0
         // Given that `this` is positive we must not use '>>'. Otherwise a
         // number that has the 31st bit set would be treated as negative and
         // shift in ones.
         : JS('int', r'# >>> #', this, other);
   }
 
   int operator &(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('int', r'(# & #) >>> 0', this, other);
   }
 
   int operator |(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('int', r'(# | #) >>> 0', this, other);
   }
 
   int operator ^(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('int', r'(# ^ #) >>> 0', this, other);
   }
 
   bool operator <(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('bool', '# < #', this, other);
   }
 
   bool operator >(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('bool', '# > #', this, other);
   }
 
   bool operator <=(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('bool', '# <= #', this, other);
   }
 
   bool operator >=(num other) {
-    if (other is !num) throw argumentErrorValue(other);
+    if (other is! num) throw argumentErrorValue(other);
     return JS('bool', '# >= #', this, other);
   }
 
   // int members.
   // TODO(jmesserly): all numbers will have these in dynamic dispatch.
   // We can fix by checking it at dispatch time but we'd need to structure them
   // differently.
 
   bool get isEven => (this & 1) == 0;
 
@@ skipping 56 matching lines @@
       }
       if (y.isOdd) {
         var t = x;
         x = y;
         y = t;
       }
     }
     final bool ac = x.isEven;
     int u = x;
     int v = y;
-    int a = 1,
-        b = 0,
-        c = 0,
-        d = 1;
+    int a = 1, b = 0, c = 0, d = 1;
     do {
       while (u.isEven) {
         u ~/= 2;
         if (ac) {
           if (!a.isEven || !b.isEven) {
             a += y;
             b -= x;
           }
           a ~/= 2;
         } else if (!b.isEven) {
@@ skipping 17 matching lines @@
       if (u >= v) {
         u -= v;
         if (ac) a -= c;
         b -= d;
       } else {
         v -= u;
         if (ac) c -= a;
         d -= b;
       }
     } while (u != 0);
-    if (!inv) return s*v;
+    if (!inv) return s * v;
     if (v != 1) throw new Exception("Not coprime");
     if (d < 0) {
       d += x;
       if (d < 0) d += x;
     } else if (d > x) {
       d -= x;
       if (d > x) d -= x;
     }
     return d;
   }
@@ skipping 63 matching lines @@
     i = _ors(i, _shrs(i, 1));
     i = _ors(i, _shrs(i, 2));
     i = _ors(i, _shrs(i, 4));
     i = _ors(i, _shrs(i, 8));
     i = _shru(_ors(i, _shrs(i, 16)), 0);
     return i;
   }
 
   int operator ~() => JS('int', r'(~#) >>> 0', this);
 }