Tag closures with their types

lib/runtime/dart/core.js

 var core = dart.defineLibrary(core, {});
 var _js_helper = dart.lazyImport(_js_helper);
 var _internal = dart.lazyImport(_internal);
 var collection = dart.lazyImport(collection);
 var _interceptors = dart.lazyImport(_interceptors);
+var math = dart.lazyImport(math);
 var convert = dart.lazyImport(convert);
-(function(exports, _js_helper, _internal, collection, _interceptors, convert) {
+(function(exports, _js_helper, _internal, collection, _interceptors, math, convert) {
   'use strict';
   class Object {
     constructor() {
       let name = this.constructor.name;
       let init = this[name];
       let result = void 0;
       if (init)
         result = init.apply(this, arguments);
       return result === void 0 ? this : result;
     }
     ['=='](other) {
       return identical(this, other);
     }
     get hashCode() {
       return _js_helper.Primitives.objectHashCode(this);
     }
     toString() {
       return _js_helper.Primitives.objectToString(this);
     }
     noSuchMethod(invocation) {
       throw new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments);
     }
     get runtimeType() {
       return dart.realRuntimeType(this);
     }
   }
+  dart.setSignature(Object, {
+    methods: () => ({

[Jennifer Messerly, 2015/05/18 17:52:52]

could this level be removed? e.g. 

dart.setSignature(Object, () => ({
  '==': ...
  toString: ...
  noSuchMethod: ...
}));

[Leaf, 2015/05/19 00:02:20]

Certainly in the case that there are no statics, I could do so.  It makes it a
bit less uniform, but probably okay.  When there are statics, I either need to
pass them as a separate argument (which I didn't like) or mix them in, which is
ok but also not my favorite.  In the latter case I also need to pass the names
array as another argument.

+      '==': dart.functionType(bool, [dart.dynamic]),

[Jennifer Messerly, 2015/05/18 17:52:52]

could we compute the function type later? the `dart.functionType` feels very
redundant.

'==': [dart.dynamic, bool]
toString: [String]
noSuchMethod: [Invocation, dart.dynamic]

[Leaf, 2015/05/19 00:02:20]

Something like this sounds like a good idea, might do in a follow up CL.

+      toString: dart.functionType(String, []),
+      noSuchMethod: dart.functionType(dart.dynamic, [Invocation])
+    })
+  });
   class JsName extends Object {
     JsName(opts) {
       let name = opts && 'name' in opts ? opts.name : null;
       this.name = name;
     }
   }
+  dart.setSignature(JsName, {});
   class JsPeerInterface extends Object {
     JsPeerInterface(opts) {
       let name = opts && 'name' in opts ? opts.name : null;
       this.name = name;
     }
   }
+  dart.setSignature(JsPeerInterface, {});
   class SupportJsExtensionMethod extends Object {
     SupportJsExtensionMethod() {
     }
   }
+  dart.setSignature(SupportJsExtensionMethod, {});
   class Deprecated extends Object {
     Deprecated(expires) {
       this.expires = expires;
     }
     toString() {
       return `Deprecated feature. Will be removed ${this.expires}`;
     }
   }
+  dart.setSignature(Deprecated, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class _Override extends Object {
     _Override() {
     }
   }
+  dart.setSignature(_Override, {});
   let deprecated = dart.const(new Deprecated("next release"));
   let override = dart.const(new _Override());
   class _Proxy extends Object {
     _Proxy() {
     }
   }
+  dart.setSignature(_Proxy, {});
   let proxy = dart.const(new _Proxy());
   class bool extends Object {
     fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : false;
       throw new UnsupportedError('bool.fromEnvironment can only be used as a const constructor');
     }
     toString() {
       return this ? "true" : "false";
     }
   }
   dart.defineNamedConstructor(bool, 'fromEnvironment');
+  dart.setSignature(bool, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   let Comparator$ = dart.generic(function(T) {
     let Comparator = dart.typedef('Comparator', () => dart.functionType(int, [T, T]));
     return Comparator;
   });
   let Comparator = Comparator$();
   let Comparable$ = dart.generic(function(T) {
     class Comparable extends Object {
       static compare(a, b) {
         return a.compareTo(b);
       }
     }
+    dart.setSignature(Comparable, {
+      statics: () => ({compare: dart.functionType(int, [Comparable$(), Comparable$()])}),

[Jennifer Messerly, 2015/05/18 17:52:52]

do statics need to be separate from methods? for better or worse, Dart doesn't
allow the same name to be used as instance and static (within the same class)

if they did need to be separate, dart.setStaticSignature(...) would seem
cleaner. Less nesting == win

[Leaf, 2015/05/19 00:02:20]

They don't need to be.  I didn't really like mixing them in - it looked better
to me listed in their own sections.  I'm not wedded to separating them though.

[Jennifer Messerly, 2015/05/19 16:34:39]

yeah, not a huge deal to me, just prefer less nesting. I'd be fine with
`dart.setStaticSignature` as a new top level call. What do you think? The
implementation in dart_runtime actually works that way. :-)

+      names: ['compare']

[Jennifer Messerly, 2015/05/18 17:52:52]

what does this do?

[Leaf, 2015/05/19 00:02:20]

The types in general need to be evaluated lazily.  The type data on the static
methods needs to be attached eagerly (at least, before any code that might do a
tear-off runs).  So given 

setSignature(Foo, { statics: () => {bar : dart.functionType(core.int, [])}})

I can't evaluate the closure bound to 'statics' while evaluating setSignature
(because core.int may not be defined yet).  But I need to know what names in Foo
are statics, and that information is under the lambda.  Currently I just pass in
the names separately (and redundantly) in the names array to work around this. 
I'd like a better solution - suggestions welcome.  I can inspect Foo to find the
names, but I was having trouble reliably teasing out which things were actual
static methods and which were other random properties on the class (e.g.
.prototype).  Other options might include moving the laziness under the
properties (generating statics : () => instead of () => {statics : ...), or
postponing the linking up of the metadata with the functions until after we know
everything is defined.

[Jennifer Messerly, 2015/05/19 16:32:49]

Yeah, lots of possibilities to fix. Hard to choose :)

A. change the tearoff process for statics, so type info can be associated at
that time. Given the relative infrequency of tearoffs, I think this would be a
fine tradeoff.

B. Like A, but move static method info completely to tear off point (unless
mirrors imported)?

C. change how _setStaticTypes works. Instead have static methods point back to
their class. This allows computing the type later. This pointer could just be
added to everything, as it seems pretty harmless, especially as a symbol.

D. move laziness to each method's signature, means 5 char `() =>` per method

E. just enumerate all static properties. The EcmaScript 6 draft describes which
properties are created on classes/functions. It is just: "prototype" and
"length". "name" will also be added, unless it was defined as a static:
https://people.mozilla.org/~jorendorff/es6-draft.html#sec-runtime-semantics-b....
Non-strict mode functions also get "caller" and "arguments". Searching for
`DefinePropertyOrThrow(F` is an easy way to find them all in the spec. Or just
testing in the console.

I think my stack rank would be: B > E > C > A >> D >>> current :)

The big caveat of B, is we might not be able to use with mirrors. In which case
it won't work until everyone moves to package:reflectable.

+    });
     return Comparable;
   });
   let Comparable = Comparable$();
   class DateTime extends Object {
     DateTime(year, month, day, hour, minute, second, millisecond) {
       if (month === void 0)
         month = 1;
       if (day === void 0)
         day = 1;
       if (hour === void 0)
@@ skipping 21 matching lines @@
         millisecond = 0;
       this._internal(year, month, day, hour, minute, second, millisecond, true);
     }
     now() {
       this._now();
     }
     static parse(formattedString) {
       let re = new RegExp('^([+-]?\\d{4,6})-?(\\d\\d)-?(\\d\\d)' + '(?:[ T](\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(.\\d{1,6})?)?)?' + '( ?[zZ]| ?([-+])(\\d\\d)(?::?(\\d\\d))?)?)?$');
       let match = re.firstMatch(formattedString);
       if (match != null) {
-        // Function parseIntOrZero: (String) → int
         let parseIntOrZero = matched => {
           if (matched == null)
             return 0;
           return int.parse(matched);
         };
-        // Function parseDoubleOrZero: (String) → double
+        dart.fn(parseIntOrZero, int, [String]);
         let parseDoubleOrZero = matched => {
           if (matched == null)
             return 0.0;
           return double.parse(matched);
         };
+        dart.fn(parseDoubleOrZero, double, [String]);
         let years = int.parse(match.get(1));
         let month = int.parse(match.get(2));
         let day = int.parse(match.get(3));
         let hour = parseIntOrZero(match.get(4));
         let minute = parseIntOrZero(match.get(5));
         let second = parseIntOrZero(match.get(6));
         let addOneMillisecond = false;
         let millisecond = (dart.notNull(parseDoubleOrZero(match.get(7))) * 1000).round();
         if (millisecond == 1000) {
           addOneMillisecond = true;
@@ skipping 180 matching lines @@
     get weekday() {
       return dart.as(_js_helper.Primitives.getWeekday(this), int);
     }
   }
   DateTime[dart.implements] = () => [Comparable];
   dart.defineNamedConstructor(DateTime, 'utc');
   dart.defineNamedConstructor(DateTime, 'now');
   dart.defineNamedConstructor(DateTime, 'fromMillisecondsSinceEpoch');
   dart.defineNamedConstructor(DateTime, '_internal');
   dart.defineNamedConstructor(DateTime, '_now');
+  dart.setSignature(DateTime, {
+    methods: () => ({
+      '==': dart.functionType(bool, [dart.dynamic]),

[Jennifer Messerly, 2015/05/18 17:52:53]

I'd be really curious to see this after above suggestions, I bet this would look
a lot simpler

+      isBefore: dart.functionType(bool, [DateTime]),
+      isAfter: dart.functionType(bool, [DateTime]),
+      isAtSameMomentAs: dart.functionType(bool, [DateTime]),
+      compareTo: dart.functionType(int, [DateTime]),
+      toLocal: dart.functionType(DateTime, []),
+      toUtc: dart.functionType(DateTime, []),
+      toString: dart.functionType(String, []),
+      toIso8601String: dart.functionType(String, []),
+      add: dart.functionType(DateTime, [Duration]),
+      subtract: dart.functionType(DateTime, [Duration]),
+      difference: dart.functionType(Duration, [DateTime])
+    }),
+    statics: () => ({
+      parse: dart.functionType(DateTime, [String]),
+      _fourDigits: dart.functionType(String, [int]),
+      _sixDigits: dart.functionType(String, [int]),
+      _threeDigits: dart.functionType(String, [int]),
+      _twoDigits: dart.functionType(String, [int]),
+      _brokenDownDateToMillisecondsSinceEpoch: dart.functionType(int, [int, int, int, int, int, int, int, bool])
+    }),
+    names: ['parse', '_fourDigits', '_sixDigits', '_threeDigits', '_twoDigits', '_brokenDownDateToMillisecondsSinceEpoch']
+  });
   DateTime.MONDAY = 1;
   DateTime.TUESDAY = 2;
   DateTime.WEDNESDAY = 3;
   DateTime.THURSDAY = 4;
   DateTime.FRIDAY = 5;
   DateTime.SATURDAY = 6;
   DateTime.SUNDAY = 7;
   DateTime.DAYS_PER_WEEK = 7;
   DateTime.JANUARY = 1;
   DateTime.FEBRUARY = 2;
@@ skipping 29 matching lines @@
     static _onParseErrorInt(_) {
       num._parseError = true;
       return 0;
     }
     static _onParseErrorDouble(_) {
       num._parseError = true;
       return 0.0;
     }
   }
   num[dart.implements] = () => [Comparable$(num)];
+  dart.setSignature(num, {
+    statics: () => ({
+      parse: dart.functionType(num, [String], [dart.functionType(num, [String])]),
+      _onParseErrorInt: dart.functionType(int, [String]),
+      _onParseErrorDouble: dart.functionType(double, [String])
+    }),
+    names: ['parse', '_onParseErrorInt', '_onParseErrorDouble']
+  });
   class double extends num {
     static parse(source, onError) {
       if (onError === void 0)
         onError = null;
       return _js_helper.Primitives.parseDouble(source, onError);
     }
   }
+  dart.setSignature(double, {
+    statics: () => ({parse: dart.functionType(double, [String], [dart.functionType(double, [String])])}),
+    names: ['parse']
+  });
   double.NAN = 0.0 / 0.0;
   double.INFINITY = 1.0 / 0.0;
   double.NEGATIVE_INFINITY = -dart.notNull(double.INFINITY);
   double.MIN_POSITIVE = 5e-324;
   double.MAX_FINITE = 1.7976931348623157e+308;
   let _duration = dart.JsSymbol('_duration');
   class Duration extends Object {
     Duration(opts) {
       let days = opts && 'days' in opts ? opts.days : 0;
       let hours = opts && 'hours' in opts ? opts.hours : 0;
@@ skipping 55 matching lines @@
         return false;
       return dart.equals(this[_duration], dart.dload(other, _duration));
     }
     get hashCode() {
       return dart.hashCode(this[_duration]);
     }
     compareTo(other) {
       return this[_duration].compareTo(other[_duration]);
     }
     toString() {
-      // Function sixDigits: (int) → String
       let sixDigits = n => {
         if (dart.notNull(n) >= 100000)
           return `${n}`;
         if (dart.notNull(n) >= 10000)
           return `0${n}`;
         if (dart.notNull(n) >= 1000)
           return `00${n}`;
         if (dart.notNull(n) >= 100)
           return `000${n}`;
         if (dart.notNull(n) >= 10)
           return `0000${n}`;
         return `00000${n}`;
       };
-      // Function twoDigits: (int) → String
+      dart.fn(sixDigits, String, [int]);
       let twoDigits = n => {
         if (dart.notNull(n) >= 10)
           return `${n}`;
         return `0${n}`;
       };
+      dart.fn(twoDigits, String, [int]);
       if (dart.notNull(this.inMicroseconds) < 0) {
         return `-${this['unary-']()}`;
       }
       let twoDigitMinutes = twoDigits(this.inMinutes.remainder(Duration.MINUTES_PER_HOUR));
       let twoDigitSeconds = twoDigits(this.inSeconds.remainder(Duration.SECONDS_PER_MINUTE));
       let sixDigitUs = sixDigits(this.inMicroseconds.remainder(Duration.MICROSECONDS_PER_SECOND));
       return `${this.inHours}:${twoDigitMinutes}:${twoDigitSeconds}.${sixDigitUs}`;
     }
     get isNegative() {
       return dart.notNull(this[_duration]) < 0;
     }
     abs() {
       return new Duration._microseconds(this[_duration].abs());
     }
     ['unary-']() {
       return new Duration._microseconds(-dart.notNull(this[_duration]));
     }
   }
   Duration[dart.implements] = () => [Comparable$(Duration)];
   dart.defineNamedConstructor(Duration, '_microseconds');
+  dart.setSignature(Duration, {
+    methods: () => ({
+      '+': dart.functionType(Duration, [Duration]),
+      '-': dart.functionType(Duration, [Duration]),
+      '*': dart.functionType(Duration, [num]),
+      '~/': dart.functionType(Duration, [int]),
+      '<': dart.functionType(bool, [Duration]),
+      '>': dart.functionType(bool, [Duration]),
+      '<=': dart.functionType(bool, [Duration]),
+      '>=': dart.functionType(bool, [Duration]),
+      '==': dart.functionType(bool, [dart.dynamic]),
+      compareTo: dart.functionType(int, [Duration]),
+      toString: dart.functionType(String, []),
+      abs: dart.functionType(Duration, []),
+      'unary-': dart.functionType(Duration, [])
+    })
+  });
   Duration.MICROSECONDS_PER_MILLISECOND = 1000;
   Duration.MILLISECONDS_PER_SECOND = 1000;
   Duration.SECONDS_PER_MINUTE = 60;
   Duration.MINUTES_PER_HOUR = 60;
   Duration.HOURS_PER_DAY = 24;
   Duration.MICROSECONDS_PER_SECOND = dart.notNull(Duration.MICROSECONDS_PER_MILLISECOND) * dart.notNull(Duration.MILLISECONDS_PER_SECOND);
   Duration.MICROSECONDS_PER_MINUTE = dart.notNull(Duration.MICROSECONDS_PER_SECOND) * dart.notNull(Duration.SECONDS_PER_MINUTE);
   Duration.MICROSECONDS_PER_HOUR = dart.notNull(Duration.MICROSECONDS_PER_MINUTE) * dart.notNull(Duration.MINUTES_PER_HOUR);
   Duration.MICROSECONDS_PER_DAY = dart.notNull(Duration.MICROSECONDS_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.MILLISECONDS_PER_MINUTE = dart.notNull(Duration.MILLISECONDS_PER_SECOND) * dart.notNull(Duration.SECONDS_PER_MINUTE);
@@ skipping 18 matching lines @@
     static _stringToSafeString(string) {
       return _js_helper.jsonEncodeNative(string);
     }
     static _objectToString(object) {
       return _js_helper.Primitives.objectToString(object);
     }
     get stackTrace() {
       return _js_helper.Primitives.extractStackTrace(this);
     }
   }
+  dart.setSignature(Error, {
+    statics: () => ({
+      safeToString: dart.functionType(String, [Object]),
+      _stringToSafeString: dart.functionType(String, [String]),
+      _objectToString: dart.functionType(String, [Object])
+    }),
+    names: ['safeToString', '_stringToSafeString', '_objectToString']
+  });
   class AssertionError extends Error {
     AssertionError() {
       super.Error();
     }
   }
+  dart.setSignature(AssertionError, {});
   class TypeError extends AssertionError {}
+  dart.setSignature(TypeError, {});
   class CastError extends Error {
     CastError() {
       super.Error();
     }
   }
+  dart.setSignature(CastError, {});
   class NullThrownError extends Error {
     NullThrownError() {
       super.Error();
     }
     toString() {
       return "Throw of null.";
     }
   }
+  dart.setSignature(NullThrownError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   let _hasValue = dart.JsSymbol('_hasValue');
   class ArgumentError extends Error {
     ArgumentError(message) {
       if (message === void 0)
         message = null;
       this.message = message;
       this.invalidValue = null;
       this[_hasValue] = false;
       this.name = null;
       super.Error();
@@ skipping 24 matching lines @@
       }
       let nameString = "";
       if (this.name != null) {
         nameString = ` (${this.name})`;
       }
       return `${this.message}${nameString}: ${Error.safeToString(this.invalidValue)}`;
     }
   }
   dart.defineNamedConstructor(ArgumentError, 'value');
   dart.defineNamedConstructor(ArgumentError, 'notNull');
+  dart.setSignature(ArgumentError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class RangeError extends ArgumentError {
     RangeError(message) {
       this.start = null;
       this.end = null;
       super.ArgumentError(message);
     }
     value(value, name, message) {
       if (name === void 0)
         name = null;
       if (message === void 0)
@@ skipping 81 matching lines @@
         explanation = ": Valid value range is empty";
       } else {
         explanation = `: Only valid value is ${this.start}`;
       }
       return `RangeError: ${this.message} (${value})${explanation}`;
     }
   }
   dart.defineNamedConstructor(RangeError, 'value');
   dart.defineNamedConstructor(RangeError, 'range');
   dart.defineNamedConstructor(RangeError, 'index');
+  dart.setSignature(RangeError, {
+    methods: () => ({toString: dart.functionType(String, [])}),
+    statics: () => ({
+      checkValueInInterval: dart.functionType(dart.void, [int, int, int], [String, String]),
+      checkValidIndex: dart.functionType(dart.void, [int, dart.dynamic], [String, int, String]),
+      checkValidRange: dart.functionType(dart.void, [int, int, int], [String, String, String]),
+      checkNotNegative: dart.functionType(dart.void, [int], [String, String])
+    }),
+    names: ['checkValueInInterval', 'checkValidIndex', 'checkValidRange', 'checkNotNegative']
+  });
   class IndexError extends ArgumentError {
     IndexError(invalidValue, indexable, name, message, length) {
       if (name === void 0)
         name = null;
       if (message === void 0)
         message = null;
       if (length === void 0)
         length = null;
       this.indexable = indexable;
       this.length = length != null ? length : dart.as(dart.dload(indexable, 'length'), int);
       super.value(invalidValue, name, message != null ? message : "Index out of range");
     }
     get start() {
       return 0;
     }
     get end() {
       return dart.notNull(this.length) - 1;
     }
     toString() {
       dart.assert(this[_hasValue]);
       let target = Error.safeToString(this.indexable);
       let explanation = `index should be less than ${this.length}`;
       if (dart.dsend(this.invalidValue, '<', 0)) {
         explanation = "index must not be negative";
       }
       return `RangeError: ${this.message} (${target}[${this.invalidValue}]): ${explanation}`;
     }
   }
   IndexError[dart.implements] = () => [RangeError];
+  dart.setSignature(IndexError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class FallThroughError extends Error {
     FallThroughError() {
       super.Error();
     }
   }
+  dart.setSignature(FallThroughError, {});
   let _className = dart.JsSymbol('_className');
   class AbstractClassInstantiationError extends Error {
     AbstractClassInstantiationError(className) {
       this[_className] = className;
       super.Error();
     }
     toString() {
       return `Cannot instantiate abstract class: '${this[_className]}'`;
     }
   }
+  dart.setSignature(AbstractClassInstantiationError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   let _receiver = dart.JsSymbol('_receiver');
   let _memberName = dart.JsSymbol('_memberName');
   let _arguments = dart.JsSymbol('_arguments');
   let _namedArguments = dart.JsSymbol('_namedArguments');
   let _existingArgumentNames = dart.JsSymbol('_existingArgumentNames');
   let $length = dart.JsSymbol('$length');
   let $get = dart.JsSymbol('$get');
   class NoSuchMethodError extends Error {
     NoSuchMethodError(receiver, memberName, positionalArguments, namedArguments, existingArgumentNames) {
       if (existingArgumentNames === void 0)
@@ skipping 10 matching lines @@
       let i = 0;
       if (this[_arguments] != null) {
         for (; dart.notNull(i) < dart.notNull(this[_arguments][$length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(Error.safeToString(this[_arguments][$get](i)));
         }
       }
       if (this[_namedArguments] != null) {
-        this[_namedArguments].forEach((key, value) => {
+        this[_namedArguments].forEach(dart.fn((key, value) => {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(_symbolToString(key));
           sb.write(": ");
           sb.write(Error.safeToString(value));
           i = dart.notNull(i) + 1;
-        });
+        }, dart.dynamic, [Symbol, dart.dynamic]));
       }
       if (this[_existingArgumentNames] == null) {
         return `NoSuchMethodError : method not found: '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Arguments: [${sb}]`;
       } else {
         let actualParameters = dart.toString(sb);
         sb = new StringBuffer();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_existingArgumentNames][$length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(this[_existingArgumentNames][$get](i));
         }
         let formalParameters = dart.toString(sb);
         return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
       }
     }
   }
+  dart.setSignature(NoSuchMethodError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class UnsupportedError extends Error {
     UnsupportedError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this.message}`;
     }
   }
+  dart.setSignature(UnsupportedError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class UnimplementedError extends Error {
     UnimplementedError(message) {
       if (message === void 0)
         message = null;
       this.message = message;
       super.Error();
     }
     toString() {
       return this.message != null ? `UnimplementedError: ${this.message}` : "UnimplementedError";
     }
   }
   UnimplementedError[dart.implements] = () => [UnsupportedError];
+  dart.setSignature(UnimplementedError, {
+    methods: () => ({toString: dart.functionType(String, [])})

[Jennifer Messerly, 2015/05/18 17:52:52]

can we avoid adding types to overrides when it just duplicates info from base
class?

[Leaf, 2015/05/19 00:02:20]

Sure.  I'll do in a follow up CL.

+  });
   class StateError extends Error {
     StateError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Bad state: ${this.message}`;
     }
   }
+  dart.setSignature(StateError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class ConcurrentModificationError extends Error {
     ConcurrentModificationError(modifiedObject) {
       if (modifiedObject === void 0)
         modifiedObject = null;
       this.modifiedObject = modifiedObject;
       super.Error();
     }
     toString() {
       if (this.modifiedObject == null) {
         return "Concurrent modification during iteration.";
       }
       return "Concurrent modification during iteration: " + `${Error.safeToString(this.modifiedObject)}.`;
     }
   }
+  dart.setSignature(ConcurrentModificationError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class OutOfMemoryError extends Object {
     OutOfMemoryError() {
     }
     toString() {
       return "Out of Memory";
     }
     get stackTrace() {
       return null;
     }
   }
   OutOfMemoryError[dart.implements] = () => [Error];
+  dart.setSignature(OutOfMemoryError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class StackOverflowError extends Object {
     StackOverflowError() {
     }
     toString() {
       return "Stack Overflow";
     }
     get stackTrace() {
       return null;
     }
   }
   StackOverflowError[dart.implements] = () => [Error];
+  dart.setSignature(StackOverflowError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class CyclicInitializationError extends Error {
     CyclicInitializationError(variableName) {
       if (variableName === void 0)
         variableName = null;
       this.variableName = variableName;
       super.Error();
     }
     toString() {
       return this.variableName == null ? "Reading static variable during its initialization" : `Reading static variable '${this.variableName}' during its initialization`;
     }
   }
+  dart.setSignature(CyclicInitializationError, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class Exception extends Object {
     Exception(message) {
       if (message === void 0)
         message = null;
       return new _ExceptionImplementation(message);
     }
   }
+  dart.setSignature(Exception, {});
   class _ExceptionImplementation extends Object {
     _ExceptionImplementation(message) {
       if (message === void 0)
         message = null;
       this.message = message;
     }
     toString() {
       if (this.message == null)
         return "Exception";
       return `Exception: ${this.message}`;
     }
   }
   _ExceptionImplementation[dart.implements] = () => [Exception];
+  dart.setSignature(_ExceptionImplementation, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class FormatException extends Object {
     FormatException(message, source, offset) {
       if (message === void 0)
         message = "";
       if (source === void 0)
         source = null;
       if (offset === void 0)
         offset = -1;
       this.message = message;
       this.source = source;
@@ skipping 69 matching lines @@
           end = dart.notNull(offset) + 36;
           prefix = postfix = "...";
         }
       }
       let slice = dart.as(dart.dsend(this.source, 'substring', start, end), String);
       let markOffset = dart.notNull(offset) - dart.notNull(start) + dart.notNull(prefix.length);
       return `${report}${prefix}${slice}${postfix}\n${" "['*'](markOffset)}^\n`;
     }
   }
   FormatException[dart.implements] = () => [Exception];
+  dart.setSignature(FormatException, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   class IntegerDivisionByZeroException extends Object {
     IntegerDivisionByZeroException() {
     }
     toString() {
       return "IntegerDivisionByZeroException";
     }
   }
   IntegerDivisionByZeroException[dart.implements] = () => [Exception];
+  dart.setSignature(IntegerDivisionByZeroException, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   let _getKey = dart.JsSymbol('_getKey');
   let Expando$ = dart.generic(function(T) {
     class Expando extends Object {
       Expando(name) {
         if (name === void 0)
           name = null;
         this.name = name;
       }
       toString() {
         return `Expando:${this.name}`;
@@ skipping 17 matching lines @@
           key = `expando$key$${(() => {
             let x = Expando$()._keyCount;
             Expando$()._keyCount = dart.notNull(x) + 1;
             return x;
           })()}`;
           _js_helper.Primitives.setProperty(this, Expando$()._KEY_PROPERTY_NAME, key);
         }
         return key;
       }
     }
+    dart.setSignature(Expando, {
+      methods: () => ({
+        toString: dart.functionType(String, []),
+        get: dart.functionType(T, [Object]),
+        set: dart.functionType(dart.void, [Object, T]),
+        [_getKey]: dart.functionType(String, [])
+      })
+    });
     return Expando;
   });
   let Expando = Expando$();
   Expando._KEY_PROPERTY_NAME = 'expando$key';
   Expando._EXPANDO_PROPERTY_NAME = 'expando$values';
   Expando._keyCount = 0;
   class Function extends Object {
     static apply(f, positionalArguments, namedArguments) {
       if (namedArguments === void 0)
         namedArguments = null;
       return dart.dcall.apply(null, [f].concat(positionalArguments));
     }
     static _toMangledNames(namedArguments) {
       let result = dart.map();
-      namedArguments.forEach((symbol, value) => {
+      namedArguments.forEach(dart.fn((symbol, value) => {

[Jennifer Messerly, 2015/05/18 17:52:52]

this one seems not needed

[Leaf, 2015/05/19 00:02:20]

You mean just assuming that any Function not marked with a type is of type
dynamic^n -> dynamic?  I think that's fine, but we need to be careful that we
can always tell whether we're in this case.  Currently I think we would classify
types (i.e. constructor functions) as dart functions if we did this.  If I add
an _runtimeType field to classes (which I'm planning on doing to make core.Type
work out right), then probably we could make this assumption again.  It does
leave us with no way to tell whether we have a javascript function or a dart
function, but that's probably ok.

         result.set(_symbolToString(dart.as(symbol, Symbol)), value);
-      });
+      }));
       return result;
     }
   }
-  // Function identical: (Object, Object) → bool
+  dart.setSignature(Function, {
+    statics: () => ({
+      apply: dart.functionType(dart.dynamic, [Function, List], [Map$(Symbol, dart.dynamic)]),
+      _toMangledNames: dart.functionType(Map$(String, dart.dynamic), [Map$(Symbol, dart.dynamic)])
+    }),
+    names: ['apply', '_toMangledNames']
+  });
   function identical(a, b) {
     return _js_helper.Primitives.identicalImplementation(a, b);
   }
-  // Function identityHashCode: (Object) → int
+  dart.fn(identical, bool, [Object, Object]);
   function identityHashCode(object) {
     return _js_helper.objectHashCode(object);
   }
+  dart.fn(identityHashCode, () => dart.functionType(int, [Object]));
   class int extends num {
     fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       throw new UnsupportedError('int.fromEnvironment can only be used as a const constructor');
     }
     static parse(source, opts) {
       let radix = opts && 'radix' in opts ? opts.radix : null;
       let onError = opts && 'onError' in opts ? opts.onError : null;
       return _js_helper.Primitives.parseInt(source, radix, onError);
     }
   }
   dart.defineNamedConstructor(int, 'fromEnvironment');
+  dart.setSignature(int, {
+    statics: () => ({parse: dart.functionType(int, [String], {adi: int, nErro: dart.functionType(int, [String])})}),
+    names: ['parse']
+  });
   class Invocation extends Object {
     get isAccessor() {
       return dart.notNull(this.isGetter) || dart.notNull(this.isSetter);
     }
   }
+  dart.setSignature(Invocation, {});
   let $iterator = dart.JsSymbol('$iterator');
   let $join = dart.JsSymbol('$join');
   let Iterable$ = dart.generic(function(E) {
     class Iterable extends Object {
       Iterable() {
       }
       generate(count, generator) {
         if (generator === void 0)
           generator = null;
         if (dart.notNull(count) <= 0)
           return new (_internal.EmptyIterable$(E))();
         return new (exports._GeneratorIterable$(E))(count, generator);
       }
       [dart.JsSymbol.iterator]() {
         return new dart.JsIterator(this[$iterator]);
       }
       [$join](separator) {
         if (separator === void 0)
           separator = "";
         let buffer = new StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
     }
     dart.defineNamedConstructor(Iterable, 'generate');
+    dart.setSignature(Iterable, {
+      methods: () => ({[$join]: dart.functionType(String, [], [String])})
+    });
     return Iterable;
   });
   let Iterable = Iterable$();
   let _Generator$ = dart.generic(function(E) {
     let _Generator = dart.typedef('_Generator', () => dart.functionType(E, [int]));
     return _Generator;
   });
   let _Generator = _Generator$();
   let _end = dart.JsSymbol('_end');
   let _start = dart.JsSymbol('_start');
@@ skipping 37 matching lines @@
         if (dart.notNull(newEnd) >= dart.notNull(this[_end]))
           return this;
         return new (exports._GeneratorIterable$(E)).slice(this[_start], newEnd, this[_generator]);
       }
       static _id(n) {
         return n;
       }
     }
     _GeneratorIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.defineNamedConstructor(_GeneratorIterable, 'slice');
+    dart.setSignature(_GeneratorIterable, {
+      methods: () => ({
+        [$skip]: dart.functionType(Iterable$(E), [int]),
+        [$take]: dart.functionType(Iterable$(E), [int])
+      }),
+      statics: () => ({_id: dart.functionType(int, [int])}),
+      names: ['_id']
+    });
     return _GeneratorIterable;
   });
   dart.defineLazyClassGeneric(exports, '_GeneratorIterable', {get: _GeneratorIterable$});
   let _index = dart.JsSymbol('_index');
   let _current = dart.JsSymbol('_current');
   let _GeneratorIterator$ = dart.generic(function(E) {
     class _GeneratorIterator extends Object {
       _GeneratorIterator(index, end, generator) {
         this[_index] = index;
         this[_end] = end;
         this[_generator] = generator;
         this[_current] = null;
       }
       moveNext() {
         if (dart.notNull(this[_index]) < dart.notNull(this[_end])) {
           this[_current] = this[_generator](this[_index]);
           this[_index] = dart.notNull(this[_index]) + 1;
           return true;
         } else {
           this[_current] = null;
           return false;
         }
       }
       get current() {
         return this[_current];
       }
     }
     _GeneratorIterator[dart.implements] = () => [Iterator$(E)];
+    dart.setSignature(_GeneratorIterator, {
+      methods: () => ({moveNext: dart.functionType(bool, [])})
+    });
     return _GeneratorIterator;
   });
   let _GeneratorIterator = _GeneratorIterator$();
   let BidirectionalIterator$ = dart.generic(function(E) {
     class BidirectionalIterator extends Object {}
     BidirectionalIterator[dart.implements] = () => [Iterator$(E)];
+    dart.setSignature(BidirectionalIterator, {});
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$();
   let Iterator$ = dart.generic(function(E) {
     class Iterator extends Object {}
+    dart.setSignature(Iterator, {});
     return Iterator;
   });
   let Iterator = Iterator$();
   let $set = dart.JsSymbol('$set');
   let $add = dart.JsSymbol('$add');
   let $checkMutable = dart.JsSymbol('$checkMutable');
   let $checkGrowable = dart.JsSymbol('$checkGrowable');
   let $where = dart.JsSymbol('$where');
   let $expand = dart.JsSymbol('$expand');
   let $forEach = dart.JsSymbol('$forEach');
@@ skipping 331 matching lines @@
         if (this[$length] == 0)
           throw new RangeError.value(-1);
         return dart.as(this.pop(), E);
       }
       [$removeWhere](test) {
         dart.as(test, dart.functionType(bool, [E]));
         _internal.IterableMixinWorkaround.removeWhereList(this, test);
       }
       [$retainWhere](test) {
         dart.as(test, dart.functionType(bool, [E]));
-        _internal.IterableMixinWorkaround.removeWhereList(this, element => !dart.notNull(test(element)));
+        _internal.IterableMixinWorkaround.removeWhereList(this, dart.fn(element => !dart.notNull(test(element)), bool, [E]));
       }
       [$sublist](start, end) {
         if (end === void 0)
           end = null;
         dart.dcall(/* Unimplemented unknown name */checkNull, start);
         if (!(typeof start == 'number'))
           throw new ArgumentError(start);
         if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(this[$length])) {
           throw new RangeError.range(start, 0, this[$length]);
         }
@@ skipping 46 matching lines @@
       }
       [$asMap]() {
         return new (_internal.IterableMixinWorkaround$(E))().asMapList(this);
       }
     }
     dart.setBaseClass(List, dart.global.Array);
     List[dart.implements] = () => [Iterable$(E), _internal.EfficientLength];
     dart.defineNamedConstructor(List, 'filled');
     dart.defineNamedConstructor(List, 'from');
     dart.defineNamedConstructor(List, 'generate');
+    dart.setSignature(List, {
+      methods: () => ({
+        [$checkMutable]: dart.functionType(dart.dynamic, [dart.dynamic]),
+        [$checkGrowable]: dart.functionType(dart.dynamic, [dart.dynamic]),
+        [$where]: dart.functionType(Iterable$(E), [dart.functionType(bool, [E])]),
+        [$expand]: dart.functionType(Iterable, [dart.functionType(Iterable, [E])]),
+        [$forEach]: dart.functionType(dart.void, [dart.functionType(dart.void, [E])]),
+        [$map]: dart.functionType(Iterable, [dart.functionType(dart.dynamic, [E])]),
+        [$join]: dart.functionType(String, [], [String]),
+        [$take]: dart.functionType(Iterable$(E), [int]),
+        [$takeWhile]: dart.functionType(Iterable$(E), [dart.functionType(bool, [E])]),
+        [$skip]: dart.functionType(Iterable$(E), [int]),
+        [$skipWhile]: dart.functionType(Iterable$(E), [dart.functionType(bool, [E])]),
+        [$reduce]: dart.functionType(E, [dart.functionType(E, [E, E])]),
+        [$fold]: dart.functionType(dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, E])]),
+        [$firstWhere]: dart.functionType(E, [dart.functionType(bool, [E])], {rEls: dart.functionType(E, [])}),
+        [$lastWhere]: dart.functionType(E, [dart.functionType(bool, [E])], {rEls: dart.functionType(E, [])}),
+        [$singleWhere]: dart.functionType(E, [dart.functionType(bool, [E])]),
+        [$elementAt]: dart.functionType(E, [int]),
+        [$any]: dart.functionType(bool, [dart.functionType(bool, [E])]),
+        [$every]: dart.functionType(bool, [dart.functionType(bool, [E])]),
+        [$contains]: dart.functionType(bool, [Object]),
+        [$toString]: dart.functionType(String, []),
+        [$toList]: dart.functionType(List$(E), [], {rowabl: bool}),
+        [$toSet]: dart.functionType(exports.Set$(E), []),
+        [$get]: dart.functionType(E, [int]),
+        [$set]: dart.functionType(dart.void, [int, E]),
+        [$add]: dart.functionType(dart.void, [E]),
+        [$addAll]: dart.functionType(dart.void, [Iterable$(E)]),
+        [$sort]: dart.functionType(dart.void, [], [dart.functionType(int, [E, E])]),
+        [$shuffle]: dart.functionType(dart.void, [], [math.Random]),
+        [$indexOf]: dart.functionType(int, [E], [int]),
+        [$lastIndexOf]: dart.functionType(int, [E], [int]),
+        [$clear]: dart.functionType(dart.void, []),
+        [$insert]: dart.functionType(dart.void, [int, E]),
+        [$insertAll]: dart.functionType(dart.void, [int, Iterable$(E)]),
+        [$setAll]: dart.functionType(dart.void, [int, Iterable$(E)]),
+        [$remove]: dart.functionType(bool, [Object]),
+        [$removeAt]: dart.functionType(E, [int]),
+        [$removeLast]: dart.functionType(E, []),
+        [$removeWhere]: dart.functionType(dart.void, [dart.functionType(bool, [E])]),
+        [$retainWhere]: dart.functionType(dart.void, [dart.functionType(bool, [E])]),
+        [$sublist]: dart.functionType(List$(E), [int], [int]),
+        [$getRange]: dart.functionType(Iterable$(E), [int, int]),
+        [$setRange]: dart.functionType(dart.void, [int, int, Iterable$(E)], [int]),
+        [$removeRange]: dart.functionType(dart.void, [int, int]),
+        [$fillRange]: dart.functionType(dart.void, [int, int], [E]),
+        [$replaceRange]: dart.functionType(dart.void, [int, int, Iterable$(E)]),
+        [$asMap]: dart.functionType(Map$(int, E), [])
+      })
+    });
     return List;
   });
   let List = List$();
   dart.registerExtension(dart.global.Array, List);
   let Map$ = dart.generic(function(K, V) {
     class Map extends Object {
       Map() {
         return new (collection.LinkedHashMap$(K, V))();
       }
       from(other) {
         return new (collection.LinkedHashMap$(K, V)).from(other);
       }
       identity() {
         return new (collection.LinkedHashMap$(K, V)).identity();
       }
       fromIterable(iterable, opts) {
         return new (collection.LinkedHashMap$(K, V)).fromIterable(iterable, opts);
       }
       fromIterables(keys, values) {
         return new (collection.LinkedHashMap$(K, V)).fromIterables(keys, values);
       }
     }
     dart.defineNamedConstructor(Map, 'from');
     dart.defineNamedConstructor(Map, 'identity');
     dart.defineNamedConstructor(Map, 'fromIterable');
     dart.defineNamedConstructor(Map, 'fromIterables');
+    dart.setSignature(Map, {});
     return Map;
   });
   let Map = Map$();
   class Null extends Object {
     _uninstantiable() {
       throw new UnsupportedError('class Null cannot be instantiated');
     }
     toString() {
       return "null";
     }
   }
   dart.defineNamedConstructor(Null, '_uninstantiable');
+  dart.setSignature(Null, {
+    methods: () => ({toString: dart.functionType(String, [])})
+  });
   num._parseError = false;
   class Pattern extends Object {}
-  // Function print: (Object) → void
+  dart.setSignature(Pattern, {});
   function print(object) {
     let line = `${object}`;
     if (_internal.printToZone == null) {
       _internal.printToConsole(line);
     } else {
       dart.dcall(_internal.printToZone, line);
     }
   }
+  dart.fn(print, dart.void, [Object]);
   class Match extends Object {}
+  dart.setSignature(Match, {});
   class RegExp extends Object {
     RegExp(source, opts) {
       let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
       let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
       return new _js_helper.JSSyntaxRegExp(source, {multiLine: multiLine, caseSensitive: caseSensitive});
     }
   }
   RegExp[dart.implements] = () => [Pattern];
+  dart.setSignature(RegExp, {});
   let Set$ = dart.generic(function(E) {
     class Set extends collection.IterableBase$(E) {
       Set() {
         return new (collection.LinkedHashSet$(E))();
       }
       identity() {
         return new (collection.LinkedHashSet$(E)).identity();
       }
       from(elements) {
         return new (collection.LinkedHashSet$(E)).from(elements);
       }
     }
     Set[dart.implements] = () => [_internal.EfficientLength];
     dart.defineNamedConstructor(Set, 'identity');
     dart.defineNamedConstructor(Set, 'from');
+    dart.setSignature(Set, {});
     return Set;
   });
   dart.defineLazyClassGeneric(exports, 'Set', {get: Set$});
   let Sink$ = dart.generic(function(T) {
     class Sink extends Object {}
+    dart.setSignature(Sink, {});
     return Sink;
   });
   let Sink = Sink$();
   class StackTrace extends Object {}
+  dart.setSignature(StackTrace, {});
   let _stop = dart.JsSymbol('_stop');
   class Stopwatch extends Object {
     get frequency() {
       return Stopwatch._frequency;
     }
     Stopwatch() {
       this[_start] = null;
       this[_stop] = null;
       Stopwatch._initTicker();
     }
@@ skipping 39 matching lines @@
       return this[_start] != null && this[_stop] == null;
     }
     static _initTicker() {
       _js_helper.Primitives.initTicker();
       Stopwatch._frequency = _js_helper.Primitives.timerFrequency;
     }
     static _now() {
       return dart.as(dart.dcall(_js_helper.Primitives.timerTicks), int);
     }
   }
+  dart.setSignature(Stopwatch, {
+    methods: () => ({
+      start: dart.functionType(dart.void, []),
+      stop: dart.functionType(dart.void, []),
+      reset: dart.functionType(dart.void, [])
+    }),
+    statics: () => ({
+      _initTicker: dart.functionType(dart.void, []),
+      _now: dart.functionType(int, [])
+    }),
+    names: ['_initTicker', '_now']
+  });
   Stopwatch._frequency = null;
   class String extends Object {
     fromCharCodes(charCodes, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (!dart.is(charCodes, _interceptors.JSArray)) {
         return String._stringFromIterable(charCodes, start, end);
       }
@@ skipping 43 matching lines @@
           list[$add](it.current);
         }
       }
       return _js_helper.Primitives.stringFromCharCodes(list);
     }
   }
   String[dart.implements] = () => [Comparable$(String), Pattern];
   dart.defineNamedConstructor(String, 'fromCharCodes');
   dart.defineNamedConstructor(String, 'fromCharCode');
   dart.defineNamedConstructor(String, 'fromEnvironment');
