Format all dart dev compiler files

pkg/dev_compiler/tool/input_sdk/patch/math_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.
 
 // Patch file for dart:math library.
 import 'dart:_foreign_helper' show JS;
 import 'dart:_js_helper' show patch, checkNum;
 import 'dart:typed_data' show ByteData;
 
 @patch
-num/*=T*/ min/*<T extends num>*/(num/*=T*/ a, num/*=T*/ b)
-  => JS('num', r'Math.min(#, #)', checkNum(a), checkNum(b)) as num/*=T*/;
+num/*=T*/ min/*<T extends num>*/(num/*=T*/ a, num/*=T*/ b) =>
+    JS('num', r'Math.min(#, #)', checkNum(a), checkNum(b)) as num/*=T*/;
 
 @patch
-num/*=T*/ max/*<T extends num>*/(num/*=T*/ a, num/*=T*/ b)
-  => JS('num', r'Math.max(#, #)', checkNum(a), checkNum(b)) as num/*=T*/;
+num/*=T*/ max/*<T extends num>*/(num/*=T*/ a, num/*=T*/ b) =>
+    JS('num', r'Math.max(#, #)', checkNum(a), checkNum(b)) as num/*=T*/;
 
 @patch
-double sqrt(num x)
-  => JS('num', r'Math.sqrt(#)', checkNum(x));
+double sqrt(num x) => JS('num', r'Math.sqrt(#)', checkNum(x));
 
 @patch
-double sin(num x)
-  => JS('num', r'Math.sin(#)', checkNum(x));
+double sin(num x) => JS('num', r'Math.sin(#)', checkNum(x));
 
 @patch
-double cos(num x)
-  => JS('num', r'Math.cos(#)', checkNum(x));
+double cos(num x) => JS('num', r'Math.cos(#)', checkNum(x));
 
 @patch
-double tan(num x)
-  => JS('num', r'Math.tan(#)', checkNum(x));
+double tan(num x) => JS('num', r'Math.tan(#)', checkNum(x));
 
 @patch
-double acos(num x)
-  => JS('num', r'Math.acos(#)', checkNum(x));
+double acos(num x) => JS('num', r'Math.acos(#)', checkNum(x));
 
 @patch
-double asin(num x)
-  => JS('num', r'Math.asin(#)', checkNum(x));
+double asin(num x) => JS('num', r'Math.asin(#)', checkNum(x));
 
 @patch
-double atan(num x)
-  => JS('num', r'Math.atan(#)', checkNum(x));
+double atan(num x) => JS('num', r'Math.atan(#)', checkNum(x));
 
 @patch
-double atan2(num a, num b)
-  => JS('num', r'Math.atan2(#, #)', checkNum(a), checkNum(b));
+double atan2(num a, num b) =>
+    JS('num', r'Math.atan2(#, #)', checkNum(a), checkNum(b));
 
 @patch
-double exp(num x)
-  => JS('num', r'Math.exp(#)', checkNum(x));
+double exp(num x) => JS('num', r'Math.exp(#)', checkNum(x));
 
 @patch
-double log(num x)
-  => JS('num', r'Math.log(#)', checkNum(x));
+double log(num x) => JS('num', r'Math.log(#)', checkNum(x));
 
 @patch
 num pow(num x, num exponent) {
   checkNum(x);
   checkNum(exponent);
   return JS('num', r'Math.pow(#, #)', x, exponent);
 }
 
 const int _POW2_32 = 0x100000000;
 
@@ skipping 25 matching lines @@
    * the range from 0.0, inclusive, to 1.0, exclusive.
    */
   double nextDouble() => JS("double", "Math.random()");
 
   /**
    * Generates a random boolean value.
    */
   bool nextBool() => JS("bool", "Math.random() < 0.5");
 }
 
