Tag closures with their types

lib/runtime/dart/math.js

 var math = dart.defineLibrary(math, {});
 var core = dart.import(core);
 var _js_helper = dart.lazyImport(_js_helper);
 (function(exports, core, _js_helper) {
   'use strict';
   class _JenkinsSmiHash extends core.Object {
     static combine(hash, value) {
       hash = 536870911 & dart.notNull(hash) + dart.notNull(value);
       hash = 536870911 & dart.notNull(hash) + ((524287 & dart.notNull(hash)) << 10);
       return dart.notNull(hash) ^ dart.notNull(hash) >> 6;
     }
     static finish(hash) {
       hash = 536870911 & dart.notNull(hash) + ((67108863 & dart.notNull(hash)) << 3);
       hash = dart.notNull(hash) ^ dart.notNull(hash) >> 11;
       return 536870911 & dart.notNull(hash) + ((16383 & dart.notNull(hash)) << 15);
     }
     static hash2(a, b) {
       return _JenkinsSmiHash.finish(_JenkinsSmiHash.combine(_JenkinsSmiHash.combine(0, dart.as(a, core.int)), dart.as(b, core.int)));
     }
     static hash4(a, b, c, d) {
       return _JenkinsSmiHash.finish(_JenkinsSmiHash.combine(_JenkinsSmiHash.combine(_JenkinsSmiHash.combine(_JenkinsSmiHash.combine(0, dart.as(a, core.int)), dart.as(b, core.int)), dart.as(c, core.int)), dart.as(d, core.int)));
     }
   }
+  dart.setSignature(_JenkinsSmiHash, {
+    statics: () => ({
+      combine: dart.functionType(core.int, [core.int, core.int]),
+      finish: dart.functionType(core.int, [core.int]),
+      hash2: dart.functionType(core.int, [dart.dynamic, dart.dynamic]),
+      hash4: dart.functionType(core.int, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic])
+    }),
+    names: ['combine', 'finish', 'hash2', 'hash4']
+  });
   let Point$ = dart.generic(function(T) {
     class Point extends core.Object {
       Point(x, y) {
         this.x = x;
         this.y = y;
       }
       toString() {
         return `Point(${this.x}, ${this.y})`;
       }
       ['=='](other) {
@@ skipping 24 matching lines @@
         let dy = this.y['-'](other.y);
         return sqrt(dart.notNull(dx) * dart.notNull(dx) + dart.notNull(dy) * dart.notNull(dy));
       }
       squaredDistanceTo(other) {
         dart.as(other, Point$(T));
         let dx = this.x['-'](other.x);
         let dy = this.y['-'](other.y);
         return dart.as(dart.notNull(dx) * dart.notNull(dx) + dart.notNull(dy) * dart.notNull(dy), T);
       }
     }
+    dart.setSignature(Point, {
+      methods: () => ({
+        toString: dart.functionType(core.String, []),
+        '==': dart.functionType(core.bool, [dart.dynamic]),
+        '+': dart.functionType(Point$(T), [Point$(T)]),
+        '-': dart.functionType(Point$(T), [Point$(T)]),
+        '*': dart.functionType(Point$(T), [core.num]),
+        distanceTo: dart.functionType(core.double, [Point$(T)]),
+        squaredDistanceTo: dart.functionType(T, [Point$(T)])
+      })
+    });
     return Point;
   });
   let Point = Point$();
   class Random extends core.Object {
     Random(seed) {
       if (seed === void 0)
         seed = null;
       return seed == null ? dart.const(new _JSRandom()) : new _Random(seed);
     }
   }
+  dart.setSignature(Random, {});
   let _RectangleBase$ = dart.generic(function(T) {
     class _RectangleBase extends core.Object {
       _RectangleBase() {
       }
       get right() {
         return dart.as(this.left['+'](this.width), T);
       }
       get bottom() {
         return dart.as(this.top['+'](this.height), T);
       }
@@ skipping 44 matching lines @@
       get topRight() {
         return new (Point$(T))(dart.as(this.left['+'](this.width), T), this.top);
       }
       get bottomRight() {
         return new (Point$(T))(dart.as(this.left['+'](this.width), T), dart.as(this.top['+'](this.height), T));
       }
       get bottomLeft() {
         return new (Point$(T))(this.left, dart.as(this.top['+'](this.height), T));
       }
     }
+    dart.setSignature(_RectangleBase, {
+      methods: () => ({
+        toString: dart.functionType(core.String, []),
+        '==': dart.functionType(core.bool, [dart.dynamic]),
+        intersection: dart.functionType(Rectangle$(T), [Rectangle$(T)]),
+        intersects: dart.functionType(core.bool, [Rectangle$(core.num)]),
+        boundingBox: dart.functionType(Rectangle$(T), [Rectangle$(T)]),
+        containsRectangle: dart.functionType(core.bool, [Rectangle$(core.num)]),
+        containsPoint: dart.functionType(core.bool, [Point$(core.num)])
+      })
+    });
     return _RectangleBase;
   });
   let _RectangleBase = _RectangleBase$();
   let Rectangle$ = dart.generic(function(T) {
     class Rectangle extends _RectangleBase$(T) {
       Rectangle(left, top, width, height) {
         this.left = left;
         this.top = top;
         this.width = dart.as(width['<'](0) ? dart.notNull(width['unary-']()) * 0 : width, T);
         this.height = dart.as(height['<'](0) ? dart.notNull(height['unary-']()) * 0 : height, T);
         super._RectangleBase();
       }
       fromPoints(a, b) {
         let left = dart.as(min(a.x, b.x), T);
         let width = dart.as(max(a.x, b.x)['-'](left), T);
         let top = dart.as(min(a.y, b.y), T);
         let height = dart.as(max(a.y, b.y)['-'](top), T);
         return new (Rectangle$(T))(left, top, width, height);
       }
     }
     dart.defineNamedConstructor(Rectangle, 'fromPoints');
+    dart.setSignature(Rectangle, {});
     return Rectangle;
   });
   let Rectangle = Rectangle$();
   let _width = Symbol('_width');
   let _height = Symbol('_height');
   let MutableRectangle$ = dart.generic(function(T) {
     class MutableRectangle extends _RectangleBase$(T) {
       MutableRectangle(left, top, width, height) {
         this.left = left;
         this.top = top;
@@ skipping 22 matching lines @@
       }
       set height(height) {
         dart.as(height, T);
         if (height['<'](0))
           height = dart.as(_clampToZero(height), T);
         this[_height] = height;
       }
     }
     MutableRectangle[dart.implements] = () => [Rectangle$(T)];
     dart.defineNamedConstructor(MutableRectangle, 'fromPoints');
+    dart.setSignature(MutableRectangle, {});
     return MutableRectangle;
   });
   let MutableRectangle = MutableRectangle$();
-  // Function _clampToZero: (num) → num
   function _clampToZero(value) {
     dart.assert(dart.notNull(value) < 0);
     return -dart.notNull(value) * 0;
   }
+  dart.fn(_clampToZero, core.num, [core.num]);
   let E = 2.718281828459045;
   let LN10 = 2.302585092994046;
   let LN2 = 0.6931471805599453;
   let LOG2E = 1.4426950408889634;
   let LOG10E = 0.4342944819032518;
   let PI = 3.141592653589793;
   let SQRT1_2 = 0.7071067811865476;
   let SQRT2 = 1.4142135623730951;
-  // Function min: (num, num) → num
   function min(a, b) {
     if (!dart.is(a, core.num))
       throw new core.ArgumentError(a);
     if (!dart.is(b, core.num))
       throw new core.ArgumentError(b);
     if (dart.notNull(a) > dart.notNull(b))
       return b;
     if (dart.notNull(a) < dart.notNull(b))
       return a;
     if (typeof b == 'number') {
       if (typeof a == 'number') {
         if (a == 0.0) {
           return (dart.notNull(a) + dart.notNull(b)) * dart.notNull(a) * dart.notNull(b);
         }
       }
       if (a == 0 && dart.notNull(b.isNegative) || dart.notNull(b.isNaN))
         return b;
       return a;
     }
     return a;
   }
-  // Function max: (num, num) → num
+  dart.fn(min, core.num, [core.num, core.num]);
   function max(a, b) {
     if (!dart.is(a, core.num))
       throw new core.ArgumentError(a);
     if (!dart.is(b, core.num))
       throw new core.ArgumentError(b);
     if (dart.notNull(a) > dart.notNull(b))
       return a;
     if (dart.notNull(a) < dart.notNull(b))
       return b;
     if (typeof b == 'number') {
       if (typeof a == 'number') {
         if (a == 0.0) {
           return dart.notNull(a) + dart.notNull(b);
         }
       }
       if (b.isNaN)
         return b;
       return a;
     }
     if (b == 0 && dart.notNull(a.isNegative))
       return b;
     return a;
   }
-  // Function atan2: (num, num) → double
+  dart.fn(max, core.num, [core.num, core.num]);
   function atan2(a, b) {
     return Math.atan2(_js_helper.checkNum(a), _js_helper.checkNum(b));
   }
-  // Function pow: (num, num) → num
+  dart.fn(atan2, core.double, [core.num, core.num]);
   function pow(x, exponent) {
     _js_helper.checkNum(x);
     _js_helper.checkNum(exponent);
     return Math.pow(x, exponent);
   }
-  // Function sin: (num) → double
+  dart.fn(pow, core.num, [core.num, core.num]);
   function sin(x) {
     return Math.sin(_js_helper.checkNum(x));
   }
-  // Function cos: (num) → double
+  dart.fn(sin, core.double, [core.num]);
   function cos(x) {
     return Math.cos(_js_helper.checkNum(x));
   }
-  // Function tan: (num) → double
+  dart.fn(cos, core.double, [core.num]);
   function tan(x) {
     return Math.tan(_js_helper.checkNum(x));
   }
-  // Function acos: (num) → double
+  dart.fn(tan, core.double, [core.num]);
   function acos(x) {
     return Math.acos(_js_helper.checkNum(x));
   }
-  // Function asin: (num) → double
+  dart.fn(acos, core.double, [core.num]);
   function asin(x) {
     return Math.asin(_js_helper.checkNum(x));
   }
-  // Function atan: (num) → double
+  dart.fn(asin, core.double, [core.num]);
   function atan(x) {
     return Math.atan(_js_helper.checkNum(x));
   }
-  // Function sqrt: (num) → double
+  dart.fn(atan, core.double, [core.num]);
   function sqrt(x) {
     return Math.sqrt(_js_helper.checkNum(x));
   }
-  // Function exp: (num) → double
+  dart.fn(sqrt, core.double, [core.num]);
   function exp(x) {
     return Math.exp(_js_helper.checkNum(x));
   }
-  // Function log: (num) → double
+  dart.fn(exp, core.double, [core.num]);
   function log(x) {
     return Math.log(_js_helper.checkNum(x));
   }
+  dart.fn(log, core.double, [core.num]);
   let _POW2_32 = 4294967296;
   class _JSRandom extends core.Object {
     _JSRandom() {
     }
     nextInt(max) {
       if (dart.notNull(max) <= 0 || dart.notNull(max) > dart.notNull(_POW2_32)) {
         throw new core.RangeError(`max must be in range 0 < max ≤ 2^32, was ${max}`);
       }
       return Math.random() * max >>> 0;
     }
     nextDouble() {
       return Math.random();
     }
     nextBool() {
       return Math.random() < 0.5;
     }
   }
   _JSRandom[dart.implements] = () => [Random];
+  dart.setSignature(_JSRandom, {
+    methods: () => ({
+      nextInt: dart.functionType(core.int, [core.int]),
+      nextDouble: dart.functionType(core.double, []),
+      nextBool: dart.functionType(core.bool, [])
+    })
+  });
   let _lo = Symbol('_lo');
   let _hi = Symbol('_hi');
   let _nextState = Symbol('_nextState');
   class _Random extends core.Object {
     _Random(seed) {
       this[_lo] = 0;
       this[_hi] = 0;
       let empty_seed = 0;
       if (dart.notNull(seed) < 0) {
         empty_seed = -1;
@@ skipping 82 matching lines @@
       this[_nextState]();
       let bits27 = dart.notNull(this[_lo]) & (1 << 27) - 1;
       return (dart.notNull(bits26) * dart.notNull(_Random._POW2_27_D) + dart.notNull(bits27)) / dart.notNull(_Random._POW2_53_D);
     }
     nextBool() {
       this[_nextState]();
       return (dart.notNull(this[_lo]) & 1) == 0;
     }
   }
   _Random[dart.implements] = () => [Random];
+  dart.setSignature(_Random, {
+    methods: () => ({
+      [_nextState]: dart.functionType(dart.void, []),
+      nextInt: dart.functionType(core.int, [core.int]),
+      nextDouble: dart.functionType(core.double, []),
+      nextBool: dart.functionType(core.bool, [])
+    })
+  });
   _Random._POW2_53_D = 1.0 * 9007199254740992;
   _Random._POW2_27_D = 1.0 * (1 << 27);
   _Random._MASK32 = 4294967295;
   // Exports:
   exports.Point$ = Point$;
   exports.Point = Point;
   exports.Random = Random;
   exports.Rectangle$ = Rectangle$;
   exports.Rectangle = Rectangle;
   exports.MutableRectangle$ = MutableRectangle$;
@@ skipping 13 matching lines @@
   exports.sin = sin;
   exports.cos = cos;
   exports.tan = tan;
   exports.acos = acos;
   exports.asin = asin;
   exports.atan = atan;
   exports.sqrt = sqrt;
   exports.exp = exp;
   exports.log = log;
 })(math, core, _js_helper);