+  dart.setSignature(String, {
+    statics: () => ({_stringFromIterable: dart.functionType(String, [Iterable$(int), int, int])}),
+    names: ['_stringFromIterable']
+  });
   dart.defineLazyClass(exports, {
     get Runes() {
       class Runes extends collection.IterableBase$(int) {
         Runes(string) {
           this.string = string;
           super.IterableBase();
         }
         get [$iterator]() {
           return new RuneIterator(this.string);
         }
         get [$last]() {
           if (this.string.length == 0) {
             throw new StateError('No elements.');
           }
           let length = this.string.length;
           let code = this.string.codeUnitAt(dart.notNull(length) - 1);
           if (dart.notNull(_isTrailSurrogate(code)) && dart.notNull(this.string.length) > 1) {
             let previousCode = this.string.codeUnitAt(dart.notNull(length) - 2);
             if (_isLeadSurrogate(previousCode)) {
               return _combineSurrogatePair(previousCode, code);
             }
           }
           return code;
         }
       }
+      dart.setSignature(Runes, {});
       return Runes;
     }
   });
-  // Function _isLeadSurrogate: (int) → bool
   function _isLeadSurrogate(code) {
     return (dart.notNull(code) & 64512) == 55296;
   }
-  // Function _isTrailSurrogate: (int) → bool
+  dart.fn(_isLeadSurrogate, bool, [int]);
   function _isTrailSurrogate(code) {
     return (dart.notNull(code) & 64512) == 56320;
   }