-
 class _Random implements Random {
   // Constants used by the algorithm or masking.
   static const double _POW2_53_D = 1.0 * (0x20000000000000);
   static const double _POW2_27_D = 1.0 * (1 << 27);
   static const int _MASK32 = 0xFFFFFFFF;
 
   // State comprised of two unsigned 32 bit integers.
   int _lo = 0;
   int _hi = 0;
 
@@ skipping 82 matching lines @@
   // http://en.wikipedia.org/wiki/Multiply-with-carry
   // The constant A (0xFFFFDA61) is selected from "Numerical Recipes 3rd
   // Edition" p.348 B1.
 
   // Implements:
   //   var state = (A * _lo + _hi) & _MASK_64;
   //   _lo = state & _MASK_32;
   //   _hi = state >> 32;
   void _nextState() {
     // Simulate (0xFFFFDA61 * lo + hi) without overflowing 53 bits.
-    int tmpHi = 0xFFFF0000 * _lo;  // At most 48 bits of significant result.
-    int tmpHiLo = tmpHi & _MASK32;             // Get the lower 32 bits.
-    int tmpHiHi = tmpHi - tmpHiLo;            // And just the upper 32 bits.
+    int tmpHi = 0xFFFF0000 * _lo; // At most 48 bits of significant result.
+    int tmpHiLo = tmpHi & _MASK32; // Get the lower 32 bits.
+    int tmpHiHi = tmpHi - tmpHiLo; // And just the upper 32 bits.
     int tmpLo = 0xDA61 * _lo;
     int tmpLoLo = tmpLo & _MASK32;
     int tmpLoHi = tmpLo - tmpLoLo;
 
     int newLo = tmpLoLo + tmpHiLo + _hi;
     _lo = newLo & _MASK32;
     int newLoHi = newLo - _lo;
     _hi = ((tmpLoHi + tmpHiHi + newLoHi) ~/ _POW2_32) & _MASK32;
     assert(_lo < _POW2_32);
     assert(_hi < _POW2_32);
@@ skipping 26 matching lines @@
     int bits27 = _lo & ((1 << 27) - 1);
     return (bits26 * _POW2_27_D + bits27) / _POW2_53_D;
   }
 
   bool nextBool() {
     _nextState();
     return (_lo & 1) == 0;
   }
 }
 
-
 class _JSSecureRandom implements Random {
   // Reused buffer with room enough for a double.
   final _buffer = new ByteData(8);
 
   _JSSecureRandom() {
     var crypto = JS("", "self.crypto");
     if (crypto != null) {
       var getRandomValues = JS("", "#.getRandomValues", crypto);
       if (getRandomValues != null) {
         return;
       }
     }
     throw new UnsupportedError(
         "No source of cryptographically secure random numbers available.");
   }
 
   /// Fill _buffer from [start] to `start + length` with random bytes.
   void _getRandomBytes(int start, int length) {
     JS("void", "crypto.getRandomValues(#)",
-       _buffer.buffer.asUint8List(start, length));
+        _buffer.buffer.asUint8List(start, length));
   }
 
   bool nextBool() {
     _getRandomBytes(0, 1);
     return _buffer.getUint8(0).isOdd;
   }
 
   double nextDouble() {
     _getRandomBytes(1, 7);
     // Set top bits 12 of double to 0x3FF which is the exponent for numbers
     // between 1.0 and 2.0.
     _buffer.setUint8(0, 0x3F);
     int highByte = _buffer.getUint8(1);
     _buffer.setUint8(1, highByte | 0xF0);
 
     // Buffer now contains double in the range [1.0-2.0)
     // with 52 bits of entropy (not 53).
     // To get 53 bits, we extract the 53rd bit from higthByte before
     // overwriting it, and add that as a least significant bit.
     // The getFloat64 method is big-endian as default.
     double result = _buffer.getFloat64(0) - 1.0;
     if (highByte & 0x10 != 0) {
-      result += 1.1102230246251565e-16;  // pow(2,-53).
+      result += 1.1102230246251565e-16; // pow(2,-53).
     }
     return result;
   }
 
   int nextInt(int max) {
     if (max <= 0 || max > _POW2_32) {
       throw new RangeError("max must be in range 0 < max ≤ 2^32, was $max");
     }
     int byteCount = 1;
     if (max > 0xFF) {
@@ skipping 21 matching lines @@
       // last range of k*max .. 256**byteCount.
       // TODO: Consider picking a higher byte count if the last range is a
       // significant portion of the entire range - a 50% chance of having
       // to use two more bytes is no worse than always using one more.
       if (random - result + max < randomLimit) {
         return result;
       }
     }
   }
 }