Optimize DDC private library 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:_js_helper' show patch, nullCheck, notNull;
 import 'dart:typed_data' show ByteData;
 
 @patch
-T min<T extends num>(T a, T b) =>
-    JS('num', r'Math.min(#, #)', checkNum(a), checkNum(b)) as T;
+T min<T extends num>(@nullCheck T a, @nullCheck T b) =>

[Jennifer Messerly, 2017/08/22 21:54:41]

add @nonNull here?

while T could be Null, it will throw before it returns a value

[Leaf, 2017/08/23 17:26:13]

Done.

+    JS('-dynamic', r'Math.min(#, #)', a, b);

[Jennifer Messerly, 2017/08/22 21:54:41]

Question: if you could use

    JS<T>('', r'Math.min(#, #)', a, b);

would you?


basically adding a generic type so we can annotate results (and it will get
inferred too)

we'd still have to decide what it means w.r.t. null. I think by default non-null
and if you want nullable, you could write:

    JS<T>('Null', r'Math.min(#, #)', a, b);

... which implies a union type T|Null

[Leaf, 2017/08/23 17:26:13]

Yes, this could be good to do in some way.  The `-dynamic` thing works, but it's
a little hinky - we need to be sure not to do anything too tricky like use the
fact that something is typed as returning bottom to elide subsequent code or
somesuch without reconsidering this.

 
 @patch
-T max<T extends num>(T a, T b) =>
-    JS('num', r'Math.max(#, #)', checkNum(a), checkNum(b)) as T;
+T max<T extends num>(@nullCheck T a, @nullCheck T b) =>

[Jennifer Messerly, 2017/08/22 21:54:41]

add @nonNull here?

[Leaf, 2017/08/23 17:26:13]

Done.

+    JS('-dynamic', r'Math.max(#, #)', a, b);
 
 @patch
-double sqrt(num x) => JS('num', r'Math.sqrt(#)', checkNum(x));
+@notNull
+double sqrt(@nullCheck num x) => JS('num', r'Math.sqrt(#)', x);
 
 @patch
-double sin(num radians) => JS('num', r'Math.sin(#)', checkNum(radians));
+@notNull
+double sin(@nullCheck num radians) => JS('num', r'Math.sin(#)', radians);
 
 @patch
-double cos(num radians) => JS('num', r'Math.cos(#)', checkNum(radians));
+@notNull
+double cos(@nullCheck num radians) => JS('num', r'Math.cos(#)', radians);
 
 @patch
-double tan(num radians) => JS('num', r'Math.tan(#)', checkNum(radians));
+@notNull
+double tan(@nullCheck num radians) => JS('num', r'Math.tan(#)', radians);
 
 @patch
-double acos(num x) => JS('num', r'Math.acos(#)', checkNum(x));
+@notNull
+double acos(@nullCheck num x) => JS('num', r'Math.acos(#)', x);
 
 @patch
-double asin(num x) => JS('num', r'Math.asin(#)', checkNum(x));
+@notNull
+double asin(@nullCheck num x) => JS('num', r'Math.asin(#)', x);
 
 @patch
-double atan(num x) => JS('num', r'Math.atan(#)', checkNum(x));
+@notNull
+double atan(@nullCheck num x) => JS('num', r'Math.atan(#)', x);
 
 @patch
-double atan2(num a, num b) =>
-    JS('num', r'Math.atan2(#, #)', checkNum(a), checkNum(b));
+@notNull
+double atan2(@nullCheck num a, @nullCheck num b) =>
+    JS('num', r'Math.atan2(#, #)', a, b);
 
 @patch
-double exp(num x) => JS('num', r'Math.exp(#)', checkNum(x));
+@notNull
+double exp(@nullCheck num x) => JS('num', r'Math.exp(#)', x);
 
 @patch
-double log(num x) => JS('num', r'Math.log(#)', checkNum(x));
+@notNull
+double log(@nullCheck num x) => JS('num', r'Math.log(#)', x);
 
 @patch
-num pow(num x, num exponent) {
-  checkNum(x);
-  checkNum(exponent);
-  return JS('num', r'Math.pow(#, #)', x, exponent);
-}
+@notNull
+num pow(@nullCheck num x, @nullCheck num exponent) =>
+    JS('num', r'Math.pow(#, #)', x, exponent);
 
 const int _POW2_32 = 0x100000000;
 
 @patch
 class Random {
   static final _secureRandom = new _JSSecureRandom();
 
   @patch
   factory Random([int seed]) =>
       (seed == null) ? const _JSRandom() : new _Random(seed);
 
   @patch
   factory Random.secure() => _secureRandom;
 }
 
 class _JSRandom implements Random {
   // The Dart2JS implementation of Random doesn't use a seed.
   const _JSRandom();
 
+  @notNull
   int nextInt(int max) {
     if (max <= 0 || max > _POW2_32) {
       throw new RangeError("max must be in range 0 < max ≤ 2^32, was $max");
     }
     return JS("int", "(Math.random() * #) >>> 0", max);
   }
 
   /**
    * Generates a positive random floating point value uniformly distributed on
    * the range from 0.0, inclusive, to 1.0, exclusive.
    */
+  @notNull
   double nextDouble() => JS("double", "Math.random()");
 
   /**
    * Generates a random boolean value.
    */
+  @notNull
   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.
+  @notNull
   int _lo = 0;
+  @notNull
   int _hi = 0;
 
   // Implements:
   //   uint64_t hash = 0;
   //   do {
   //      hash = hash * 1037 ^ mix64((uint64_t)seed);
   //      seed >>= 64;
   //   } while (seed != 0 && seed != -1);  // Limits for pos/neg seed.
   //   if (hash == 0) {
   //     hash = 0x5A17;
@@ skipping 89 matching lines @@
     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);
   }
 
-  int nextInt(int max) {
+  @notNull
+  int nextInt(@nullCheck int max) {
     if (max <= 0 || max > _POW2_32) {
       throw new RangeError("max must be in range 0 < max ≤ 2^32, was $max");
     }
     if ((max & (max - 1)) == 0) {
       // Fast case for powers of two.
       _nextState();
       return _lo & (max - 1);
     }
 
     int rnd32;
     int result;
     do {
       _nextState();
       rnd32 = _lo;
       result = rnd32.remainder(max); // % max;
     } while ((rnd32 - result + max) >= _POW2_32);
     return result;
   }
 
+  @notNull
   double nextDouble() {
     _nextState();
     int bits26 = _lo & ((1 << 26) - 1);
     _nextState();
     int bits27 = _lo & ((1 << 27) - 1);
     return (bits26 * _POW2_27_D + bits27) / _POW2_53_D;
   }
 
+  @notNull
   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));
   }
 
+  @notNull
   bool nextBool() {
     _getRandomBytes(0, 1);
     return _buffer.getUint8(0).isOdd;
   }
 
+  @notNull
   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).
     }
     return result;
   }
 
-  int nextInt(int max) {
+  @notNull
+  int nextInt(@nullCheck 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) {
       byteCount++;
       if (max > 0xFFFF) {
         byteCount++;
         if (max > 0xFFFFFF) {
           byteCount++;
@@ skipping 16 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;
       }
     }
   }
 }