-  // Function _combineSurrogatePair: (int, int) → int
+  dart.fn(_isTrailSurrogate, bool, [int]);
   function _combineSurrogatePair(start, end) {
     return 65536 + ((dart.notNull(start) & 1023) << 10) + (dart.notNull(end) & 1023);
   }
+  dart.fn(_combineSurrogatePair, int, [int, int]);
   let _position = dart.JsSymbol('_position');
   let _nextPosition = dart.JsSymbol('_nextPosition');
   let _currentCodePoint = dart.JsSymbol('_currentCodePoint');
   let _checkSplitSurrogate = dart.JsSymbol('_checkSplitSurrogate');
   class RuneIterator extends Object {
     RuneIterator(string) {
       this.string = string;
       this[_position] = 0;
       this[_nextPosition] = 0;
       this[_currentCodePoint] = null;
@@ skipping 76 matching lines @@
           return true;
         }
       }
       this[_position] = position;
       this[_currentCodePoint] = codeUnit;
       return true;
     }
   }
   RuneIterator[dart.implements] = () => [BidirectionalIterator$(int)];
   dart.defineNamedConstructor(RuneIterator, 'at');
+  dart.setSignature(RuneIterator, {
+    methods: () => ({
+      [_checkSplitSurrogate]: dart.functionType(dart.void, [int]),
+      reset: dart.functionType(dart.void, [], [int]),
+      moveNext: dart.functionType(bool, []),
+      movePrevious: dart.functionType(bool, [])
+    })
+  });
   let _contents = dart.JsSymbol('_contents');
   let _writeString = dart.JsSymbol('_writeString');
   class StringBuffer extends Object {
     StringBuffer(content) {
       if (content === void 0)
         content = "";
       this[_contents] = `${content}`;
     }
     get length() {
       return this[_contents].length;
@@ skipping 38 matching lines @@
       this[_contents] = "";
     }
     toString() {
       return _js_helper.Primitives.flattenString(this[_contents]);
     }
     [_writeString](str) {
       this[_contents] = _js_helper.Primitives.stringConcatUnchecked(this[_contents], dart.as(str, String));
     }
   }
   StringBuffer[dart.implements] = () => [StringSink];
+  dart.setSignature(StringBuffer, {
+    methods: () => ({
+      write: dart.functionType(dart.void, [Object]),
+      writeCharCode: dart.functionType(dart.void, [int]),
+      writeAll: dart.functionType(dart.void, [Iterable], [String]),
+      writeln: dart.functionType(dart.void, [], [Object]),
+      clear: dart.functionType(dart.void, []),
+      toString: dart.functionType(String, []),
+      [_writeString]: dart.functionType(dart.void, [dart.dynamic])
+    })
+  });
   class StringSink extends Object {}
+  dart.setSignature(StringSink, {});
   class Symbol extends Object {
     Symbol(name) {
       return new _internal.Symbol(name);
     }
   }
+  dart.setSignature(Symbol, {});
   class Type extends Object {}
+  dart.setSignature(Type, {});
   let _writeAuthority = dart.JsSymbol('_writeAuthority');
   let _userInfo = dart.JsSymbol('_userInfo');
   let _host = dart.JsSymbol('_host');
   let _port = dart.JsSymbol('_port');
   let _path = dart.JsSymbol('_path');
   let _query = dart.JsSymbol('_query');
   let _fragment = dart.JsSymbol('_fragment');
   let _pathSegments = dart.JsSymbol('_pathSegments');
   let _queryParameters = dart.JsSymbol('_queryParameters');
   let _merge = dart.JsSymbol('_merge');
@@ skipping 36 matching lines @@
     get path() {
       return this[_path];
     }
     get query() {
       return this[_query] == null ? "" : this[_query];
     }
     get fragment() {
       return this[_fragment] == null ? "" : this[_fragment];
     }
     static parse(uri) {
-      // Function isRegName: (int) → bool
       let isRegName = ch => {
         return dart.notNull(ch) < 128 && dart.notNull(!dart.equals(dart.dsend(Uri._regNameTable[$get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
       };
+      dart.fn(isRegName, bool, [int]);
       let EOI = -1;
       let scheme = "";
       let userinfo = "";
       let host = null;
       let port = null;
       let path = null;
       let query = null;
       let fragment = null;
       let index = 0;
       let pathStart = 0;
       let char = EOI;
-      // Function parseAuth: () → void
       let parseAuth = () => {
         if (index == uri.length) {
           char = EOI;
           return;
         }
         let authStart = index;
         let lastColon = -1;
         let lastAt = -1;
         char = uri.codeUnitAt(index);
         while (dart.notNull(index) < dart.notNull(uri.length)) {
@@ skipping 39 matching lines @@
             }
           }
           port = Uri._makePort(portNumber, scheme);
           hostEnd = lastColon;
         }
         host = Uri._makeHost(uri, hostStart, hostEnd, true);
         if (dart.notNull(index) < dart.notNull(uri.length)) {
           char = uri.codeUnitAt(index);
         }
       };
+      dart.fn(parseAuth, dart.void, []);
       let NOT_IN_PATH = 0;
       let IN_PATH = 1;
       let ALLOW_AUTH = 2;
       let state = NOT_IN_PATH;
       let i = index;
       while (dart.notNull(i) < dart.notNull(uri.length)) {
         char = uri.codeUnitAt(i);
         if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
           state = NOT_IN_PATH;
           break;
@@ skipping 176 matching lines @@
     static get base() {
       let uri = _js_helper.Primitives.currentUri();
       if (uri != null)
         return Uri.parse(uri);
       throw new UnsupportedError("'Uri.base' is not supported");
     }
     static get _isWindows() {
       return false;
     }
     static _checkNonWindowsPathReservedCharacters(segments, argumentError) {
-      segments[$forEach](segment => {
+      segments[$forEach](dart.fn(segment => {
         if (dart.dsend(segment, 'contains', "/")) {
           if (argumentError) {
             throw new ArgumentError(`Illegal path character ${segment}`);
           } else {
             throw new UnsupportedError(`Illegal path character ${segment}`);
           }
         }
-      });
+      }));
     }
     static _checkWindowsPathReservedCharacters(segments, argumentError, firstSegment) {
       if (firstSegment === void 0)
         firstSegment = 0;
-      segments[$skip](firstSegment)[$forEach](segment => {
+      segments[$skip](firstSegment)[$forEach](dart.fn(segment => {
         if (dart.dsend(segment, 'contains', new RegExp('["*/:<>?\\\\|]'))) {
           if (argumentError) {
             throw new ArgumentError("Illegal character in path");
           } else {
             throw new UnsupportedError("Illegal character in path");
           }
         }
-      });
+      }));
     }
     static _checkWindowsDriveLetter(charCode, argumentError) {
       if (dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._UPPER_CASE_Z) || dart.notNull(Uri._LOWER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._LOWER_CASE_Z)) {
         return;
       }
       if (argumentError) {
         throw new ArgumentError("Illegal drive letter " + dart.notNull(new String.fromCharCode(charCode)));
       } else {
         throw new UnsupportedError("Illegal drive letter " + dart.notNull(new String.fromCharCode(charCode)));
       }
@@ skipping 253 matching lines @@
     static _makePath(path, start, end, pathSegments, ensureLeadingSlash, isFile) {
       if (path == null && dart.notNull(pathSegments == null))
         return isFile ? "/" : "";
       if (path != null && dart.notNull(pathSegments != null)) {
         throw new ArgumentError('Both path and pathSegments specified');
       }
       let result = null;
       if (path != null) {
         result = Uri._normalize(path, start, end, dart.as(Uri._pathCharOrSlashTable, List$(int)));
       } else {
-        result = pathSegments[$map](s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)))[$join]("/");
+        result = pathSegments[$map](dart.fn(s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)), String, [dart.dynamic]))[$join]("/");
       }
       if (dart.dload(result, 'isEmpty')) {
         if (isFile)
           return "/";
       } else if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash)) && dart.notNull(!dart.equals(dart.dsend(result, 'codeUnitAt', 0), Uri._SLASH))) {
         return `/${result}`;
       }
       return dart.as(result, String);
     }
     static _makeQuery(query, start, end, queryParameters) {
       if (query == null && dart.notNull(queryParameters == null))
         return null;
       if (query != null && dart.notNull(queryParameters != null)) {
         throw new ArgumentError('Both query and queryParameters specified');
       }
       if (query != null)
         return Uri._normalize(query, start, end, dart.as(Uri._queryCharTable, List$(int)));
       let result = new StringBuffer();
       let first = true;
-      queryParameters.forEach((key, value) => {
+      queryParameters.forEach(dart.fn((key, value) => {
         if (!dart.notNull(first)) {
           result.write("&");
         }
         first = false;
         result.write(Uri.encodeQueryComponent(dart.as(key, String)));
         if (dart.notNull(value != null) && dart.notNull(dart.dsend(dart.dload(value, 'isEmpty'), '!'))) {
           result.write("=");
           result.write(Uri.encodeQueryComponent(dart.as(value, String)));
         }
-      });
+      }));
       return dart.toString(result);
     }
     static _makeFragment(fragment, start, end) {
       if (fragment == null)
         return null;
       return Uri._normalize(fragment, start, end, dart.as(Uri._queryCharTable, List$(int)));
     }
     static _stringOrNullLength(s) {
       return s == null ? 0 : s.length;
     }
@@ skipping 344 matching lines @@
       }
       return dart.toString(sb);
     }
     ['=='](other) {
       if (!dart.is(other, Uri))
         return false;
       let uri = dart.as(other, Uri);
       return this.scheme == uri.scheme && this.hasAuthority == uri.hasAuthority && this.userInfo == uri.userInfo && this.host == uri.host && this.port == uri.port && this.path == uri.path && this.hasQuery == uri.hasQuery && this.query == uri.query && this.hasFragment == uri.hasFragment && this.fragment == uri.fragment;
     }
     get hashCode() {
-      // Function combine: (dynamic, dynamic) → int
       let combine = (part, current) => {
         return dart.as(dart.dsend(dart.dsend(dart.dsend(current, '*', 31), '+', dart.hashCode(part)), '&', 1073741823), int);
       };
+      dart.fn(combine, int, [dart.dynamic, dart.dynamic]);
       return combine(this.scheme, combine(this.userInfo, combine(this.host, combine(this.port, combine(this.path, combine(this.query, combine(this.fragment, 1)))))));
     }
     static _addIfNonEmpty(sb, test, first, second) {
       if ("" != test) {
         sb.write(first);
         sb.write(second);
       }
     }
     static encodeComponent(component) {
       return Uri._uriEncode(dart.as(Uri._unreserved2396Table, List$(int)), component);
@@ skipping 10 matching lines @@
       return Uri._uriDecode(encodedComponent, {plusToSpace: true, encoding: encoding});
     }
     static encodeFull(uri) {
       return Uri._uriEncode(dart.as(Uri._encodeFullTable, List$(int)), uri);
     }
     static decodeFull(uri) {
       return Uri._uriDecode(uri);
     }
     static splitQueryString(query, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
-      return dart.as(query.split("&")[$fold](dart.map(), (map, element) => {
+      return dart.as(query.split("&")[$fold](dart.map(), dart.fn((map, element) => {
         let index = dart.as(dart.dsend(element, 'indexOf', "="), int);
         if (index == -1) {
           if (!dart.equals(element, "")) {
             dart.dsetindex(map, Uri.decodeQueryComponent(dart.as(element, String), {encoding: encoding}), "");
           }
         } else if (index != 0) {
           let key = dart.dsend(element, 'substring', 0, index);
           let value = dart.dsend(element, 'substring', dart.notNull(index) + 1);
           dart.dsetindex(map, Uri.decodeQueryComponent(dart.as(key, String), {encoding: encoding}), Uri.decodeQueryComponent(dart.as(value, String), {encoding: encoding}));
         }
         return map;
-      }), Map$(String, String));
+      })), Map$(String, String));
     }
     static parseIPv4Address(host) {
-      // Function error: (String) → void
       let error = msg => {
         throw new FormatException(`Illegal IPv4 address, ${msg}`);
       };
+      dart.fn(error, dart.void, [String]);
       let bytes = host.split('.');
       if (bytes[$length] != 4) {
         error('IPv4 address should contain exactly 4 parts');
       }
-      return dart.as(bytes[$map](byteString => {
+      return dart.as(bytes[$map](dart.fn(byteString => {
         let byte = int.parse(dart.as(byteString, String));
         if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
           error('each part must be in the range of `0..255`');
         }
         return byte;
-      })[$toList](), List$(int));
+      }))[$toList](), List$(int));
     }
     static parseIPv6Address(host, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (end == null)
         end = host.length;
-      // Function error: (String, [dynamic]) → void
       let error = (msg, position) => {
         if (position === void 0)
           position = null;
         throw new FormatException(`Illegal IPv6 address, ${msg}`, host, dart.as(position, int));
       };
-      // Function parseHex: (int, int) → int
+      dart.fn(error, dart.void, [String], [dart.dynamic]);
       let parseHex = (start, end) => {
         if (dart.notNull(end) - dart.notNull(start) > 4) {
           error('an IPv6 part can only contain a maximum of 4 hex digits', start);
         }
         let value = int.parse(host.substring(start, end), {radix: 16});
         if (dart.notNull(value) < 0 || dart.notNull(value) > (1 << 16) - 1) {
           error('each part must be in the range of `0x0..0xFFFF`', start);
         }
         return value;
       };
+      dart.fn(parseHex, int, [int, int]);
       if (dart.notNull(host.length) < 2)
         error('address is too short');
       let parts = dart.setType([], List$(int));
       let wildcardSeen = false;
       let partStart = start;
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         if (host.codeUnitAt(i) == Uri._COLON) {
           if (i == start) {
             i = dart.notNull(i) + 1;
             if (host.codeUnitAt(i) != Uri._COLON) {
@@ skipping 56 matching lines @@
           bytes[$set](index, dart.notNull(value) >> 8);
           bytes[$set](dart.notNull(index) + 1, dart.notNull(value) & 255);
           index = dart.notNull(index) + 2;
         }
       }
       return dart.as(bytes, List$(int));
     }
     static _uriEncode(canonicalTable, text, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
       let spaceToPlus = opts && 'spaceToPlus' in opts ? opts.spaceToPlus : false;
-      // Function byteToHex: (dynamic, dynamic) → dynamic
       let byteToHex = (byte, buffer) => {
         let hex = '0123456789ABCDEF';
         dart.dsend(buffer, 'writeCharCode', hex.codeUnitAt(dart.as(dart.dsend(byte, '>>', 4), int)));
         dart.dsend(buffer, 'writeCharCode', hex.codeUnitAt(dart.as(dart.dsend(byte, '&', 15), int)));
       };
+      dart.fn(byteToHex);
       let result = new StringBuffer();
       let bytes = encoding.encode(text);
       for (let i = 0; dart.notNull(i) < dart.notNull(bytes[$length]); i = dart.notNull(i) + 1) {
         let byte = bytes[$get](i);
         if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[$get](dart.notNull(byte) >> 4)) & 1 << (dart.notNull(byte) & 15)) != 0) {
           result.writeCharCode(byte);
         } else if (dart.notNull(spaceToPlus) && byte == Uri._SPACE) {
           result.writeCharCode(Uri._PLUS);
         } else {
           result.writeCharCode(Uri._PERCENT);
@@ skipping 57 matching lines @@
       return encoding.decode(bytes);
     }
     static _isAlphabeticCharacter(codeUnit) {
       return dart.notNull(codeUnit) >= dart.notNull(Uri._LOWER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._LOWER_CASE_Z) || dart.notNull(codeUnit) >= dart.notNull(Uri._UPPER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._UPPER_CASE_Z);
     }
   }
   dart.defineNamedConstructor(Uri, '_internal');
   dart.defineNamedConstructor(Uri, 'http');
   dart.defineNamedConstructor(Uri, 'https');
   dart.defineNamedConstructor(Uri, 'file');
+  dart.setSignature(Uri, {
+    methods: () => ({
+      replace: dart.functionType(Uri, [], {chem: String, serInf: String, os: String, or: int, at: String, athSegment: Iterable$(String), uer: String, ueryParameter: Map$(String, String), ragmen: String}),
+      [_merge]: dart.functionType(String, [String, String]),
+      [_hasDotSegments]: dart.functionType(bool, [String]),
+      [_removeDotSegments]: dart.functionType(String, [String]),
+      resolve: dart.functionType(Uri, [String]),
+      resolveUri: dart.functionType(Uri, [Uri]),
+      toFilePath: dart.functionType(String, [], {indow: bool}),
+      [_toFilePath]: dart.functionType(String, []),
+      [_toWindowsFilePath]: dart.functionType(String, []),
+      [_writeAuthority]: dart.functionType(dart.void, [StringSink]),
+      toString: dart.functionType(String, []),
+      '==': dart.functionType(bool, [dart.dynamic])
+    }),
+    statics: () => ({
+      _defaultPort: dart.functionType(int, [String]),
+      parse: dart.functionType(Uri, [String]),
+      _fail: dart.functionType(dart.void, [String, int, String]),
+      _makeHttpUri: dart.functionType(Uri, [String, String, String, Map$(String, String)]),
+      _checkNonWindowsPathReservedCharacters: dart.functionType(dart.dynamic, [List$(String), bool]),
+      _checkWindowsPathReservedCharacters: dart.functionType(dart.dynamic, [List$(String), bool], [int]),
+      _checkWindowsDriveLetter: dart.functionType(dart.dynamic, [int, bool]),
+      _makeFileUri: dart.functionType(dart.dynamic, [String]),
+      _makeWindowsFileUrl: dart.functionType(dart.dynamic, [String]),
+      _makePort: dart.functionType(int, [int, String]),
+      _makeHost: dart.functionType(String, [String, int, int, bool]),
+      _isRegNameChar: dart.functionType(bool, [int]),
+      _normalizeRegName: dart.functionType(String, [String, int, int]),
+      _makeScheme: dart.functionType(String, [String, int]),
+      _makeUserInfo: dart.functionType(String, [String, int, int]),
+      _makePath: dart.functionType(String, [String, int, int, Iterable$(String), bool, bool]),
+      _makeQuery: dart.functionType(String, [String, int, int, Map$(String, String)]),
+      _makeFragment: dart.functionType(String, [String, int, int]),
+      _stringOrNullLength: dart.functionType(int, [String]),
+      _isHexDigit: dart.functionType(bool, [int]),
+      _hexValue: dart.functionType(int, [int]),
+      _normalizeEscape: dart.functionType(String, [String, int, bool]),
+      _isUnreservedChar: dart.functionType(bool, [int]),
+      _escapeChar: dart.functionType(String, [dart.dynamic]),
+      _normalize: dart.functionType(String, [String, int, int, List$(int)]),
+      _isSchemeCharacter: dart.functionType(bool, [int]),
+      _isGeneralDelimiter: dart.functionType(bool, [int]),
+      _addIfNonEmpty: dart.functionType(dart.void, [StringBuffer, String, String, String]),
+      encodeComponent: dart.functionType(String, [String]),
+      encodeQueryComponent: dart.functionType(String, [String], {ncodin: convert.Encoding}),
+      decodeComponent: dart.functionType(String, [String]),
+      decodeQueryComponent: dart.functionType(String, [String], {ncodin: convert.Encoding}),
+      encodeFull: dart.functionType(String, [String]),
+      decodeFull: dart.functionType(String, [String]),
+      splitQueryString: dart.functionType(Map$(String, String), [String], {ncodin: convert.Encoding}),
+      parseIPv4Address: dart.functionType(List$(int), [String]),
+      parseIPv6Address: dart.functionType(List$(int), [String], [int, int]),
+      _uriEncode: dart.functionType(String, [List$(int), String], {ncodin: convert.Encoding, paceToPlu: bool}),
+      _hexCharPairToByte: dart.functionType(int, [String, int]),
+      _uriDecode: dart.functionType(String, [String], {lusToSpac: bool, ncodin: convert.Encoding}),
+      _isAlphabeticCharacter: dart.functionType(bool, [int])
+    }),
+    names: ['_defaultPort', 'parse', '_fail', '_makeHttpUri', '_checkNonWindowsPathReservedCharacters', '_checkWindowsPathReservedCharacters', '_checkWindowsDriveLetter', '_makeFileUri', '_makeWindowsFileUrl', '_makePort', '_makeHost', '_isRegNameChar', '_normalizeRegName', '_makeScheme', '_makeUserInfo', '_makePath', '_makeQuery', '_makeFragment', '_stringOrNullLength', '_isHexDigit', '_hexValue', '_normalizeEscape', '_isUnreservedChar', '_escapeChar', '_normalize', '_isSchemeCharacter', '_isGeneralDelimiter', '_addIfNonEmpty', 'encodeComponent', 'encodeQueryComponent', 'decodeComponent', 'decodeQueryComponent', 'encodeFull', 'decodeFull', 'splitQueryString', 'parseIPv4Address', 'parseIPv6Address', '_uriEncode', '_hexCharPairToByte', '_uriDecode', '_isAlphabeticCharacter']
+  });
   Uri._SPACE = 32;
   Uri._DOUBLE_QUOTE = 34;
   Uri._NUMBER_SIGN = 35;
   Uri._PERCENT = 37;
   Uri._ASTERISK = 42;
   Uri._PLUS = 43;
   Uri._DOT = 46;
   Uri._SLASH = 47;
   Uri._ZERO = 48;
   Uri._NINE = 57;
@@ skipping 17 matching lines @@
   Uri._encodeFullTable = dart.const([0, 0, 65498, 45055, 65535, 34815, 65534, 18431]);
   Uri._schemeTable = dart.const([0, 0, 26624, 1023, 65534, 2047, 65534, 2047]);
   Uri._schemeLowerTable = dart.const([0, 0, 26624, 1023, 0, 0, 65534, 2047]);
   Uri._subDelimitersTable = dart.const([0, 0, 32722, 11263, 65534, 34815, 65534, 18431]);
   Uri._genDelimitersTable = dart.const([0, 0, 32776, 33792, 1, 10240, 0, 0]);
   Uri._userinfoTable = dart.const([0, 0, 32722, 12287, 65534, 34815, 65534, 18431]);
   Uri._regNameTable = dart.const([0, 0, 32754, 11263, 65534, 34815, 65534, 18431]);
   Uri._pathCharTable = dart.const([0, 0, 32722, 12287, 65535, 34815, 65534, 18431]);
   Uri._pathCharOrSlashTable = dart.const([0, 0, 65490, 12287, 65535, 34815, 65534, 18431]);
   Uri._queryCharTable = dart.const([0, 0, 65490, 45055, 65535, 34815, 65534, 18431]);
-  // Function _symbolToString: (Symbol) → String
   function _symbolToString(symbol) {
     return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
   }
-  // Function _symbolMapToStringMap: (Map<Symbol, dynamic>) → dynamic
+  dart.fn(_symbolToString, String, [Symbol]);
   function _symbolMapToStringMap(map) {
     if (map == null)
       return null;
     let result = new (Map$(String, dart.dynamic))();
-    map.forEach((key, value) => {
+    map.forEach(dart.fn((key, value) => {
       result.set(_symbolToString(key), value);
-    });
+    }, dart.dynamic, [Symbol, dart.dynamic]));
     return result;
   }
+  dart.fn(_symbolMapToStringMap, dart.dynamic, [Map$(Symbol, dart.dynamic)]);
   class SupportJsExtensionMethods extends Object {
     SupportJsExtensionMethods() {
     }
   }
+  dart.setSignature(SupportJsExtensionMethods, {});
   class _ListConstructorSentinel extends Object {
     _ListConstructorSentinel() {
     }
   }
+  dart.setSignature(_ListConstructorSentinel, {});
   // Exports:
   exports.Object = Object;
   exports.JsName = JsName;
   exports.JsPeerInterface = JsPeerInterface;
   exports.SupportJsExtensionMethod = SupportJsExtensionMethod;
   exports.Deprecated = Deprecated;
   exports.deprecated = deprecated;
   exports.override = override;
   exports.proxy = proxy;
   exports.bool = bool;
@@ skipping 110 matching lines @@
   exports.StackTrace = StackTrace;
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
   exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
   exports.SupportJsExtensionMethods = SupportJsExtensionMethods;
-})(core, _js_helper, _internal, collection, _interceptors, convert);
+})(core, _js_helper, _internal, collection, _interceptors, math, convert);