Use short array syntax in method signatures

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _js_helper = dart.lazyImport(_js_helper);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _js_helper, _isolate_helper, collection) {
   'use strict';
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
@@ skipping 15 matching lines @@
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
       return dart.toString(this.error);
     }
   }
   AsyncError[dart.implements] = () => [core.Error];
   dart.setSignature(AsyncError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _UncaughtAsyncError._getBestStackTrace(error, stackTrace));
     }
     static _getBestStackTrace(error, stackTrace) {
       if (stackTrace != null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace != null) {
         result = dart.notNull(result) + `\nStack Trace:\n${this.stackTrace}`;
       }
       return result;
     }
   }
   dart.setSignature(_UncaughtAsyncError, {
-    methods: () => ({toString: dart.functionType(core.String, [])}),
-    statics: () => ({_getBestStackTrace: dart.functionType(core.StackTrace, [dart.dynamic, core.StackTrace])}),
+    methods: () => ({toString: [core.String, []]}),
+    statics: () => ({_getBestStackTrace: [core.StackTrace, [dart.dynamic, core.StackTrace]]}),
     names: ['_getBestStackTrace']
   });
   let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let _add = Symbol('_add');
   let _closeUnchecked = Symbol('_closeUnchecked');
   let _addError = Symbol('_addError');
   let _completeError = Symbol('_completeError');
   let _complete = Symbol('_complete');
   let _sink = Symbol('_sink');
   let Stream$ = dart.generic(function(T) {
@@ skipping 646 matching lines @@
         }), onCancel);
         return controller.stream;
       }
     }
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     dart.setSignature(Stream, {
       methods: () => ({
-        asBroadcastStream: dart.functionType(Stream$(T), [], {nListe: dart.functionType(dart.void, [StreamSubscription$(T)]), nCance: dart.functionType(dart.void, [StreamSubscription$(T)])}),
-        where: dart.functionType(Stream$(T), [dart.functionType(core.bool, [T])]),
-        map: dart.functionType(Stream$(), [dart.functionType(dart.dynamic, [T])]),
-        asyncMap: dart.functionType(Stream$(), [dart.functionType(dart.dynamic, [T])]),
-        asyncExpand: dart.functionType(Stream$(), [dart.functionType(Stream$(), [T])]),
-        handleError: dart.functionType(Stream$(T), [core.Function], {es: dart.functionType(core.bool, [dart.dynamic])}),
-        expand: dart.functionType(Stream$(), [dart.functionType(core.Iterable, [T])]),
-        pipe: dart.functionType(Future, [StreamConsumer$(T)]),
-        transform: dart.functionType(Stream$(), [StreamTransformer$(T, dart.dynamic)]),
-        reduce: dart.functionType(Future$(T), [dart.functionType(T, [T, T])]),
-        fold: dart.functionType(Future, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, T])]),
-        join: dart.functionType(Future$(core.String), [], [core.String]),
-        contains: dart.functionType(Future$(core.bool), [core.Object]),
-        forEach: dart.functionType(Future, [dart.functionType(dart.void, [T])]),
-        every: dart.functionType(Future$(core.bool), [dart.functionType(core.bool, [T])]),
-        any: dart.functionType(Future$(core.bool), [dart.functionType(core.bool, [T])]),
-        toList: dart.functionType(Future$(core.List$(T)), []),
-        toSet: dart.functionType(Future$(core.Set$(T)), []),
-        drain: dart.functionType(Future, [], [dart.dynamic]),
-        take: dart.functionType(Stream$(T), [core.int]),
-        takeWhile: dart.functionType(Stream$(T), [dart.functionType(core.bool, [T])]),
-        skip: dart.functionType(Stream$(T), [core.int]),
-        skipWhile: dart.functionType(Stream$(T), [dart.functionType(core.bool, [T])]),
-        distinct: dart.functionType(Stream$(T), [], [dart.functionType(core.bool, [T, T])]),
-        firstWhere: dart.functionType(Future, [dart.functionType(core.bool, [T])], {efaultValu: dart.functionType(core.Object, [])}),
-        lastWhere: dart.functionType(Future, [dart.functionType(core.bool, [T])], {efaultValu: dart.functionType(core.Object, [])}),
-        singleWhere: dart.functionType(Future$(T), [dart.functionType(core.bool, [T])]),
-        elementAt: dart.functionType(Future$(T), [core.int]),
-        timeout: dart.functionType(Stream$(), [core.Duration], {nTimeou: dart.functionType(dart.void, [EventSink])})
+        asBroadcastStream: [Stream$(T), [], {nListe: dart.functionType(dart.void, [StreamSubscription$(T)]), nCance: dart.functionType(dart.void, [StreamSubscription$(T)])}],
+        where: [Stream$(T), [dart.functionType(core.bool, [T])]],
+        map: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
+        asyncMap: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
+        asyncExpand: [Stream$(), [dart.functionType(Stream$(), [T])]],
+        handleError: [Stream$(T), [core.Function], {es: dart.functionType(core.bool, [dart.dynamic])}],
+        expand: [Stream$(), [dart.functionType(core.Iterable, [T])]],
+        pipe: [Future, [StreamConsumer$(T)]],
+        transform: [Stream$(), [StreamTransformer$(T, dart.dynamic)]],
+        reduce: [Future$(T), [dart.functionType(T, [T, T])]],
+        fold: [Future, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, T])]],
+        join: [Future$(core.String), [], [core.String]],
+        contains: [Future$(core.bool), [core.Object]],
+        forEach: [Future, [dart.functionType(dart.void, [T])]],
+        every: [Future$(core.bool), [dart.functionType(core.bool, [T])]],
+        any: [Future$(core.bool), [dart.functionType(core.bool, [T])]],
+        toList: [Future$(core.List$(T)), []],
+        toSet: [Future$(core.Set$(T)), []],
+        drain: [Future, [], [dart.dynamic]],
+        take: [Stream$(T), [core.int]],
+        takeWhile: [Stream$(T), [dart.functionType(core.bool, [T])]],
+        skip: [Stream$(T), [core.int]],
+        skipWhile: [Stream$(T), [dart.functionType(core.bool, [T])]],
+        distinct: [Stream$(T), [], [dart.functionType(core.bool, [T, T])]],
+        firstWhere: [Future, [dart.functionType(core.bool, [T])], {efaultValu: dart.functionType(core.Object, [])}],
+        lastWhere: [Future, [dart.functionType(core.bool, [T])], {efaultValu: dart.functionType(core.Object, [])}],
+        singleWhere: [Future$(T), [dart.functionType(core.bool, [T])]],
+        elementAt: [Future$(T), [core.int]],
+        timeout: [Stream$(), [core.Duration], {nTimeou: dart.functionType(dart.void, [EventSink])}]
       })
     });
     return Stream;
   });
   let Stream = Stream$();
   let _createSubscription = Symbol('_createSubscription');
   let _onListen = Symbol('_onListen');
   let _StreamImpl$ = dart.generic(function(T) {
     class _StreamImpl extends Stream$(T) {
       _StreamImpl() {
@@ skipping 12 matching lines @@
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return new (_BufferingStreamSubscription$(T))(onData, onError, onDone, cancelOnError);
       }
       [_onListen](subscription) {}
     }
     dart.setSignature(_StreamImpl, {
       methods: () => ({
-        listen: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}),
-        [_createSubscription]: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]),
-        [_onListen]: dart.functionType(dart.void, [StreamSubscription])
+        listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}],
+        [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
+        [_onListen]: [dart.void, [StreamSubscription]]
       })
     });
     return _StreamImpl;
   });
   let _StreamImpl = _StreamImpl$();
   let _controller = Symbol('_controller');
   let _subscribe = Symbol('_subscribe');
   let _ControllerStream$ = dart.generic(function(T) {
     class _ControllerStream extends _StreamImpl$(T) {
       _ControllerStream(controller) {
@@ skipping 11 matching lines @@
         if (core.identical(this, other))
           return true;
         if (!dart.is(other, _ControllerStream$()))
           return false;
         let otherStream = dart.as(other, _ControllerStream$());
         return core.identical(otherStream[_controller], this[_controller]);
       }
     }
     dart.setSignature(_ControllerStream, {
       methods: () => ({
-        [_createSubscription]: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]),
-        '==': dart.functionType(core.bool, [core.Object])
+        [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
+        '==': [core.bool, [core.Object]]
       })
     });
     return _ControllerStream;
   });
   let _ControllerStream = _ControllerStream$();
   let _BroadcastStream$ = dart.generic(function(T) {
     class _BroadcastStream extends _ControllerStream$(T) {
       _BroadcastStream(controller) {
         super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$(T)));
       }
@@ skipping 342 matching lines @@
           wasInputPaused = isInputPaused;
         }
         if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
           this[_pending].schedule(this);
         }
       }
     }
     _BufferingStreamSubscription[dart.implements] = () => [StreamSubscription$(T), _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_BufferingStreamSubscription, {
       methods: () => ({
-        [_setPendingEvents]: dart.functionType(dart.void, [_PendingEvents]),
-        [_extractPending]: dart.functionType(_PendingEvents, []),
-        onData: dart.functionType(dart.void, [dart.functionType(dart.void, [T])]),
-        onError: dart.functionType(dart.void, [core.Function]),
-        onDone: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-        pause: dart.functionType(dart.void, [], [Future]),
-        resume: dart.functionType(dart.void, []),
-        cancel: dart.functionType(Future, []),
-        asFuture: dart.functionType(Future, [], [dart.dynamic]),
-        [_cancel]: dart.functionType(dart.void, []),
-        [_incrementPauseCount]: dart.functionType(dart.void, []),
-        [_decrementPauseCount]: dart.functionType(dart.void, []),
-        [_add]: dart.functionType(dart.void, [T]),
-        [_addError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_close]: dart.functionType(dart.void, []),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, []),
-        [_onCancel]: dart.functionType(Future, []),
-        [_addPending]: dart.functionType(dart.void, [_DelayedEvent]),
-        [_sendData]: dart.functionType(dart.void, [T]),
-        [_sendError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_sendDone]: dart.functionType(dart.void, []),
-        [_guardCallback]: dart.functionType(dart.void, [dart.dynamic]),
-        [_checkState]: dart.functionType(dart.void, [core.bool])
+        [_setPendingEvents]: [dart.void, [_PendingEvents]],
+        [_extractPending]: [_PendingEvents, []],
+        onData: [dart.void, [dart.functionType(dart.void, [T])]],
+        onError: [dart.void, [core.Function]],
+        onDone: [dart.void, [dart.functionType(dart.void, [])]],
+        pause: [dart.void, [], [Future]],
+        resume: [dart.void, []],
+        cancel: [Future, []],
+        asFuture: [Future, [], [dart.dynamic]],
+        [_cancel]: [dart.void, []],
+        [_incrementPauseCount]: [dart.void, []],
+        [_decrementPauseCount]: [dart.void, []],
+        [_add]: [dart.void, [T]],
+        [_addError]: [dart.void, [core.Object, core.StackTrace]],
+        [_close]: [dart.void, []],
+        [_onPause]: [dart.void, []],
+        [_onResume]: [dart.void, []],
+        [_onCancel]: [Future, []],
+        [_addPending]: [dart.void, [_DelayedEvent]],
+        [_sendData]: [dart.void, [T]],
+        [_sendError]: [dart.void, [core.Object, core.StackTrace]],
+        [_sendDone]: [dart.void, []],
+        [_guardCallback]: [dart.void, [dart.dynamic]],
+        [_checkState]: [dart.void, [core.bool]]
       })
     });
     return _BufferingStreamSubscription;
   });
   let _BufferingStreamSubscription = _BufferingStreamSubscription$();
   let _recordCancel = Symbol('_recordCancel');
   let _recordPause = Symbol('_recordPause');
   let _recordResume = Symbol('_recordResume');
   let _ControllerSubscription$ = dart.generic(function(T) {
     class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
       _ControllerSubscription(controller, onData, onError, onDone, cancelOnError) {
         this[_controller] = controller;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
         return this[_controller][_recordCancel](this);
       }
       [_onPause]() {
         this[_controller][_recordPause](this);
       }
       [_onResume]() {
         this[_controller][_recordResume](this);
       }
     }
     dart.setSignature(_ControllerSubscription, {
       methods: () => ({
-        [_onCancel]: dart.functionType(Future, []),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, [])
+        [_onCancel]: [Future, []],
+        [_onPause]: [dart.void, []],
+        [_onResume]: [dart.void, []]
       })
     });
     return _ControllerSubscription;
   });
   let _ControllerSubscription = _ControllerSubscription$();
   let _eventState = Symbol('_eventState');
   let _expectsEvent = Symbol('_expectsEvent');
   let _toggleEventId = Symbol('_toggleEventId');
   let _isFiring = Symbol('_isFiring');
   let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
@@ skipping 25 matching lines @@
       }
       get [_removeAfterFiring]() {
         return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription$()._STATE_REMOVE_AFTER_FIRING)) != 0;
       }
       [_onPause]() {}
       [_onResume]() {}
     }
     _BroadcastSubscription[dart.implements] = () => [_BroadcastSubscriptionLink];
     dart.setSignature(_BroadcastSubscription, {
       methods: () => ({
-        [_expectsEvent]: dart.functionType(core.bool, [core.int]),
-        [_toggleEventId]: dart.functionType(dart.void, []),
-        [_setRemoveAfterFiring]: dart.functionType(dart.void, []),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, [])
+        [_expectsEvent]: [core.bool, [core.int]],
+        [_toggleEventId]: [dart.void, []],
+        [_setRemoveAfterFiring]: [dart.void, []],
+        [_onPause]: [dart.void, []],
+        [_onResume]: [dart.void, []]
       })
     });
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$();
   _BroadcastSubscription._STATE_EVENT_ID = 1;
   _BroadcastSubscription._STATE_FIRING = 2;
   _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
   let _addStreamState = Symbol('_addStreamState');
   let _doneFuture = Symbol('_doneFuture');
@@ skipping 211 matching lines @@
         dart.assert(this[_isEmpty]);
         if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayComplete])) {
           this[_doneFuture][_asyncComplete](null);
         }
         _runGuarded(this[_onCancel]);
       }
     }
     _BroadcastStreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _BroadcastSubscriptionLink, _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_BroadcastStreamController, {
       methods: () => ({
-        [_ensureDoneFuture]: dart.functionType(_Future, []),
-        [_addListener]: dart.functionType(dart.void, [_BroadcastSubscription$(T)]),
-        [_removeListener]: dart.functionType(dart.void, [_BroadcastSubscription$(T)]),
-        [_subscribe]: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]),
-        [_recordCancel]: dart.functionType(Future, [StreamSubscription$(T)]),
-        [_recordPause]: dart.functionType(dart.void, [StreamSubscription$(T)]),
-        [_recordResume]: dart.functionType(dart.void, [StreamSubscription$(T)]),
-        [_addEventError]: dart.functionType(core.Error, []),
-        add: dart.functionType(dart.void, [T]),
-        addError: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
-        close: dart.functionType(Future, []),
-        addStream: dart.functionType(Future, [Stream$(T)], {ancelOnErro: core.bool}),
-        [_add]: dart.functionType(dart.void, [T]),
-        [_addError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_close]: dart.functionType(dart.void, []),
-        [_forEachListener]: dart.functionType(dart.void, [dart.functionType(dart.void, [_BufferingStreamSubscription$(T)])]),
-        [_callOnCancel]: dart.functionType(dart.void, [])
+        [_ensureDoneFuture]: [_Future, []],
+        [_addListener]: [dart.void, [_BroadcastSubscription$(T)]],
+        [_removeListener]: [dart.void, [_BroadcastSubscription$(T)]],
+        [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
+        [_recordCancel]: [Future, [StreamSubscription$(T)]],
+        [_recordPause]: [dart.void, [StreamSubscription$(T)]],
+        [_recordResume]: [dart.void, [StreamSubscription$(T)]],
+        [_addEventError]: [core.Error, []],
+        add: [dart.void, [T]],
+        addError: [dart.void, [core.Object], [core.StackTrace]],
+        close: [Future, []],
+        addStream: [Future, [Stream$(T)], {ancelOnErro: core.bool}],
+        [_add]: [dart.void, [T]],
+        [_addError]: [dart.void, [core.Object, core.StackTrace]],
+        [_close]: [dart.void, []],
+        [_forEachListener]: [dart.void, [dart.functionType(dart.void, [_BufferingStreamSubscription$(T)])]],
+        [_callOnCancel]: [dart.void, []]
       })
     });
     return _BroadcastStreamController;
   });
   let _BroadcastStreamController = _BroadcastStreamController$();
   _BroadcastStreamController._STATE_INITIAL = 0;
   _BroadcastStreamController._STATE_EVENT_ID = 1;
   _BroadcastStreamController._STATE_FIRING = 2;
   _BroadcastStreamController._STATE_CLOSED = 4;
   _BroadcastStreamController._STATE_ADDSTREAM = 8;
@@ skipping 37 matching lines @@
           }, dart.dynamic, [_BroadcastSubscription$(T)]), __CastType2));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     dart.setSignature(_SyncBroadcastStreamController, {
       methods: () => ({
-        [_sendData]: dart.functionType(dart.void, [T]),
-        [_sendError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_sendDone]: dart.functionType(dart.void, [])
+        [_sendData]: [dart.void, [T]],
+        [_sendError]: [dart.void, [core.Object, core.StackTrace]],
+        [_sendDone]: [dart.void, []]
       })
     });
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
   let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
     class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _AsyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
@@ skipping 18 matching lines @@
           }
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     dart.setSignature(_AsyncBroadcastStreamController, {
       methods: () => ({
-        [_sendData]: dart.functionType(dart.void, [T]),
-        [_sendError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_sendDone]: dart.functionType(dart.void, [])
+        [_sendData]: [dart.void, [T]],
+        [_sendError]: [dart.void, [core.Object, core.StackTrace]],
+        [_sendDone]: [dart.void, []]
       })
     });
     return _AsyncBroadcastStreamController;
   });
   let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
   let _addPendingEvent = Symbol('_addPendingEvent');
   let _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
         this[_pending] = null;
@@ skipping 47 matching lines @@
         if (this[_hasPending]) {
           this[_pending].clear();
           this[_pending] = null;
         }
         super[_callOnCancel]();
       }
     }
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     dart.setSignature(_AsBroadcastStreamController, {
       methods: () => ({
-        [_addPendingEvent]: dart.functionType(dart.void, [_DelayedEvent]),
-        add: dart.functionType(dart.void, [T]),
-        addError: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
-        close: dart.functionType(Future, []),
-        [_callOnCancel]: dart.functionType(dart.void, [])
+        [_addPendingEvent]: [dart.void, [_DelayedEvent]],
+        add: [dart.void, [T]],
+        addError: [dart.void, [core.Object], [core.StackTrace]],
+        close: [Future, []],
+        [_callOnCancel]: [dart.void, []]
       })
     });
     return _AsBroadcastStreamController;
   });
   let _AsBroadcastStreamController = _AsBroadcastStreamController$();
   let _pauseCount = Symbol('_pauseCount');
   let _resume = Symbol('_resume');
   let _DoneSubscription$ = dart.generic(function(T) {
     class _DoneSubscription extends core.Object {
       _DoneSubscription() {
@@ skipping 29 matching lines @@
       }
       asFuture(value) {
         if (value === void 0)
           value = null;
         return new _Future();
       }
     }
     _DoneSubscription[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_DoneSubscription, {
       methods: () => ({
-        onData: dart.functionType(dart.void, [dart.functionType(dart.void, [T])]),
-        onError: dart.functionType(dart.void, [core.Function]),
-        onDone: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-        pause: dart.functionType(dart.void, [], [Future]),
-        resume: dart.functionType(dart.void, []),
-        [_resume]: dart.functionType(dart.void, [dart.dynamic]),
-        cancel: dart.functionType(Future, []),
-        asFuture: dart.functionType(Future, [], [core.Object])
+        onData: [dart.void, [dart.functionType(dart.void, [T])]],
+        onError: [dart.void, [core.Function]],
+        onDone: [dart.void, [dart.functionType(dart.void, [])]],
+        pause: [dart.void, [], [Future]],
+        resume: [dart.void, []],
+        [_resume]: [dart.void, [dart.dynamic]],
+        cancel: [Future, []],
+        asFuture: [Future, [], [core.Object]]
       })
     });
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$();
   let __CastType2$ = dart.generic(function(T) {
     let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
     return __CastType2;
   });
   let __CastType2 = __CastType2$();
   class DeferredLibrary extends core.Object {
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
       this.libraryName = libraryName;
       this.uri = uri;
     }
     load() {
       throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.';
     }
   }
   dart.setSignature(DeferredLibrary, {
-    methods: () => ({load: dart.functionType(Future$(core.Null), [])})
+    methods: () => ({load: [Future$(core.Null), []]})
   });
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s) {
       this[_s] = s;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
   dart.setSignature(DeferredLoadException, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   let _completeWithValue = Symbol('_completeWithValue');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new (_Future$(T))();
         Timer.run(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
@@ skipping 145 matching lines @@
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.setSignature(Future, {
       statics: () => ({
-        wait: dart.functionType(Future$(core.List), [core.Iterable$(Future$())], {agerErro: core.bool, leanU: dart.functionType(dart.void, [dart.dynamic])}),
-        forEach: dart.functionType(Future$(), [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]),
-        doWhile: dart.functionType(Future$(), [dart.functionType(dart.dynamic, [])])
+        wait: [Future$(core.List), [core.Iterable$(Future$())], {agerErro: core.bool, leanU: dart.functionType(dart.void, [dart.dynamic])}],
+        forEach: [Future$(), [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]],
+        doWhile: [Future$(), [dart.functionType(dart.dynamic, [])]]
       }),
       names: ['wait', 'forEach', 'doWhile']
     });
     return Future;
   });
   let Future = Future$();
   dart.defineLazyProperties(Future, {
     get _nullFuture() {
       return new _Future.immediate(null);
     }
   });
   class TimeoutException extends core.Object {
     TimeoutException(message, duration) {
       if (duration === void 0)
         duration = null;
       this.message = message;
       this.duration = duration;
     }
     toString() {
       let result = "TimeoutException";
       if (this.duration != null)
         result = `TimeoutException after ${this.duration}`;
       if (this.message != null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
   TimeoutException[dart.implements] = () => [core.Exception];
   dart.setSignature(TimeoutException, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
         return new (_AsyncCompleter$(T))();
       }
       sync() {
         return new (_SyncCompleter$(T))();
       }
     }
@@ skipping 40 matching lines @@
           stackTrace = replacement.stackTrace;
         }
         this[_completeError](error, stackTrace);
       }
       get isCompleted() {
         return !dart.notNull(this.future[_mayComplete]);
       }
     }
     _Completer[dart.implements] = () => [Completer$(T)];
     dart.setSignature(_Completer, {
-      methods: () => ({completeError: dart.functionType(dart.void, [core.Object], [core.StackTrace])})
+      methods: () => ({completeError: [dart.void, [core.Object], [core.StackTrace]]})
     });
     return _Completer;
   });
   let _Completer = _Completer$();
   let _asyncCompleteError = Symbol('_asyncCompleteError');
   let _AsyncCompleter$ = dart.generic(function(T) {
     class _AsyncCompleter extends _Completer$(T) {
       _AsyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
         this.future[_asyncComplete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_asyncCompleteError](error, stackTrace);
       }
     }
     dart.setSignature(_AsyncCompleter, {
       methods: () => ({
-        complete: dart.functionType(dart.void, [], [dart.dynamic]),
-        [_completeError]: dart.functionType(dart.void, [core.Object, core.StackTrace])
+        complete: [dart.void, [], [dart.dynamic]],
+        [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _AsyncCompleter;
   });
   let _AsyncCompleter = _AsyncCompleter$();
   let _SyncCompleter$ = dart.generic(function(T) {
     class _SyncCompleter extends _Completer$(T) {
       _SyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
         this.future[_complete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_completeError](error, stackTrace);
       }
     }
     dart.setSignature(_SyncCompleter, {
       methods: () => ({
-        complete: dart.functionType(dart.void, [], [dart.dynamic]),
-        [_completeError]: dart.functionType(dart.void, [core.Object, core.StackTrace])
+        complete: [dart.void, [], [dart.dynamic]],
+        [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _SyncCompleter;
   });
   let _SyncCompleter = _SyncCompleter$();
   let _nextListener = Symbol('_nextListener');
   let _onValue = Symbol('_onValue');
   let _errorTest = Symbol('_errorTest');
   let _whenCompleteAction = Symbol('_whenCompleteAction');
   class _FutureListener extends core.Object {
@@ skipping 499 matching lines @@
             }
           })});
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
     dart.setSignature(_Future, {
       methods: () => ({
-        then: dart.functionType(Future, [dart.functionType(dart.dynamic, [T])], {nErro: core.Function}),
-        catchError: dart.functionType(Future, [core.Function], {es: dart.functionType(core.bool, [dart.dynamic])}),
-        whenComplete: dart.functionType(Future$(T), [dart.functionType(dart.dynamic, [])]),
-        asStream: dart.functionType(Stream$(T), []),
-        [_markPendingCompletion]: dart.functionType(dart.void, []),
-        [_setValue]: dart.functionType(dart.void, [T]),
-        [_setErrorObject]: dart.functionType(dart.void, [AsyncError]),
-        [_setError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_addListener]: dart.functionType(dart.void, [_FutureListener]),
-        [_removeListeners]: dart.functionType(_FutureListener, []),
-        [_complete]: dart.functionType(dart.void, [dart.dynamic]),
-        [_completeWithValue]: dart.functionType(dart.void, [dart.dynamic]),
-        [_completeError]: dart.functionType(dart.void, [dart.dynamic], [core.StackTrace]),
-        [_asyncComplete]: dart.functionType(dart.void, [dart.dynamic]),
-        [_asyncCompleteError]: dart.functionType(dart.void, [dart.dynamic, core.StackTrace]),
-        timeout: dart.functionType(Future, [core.Duration], {nTimeou: dart.functionType(dart.dynamic, [])})
+        then: [Future, [dart.functionType(dart.dynamic, [T])], {nErro: core.Function}],
+        catchError: [Future, [core.Function], {es: dart.functionType(core.bool, [dart.dynamic])}],
+        whenComplete: [Future$(T), [dart.functionType(dart.dynamic, [])]],
+        asStream: [Stream$(T), []],
+        [_markPendingCompletion]: [dart.void, []],
+        [_setValue]: [dart.void, [T]],
+        [_setErrorObject]: [dart.void, [AsyncError]],
+        [_setError]: [dart.void, [core.Object, core.StackTrace]],
+        [_addListener]: [dart.void, [_FutureListener]],
+        [_removeListeners]: [_FutureListener, []],
+        [_complete]: [dart.void, [dart.dynamic]],
+        [_completeWithValue]: [dart.void, [dart.dynamic]],
+        [_completeError]: [dart.void, [dart.dynamic], [core.StackTrace]],
+        [_asyncComplete]: [dart.void, [dart.dynamic]],
+        [_asyncCompleteError]: [dart.void, [dart.dynamic, core.StackTrace]],
+        timeout: [Future, [core.Duration], {nTimeou: dart.functionType(dart.dynamic, [])}]
       }),
       statics: () => ({
-        _chainForeignFuture: dart.functionType(dart.void, [Future, _Future$()]),
-        _chainCoreFuture: dart.functionType(dart.void, [_Future$(), _Future$()]),
-        _propagateToListeners: dart.functionType(dart.void, [_Future$(), _FutureListener])
+        _chainForeignFuture: [dart.void, [Future, _Future$()]],
+        _chainCoreFuture: [dart.void, [_Future$(), _Future$()]],
+        _propagateToListeners: [dart.void, [_Future$(), _FutureListener]]
       }),
       names: ['_chainForeignFuture', '_chainCoreFuture', '_propagateToListeners']
     });
     return _Future;
   });
   let _Future = _Future$();
   _Future._INCOMPLETE = 0;
   _Future._PENDING_COMPLETE = 1;
   _Future._CHAINED = 2;
   _Future._VALUE = 4;
@@ skipping 132 matching lines @@
       ;
       _isolate_helper.enterJsAsync();
       self.setImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
     static _scheduleImmediateWithTimer(callback) {
       Timer._createTimer(core.Duration.ZERO, callback);
     }
   }
   dart.setSignature(_AsyncRun, {
     statics: () => ({
-      _scheduleImmediate: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-      _initializeScheduleImmediate: dart.functionType(core.Function, []),
-      _scheduleImmediateJsOverride: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-      _scheduleImmediateWithSetImmediate: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-      _scheduleImmediateWithTimer: dart.functionType(dart.void, [dart.functionType(dart.void, [])])
+      _scheduleImmediate: [dart.void, [dart.functionType(dart.void, [])]],
+      _initializeScheduleImmediate: [core.Function, []],
+      _scheduleImmediateJsOverride: [dart.void, [dart.functionType(dart.void, [])]],
+      _scheduleImmediateWithSetImmediate: [dart.void, [dart.functionType(dart.void, [])]],
+      _scheduleImmediateWithTimer: [dart.void, [dart.functionType(dart.void, [])]]
     }),
     names: ['_scheduleImmediate', '_initializeScheduleImmediate', '_scheduleImmediateJsOverride', '_scheduleImmediateWithSetImmediate', '_scheduleImmediateWithTimer']
   });
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
       return _AsyncRun._initializeScheduleImmediate();
     }
   });
   let StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {}
@@ skipping 29 matching lines @@
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         return this[_stream].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
       }
     }
     dart.setSignature(StreamView, {
       methods: () => ({
-        asBroadcastStream: dart.functionType(Stream$(T), [], {nListe: dart.functionType(dart.void, [StreamSubscription$(T)]), nCance: dart.functionType(dart.void, [StreamSubscription$(T)])}),
-        listen: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool})
+        asBroadcastStream: [Stream$(T), [], {nListe: dart.functionType(dart.void, [StreamSubscription$(T)]), nCance: dart.functionType(dart.void, [StreamSubscription$(T)])}],
+        listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}]
       })
     });
     return StreamView;
   });
   let StreamView = StreamView$();
   let StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {}
     dart.setSignature(StreamConsumer, {});
     return StreamConsumer;
   });
@@ skipping 43 matching lines @@
           stackTrace = null;
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_ControllerEventSinkWrapper, {
       methods: () => ({
-        add: dart.functionType(dart.void, [T]),
-        addError: dart.functionType(dart.void, [dart.dynamic], [core.StackTrace]),
-        close: dart.functionType(dart.void, [])
+        add: [dart.void, [T]],
+        addError: [dart.void, [dart.dynamic], [core.StackTrace]],
+        close: [dart.void, []]
       })
     });
     return _ControllerEventSinkWrapper;
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
   let __CastType12 = dart.typedef('__CastType12', () => dart.functionType(dart.void, [StreamSubscription]));
   let __CastType14 = dart.typedef('__CastType14', () => dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]));
   let __CastType17 = dart.typedef('__CastType17', () => dart.functionType(dart.void, []));
   let __CastType18 = dart.typedef('__CastType18', () => dart.functionType(dart.void, [EventSink]));
   let StreamController$ = dart.generic(function(T) {
@@ skipping 30 matching lines @@
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         return null;
       }
     }
     dart.setSignature(_StreamControllerLifecycle, {
       methods: () => ({
-        [_recordPause]: dart.functionType(dart.void, [StreamSubscription$(T)]),
-        [_recordResume]: dart.functionType(dart.void, [StreamSubscription$(T)]),
-        [_recordCancel]: dart.functionType(Future, [StreamSubscription$(T)])
+        [_recordPause]: [dart.void, [StreamSubscription$(T)]],
+        [_recordResume]: [dart.void, [StreamSubscription$(T)]],
+        [_recordCancel]: [Future, [StreamSubscription$(T)]]
       })
     });
     return _StreamControllerLifecycle;
   });
   let _StreamControllerLifecycle = _StreamControllerLifecycle$();
   let _varData = Symbol('_varData');
   let _isInitialState = Symbol('_isInitialState');
   let _subscription = Symbol('_subscription');
   let _pendingEvents = Symbol('_pendingEvents');
   let _ensurePendingEvents = Symbol('_ensurePendingEvents');
@@ skipping 217 matching lines @@
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.resume();
         }
         _runGuarded(this[_onResume]);
       }
     }
     _StreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_StreamController, {
       methods: () => ({
-        [_ensurePendingEvents]: dart.functionType(_StreamImplEvents, []),
-        [_badEventState]: dart.functionType(core.Error, []),
-        addStream: dart.functionType(Future, [Stream$(T)], {ancelOnErro: core.bool}),
-        [_ensureDoneFuture]: dart.functionType(Future, []),
-        add: dart.functionType(dart.void, [T]),
-        addError: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
-        close: dart.functionType(Future, []),
-        [_closeUnchecked]: dart.functionType(dart.void, []),
-        [_add]: dart.functionType(dart.void, [T]),
-        [_addError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_close]: dart.functionType(dart.void, []),
-        [_subscribe]: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]),
-        [_recordCancel]: dart.functionType(Future, [StreamSubscription$(T)]),
-        [_recordPause]: dart.functionType(dart.void, [StreamSubscription$(T)]),
-        [_recordResume]: dart.functionType(dart.void, [StreamSubscription$(T)])
+        [_ensurePendingEvents]: [_StreamImplEvents, []],
+        [_badEventState]: [core.Error, []],
+        addStream: [Future, [Stream$(T)], {ancelOnErro: core.bool}],
+        [_ensureDoneFuture]: [Future, []],
+        add: [dart.void, [T]],
+        addError: [dart.void, [core.Object], [core.StackTrace]],
+        close: [Future, []],
+        [_closeUnchecked]: [dart.void, []],
+        [_add]: [dart.void, [T]],
+        [_addError]: [dart.void, [core.Object, core.StackTrace]],
+        [_close]: [dart.void, []],
+        [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
+        [_recordCancel]: [Future, [StreamSubscription$(T)]],
+        [_recordPause]: [dart.void, [StreamSubscription$(T)]],
+        [_recordResume]: [dart.void, [StreamSubscription$(T)]]
       })
     });
     return _StreamController;
   });
   let _StreamController = _StreamController$();
   _StreamController._STATE_INITIAL = 0;
   _StreamController._STATE_SUBSCRIBED = 1;
   _StreamController._STATE_CANCELED = 2;
   _StreamController._STATE_SUBSCRIPTION_MASK = 3;
   _StreamController._STATE_CLOSED = 4;
   _StreamController._STATE_ADDSTREAM = 8;
   let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
         this[_subscription][_add](data);
       }
       [_sendError](error, stackTrace) {
         this[_subscription][_addError](error, stackTrace);
       }
       [_sendDone]() {
         this[_subscription][_close]();
       }
     }
     _SyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     dart.setSignature(_SyncStreamControllerDispatch, {
       methods: () => ({
-        [_sendData]: dart.functionType(dart.void, [T]),
-        [_sendError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_sendDone]: dart.functionType(dart.void, [])
+        [_sendData]: [dart.void, [T]],
+        [_sendError]: [dart.void, [core.Object, core.StackTrace]],
+        [_sendDone]: [dart.void, []]
       })
     });
     return _SyncStreamControllerDispatch;
   });
   let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$();
   let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _AsyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
         this[_subscription][_addPending](new _DelayedData(data));
       }
       [_sendError](error, stackTrace) {
         this[_subscription][_addPending](new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
         this[_subscription][_addPending](dart.const(new _DelayedDone()));
       }
     }
     _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     dart.setSignature(_AsyncStreamControllerDispatch, {
       methods: () => ({
-        [_sendData]: dart.functionType(dart.void, [T]),
-        [_sendError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_sendDone]: dart.functionType(dart.void, [])
+        [_sendData]: [dart.void, [T]],
+        [_sendError]: [dart.void, [core.Object, core.StackTrace]],
+        [_sendDone]: [dart.void, []]
       })
     });
     return _AsyncStreamControllerDispatch;
   });
   let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$();
   let _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
@@ skipping 76 matching lines @@
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         return this[_target].addStream(source, {cancelOnError: cancelOnError});
       }
       get done() {
         return this[_target].done;
       }
     }
     _StreamSinkWrapper[dart.implements] = () => [StreamSink$(T)];
     dart.setSignature(_StreamSinkWrapper, {
       methods: () => ({
-        add: dart.functionType(dart.void, [T]),
-        addError: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
-        close: dart.functionType(Future, []),
-        addStream: dart.functionType(Future, [Stream$(T)], {ancelOnErro: core.bool})
+        add: [dart.void, [T]],
+        addError: [dart.void, [core.Object], [core.StackTrace]],
+        close: [Future, []],
+        addStream: [Future, [Stream$(T)], {ancelOnErro: core.bool}]
       })
     });
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$();
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
         this.addSubscription = source.listen(dart.bind(controller, _add), {onError: cancelOnError ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : dart.bind(controller, _addError), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
@@ skipping 19 matching lines @@
         return cancel.whenComplete(dart.fn((() => {
           this.addStreamFuture[_asyncComplete](null);
         }).bind(this)));
       }
       complete() {
         this.addStreamFuture[_asyncComplete](null);
       }
     }
     dart.setSignature(_AddStreamState, {
       methods: () => ({
-        pause: dart.functionType(dart.void, []),
-        resume: dart.functionType(dart.void, []),
-        cancel: dart.functionType(Future, []),
-        complete: dart.functionType(dart.void, [])
+        pause: [dart.void, []],
+        resume: [dart.void, []],
+        cancel: [Future, []],
+        complete: [dart.void, []]
       }),
-      statics: () => ({makeErrorHandler: dart.functionType(dart.dynamic, [_EventSink])}),
+      statics: () => ({makeErrorHandler: [dart.dynamic, [_EventSink]]}),
       names: ['makeErrorHandler']
     });
     return _AddStreamState;
   });
   let _AddStreamState = _AddStreamState$();
   let _StreamControllerAddStreamState$ = dart.generic(function(T) {
     class _StreamControllerAddStreamState extends _AddStreamState$(T) {
       _StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
         this.varData = varData;
         super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
@@ skipping 42 matching lines @@
           throw new core.StateError("Stream has already been listened to.");
         this[_isUsed] = true;
         return dart.as((() => {
           let _ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
           _[_setPendingEvents](this[_pending]());
           return _;
         }).bind(this)(), StreamSubscription$(T));
       }
     }
     dart.setSignature(_GeneratedStreamImpl, {
-      methods: () => ({[_createSubscription]: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool])})
+      methods: () => ({[_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$();
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
       this[_state] = _PendingEvents._STATE_UNSCHEDULED;
     }
     get isScheduled() {
@@ skipping 20 matching lines @@
       }).bind(this)));
       this[_state] = _PendingEvents._STATE_SCHEDULED;
     }
     cancelSchedule() {
       if (this.isScheduled)
         this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
   dart.setSignature(_PendingEvents, {
     methods: () => ({
-      schedule: dart.functionType(dart.void, [_EventDispatch]),
-      cancelSchedule: dart.functionType(dart.void, [])
+      schedule: [dart.void, [_EventDispatch]],
+      cancelSchedule: [dart.void, []]
     })
   });
   let _iterator = Symbol('_iterator');
   let _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data[core.$iterator];
         super._PendingEvents();
       }
       get isEmpty() {
@@ skipping 21 matching lines @@
         }
       }
       clear() {
         if (this.isScheduled)
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
     dart.setSignature(_IterablePendingEvents, {
       methods: () => ({
-        handleNext: dart.functionType(dart.void, [_EventDispatch]),
-        clear: dart.functionType(dart.void, [])
+        handleNext: [dart.void, [_EventDispatch]],
+        clear: [dart.void, []]
       })
     });
     return _IterablePendingEvents;
   });
   let _IterablePendingEvents = _IterablePendingEvents$();
   let _DataHandler$ = dart.generic(function(T) {
     let _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
     return _DataHandler;
   });
   let _DataHandler = _DataHandler$();
@@ skipping 25 matching lines @@
       _DelayedData(value) {
         this.value = value;
         super._DelayedEvent();
       }
       perform(dispatch) {
         dart.as(dispatch, _EventDispatch$(T));
         dispatch[_sendData](this.value);
       }
     }
     dart.setSignature(_DelayedData, {
-      methods: () => ({perform: dart.functionType(dart.void, [_EventDispatch$(T)])})
+      methods: () => ({perform: [dart.void, [_EventDispatch$(T)]]})
     });
     return _DelayedData;
   });
   let _DelayedData = _DelayedData$();
   class _DelayedError extends _DelayedEvent {
     _DelayedError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
       super._DelayedEvent();
     }
     perform(dispatch) {
       dispatch[_sendError](this.error, this.stackTrace);
     }
   }
   dart.setSignature(_DelayedError, {
-    methods: () => ({perform: dart.functionType(dart.void, [_EventDispatch])})
+    methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
   class _DelayedDone extends core.Object {
     _DelayedDone() {
     }
     perform(dispatch) {
       dispatch[_sendDone]();
     }
     get next() {
       return null;
     }
     set next(_) {
       throw new core.StateError("No events after a done.");
     }
   }
   _DelayedDone[dart.implements] = () => [_DelayedEvent];
   dart.setSignature(_DelayedDone, {
-    methods: () => ({perform: dart.functionType(dart.void, [_EventDispatch])})
+    methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
   _PendingEvents._STATE_UNSCHEDULED = 0;
   _PendingEvents._STATE_SCHEDULED = 1;
   _PendingEvents._STATE_CANCELED = 3;
   class _StreamImplEvents extends _PendingEvents {
     _StreamImplEvents() {
       this.firstPendingEvent = null;
       this.lastPendingEvent = null;
       super._PendingEvents();
     }
@@ skipping 17 matching lines @@
       event.perform(dispatch);
     }
     clear() {
       if (this.isScheduled)
         this.cancelSchedule();
       this.firstPendingEvent = this.lastPendingEvent = null;
     }
   }
   dart.setSignature(_StreamImplEvents, {
     methods: () => ({
-      add: dart.functionType(dart.void, [_DelayedEvent]),
-      handleNext: dart.functionType(dart.void, [_EventDispatch]),
-      clear: dart.functionType(dart.void, [])
+      add: [dart.void, [_DelayedEvent]],
+      handleNext: [dart.void, [_EventDispatch]],
+      clear: [dart.void, []]
     })
   });
   let _unlink = Symbol('_unlink');
   let _insertBefore = Symbol('_insertBefore');
   class _BroadcastLinkedList extends core.Object {
     _BroadcastLinkedList() {
       this[_next] = null;
       this[_previous] = null;
     }
     [_unlink]() {
       this[_previous][_next] = this[_next];
       this[_next][_previous] = this[_previous];
       this[_next] = this[_previous] = this;
     }
     [_insertBefore](newNext) {
       let newPrevious = newNext[_previous];
       newPrevious[_next] = this;
       newNext[_previous] = this[_previous];
       this[_previous][_next] = newNext;
       this[_previous] = newPrevious;
     }
   }
   dart.setSignature(_BroadcastLinkedList, {
     methods: () => ({
-      [_unlink]: dart.functionType(dart.void, []),
-      [_insertBefore]: dart.functionType(dart.void, [_BroadcastLinkedList])
+      [_unlink]: [dart.void, []],
+      [_insertBefore]: [dart.void, [_BroadcastLinkedList]]
     })
   });
   let _broadcastCallback = dart.typedef('_broadcastCallback', () => dart.functionType(dart.void, [StreamSubscription]));
   let _schedule = Symbol('_schedule');
   let _isSent = Symbol('_isSent');
   let _isScheduled = Symbol('_isScheduled');
   let _DoneStreamSubscription$ = dart.generic(function(T) {
     class _DoneStreamSubscription extends core.Object {
       _DoneStreamSubscription(onDone) {
         this[_onDone] = onDone;
@@ skipping 56 matching lines @@
         if (this.isPaused)
           return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._DONE_SENT);
         if (this[_onDone] != null)
           this[_zone].runGuarded(this[_onDone]);
       }
     }
     _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_DoneStreamSubscription, {
       methods: () => ({
-        [_schedule]: dart.functionType(dart.void, []),
-        onData: dart.functionType(dart.void, [dart.functionType(dart.void, [T])]),
-        onError: dart.functionType(dart.void, [core.Function]),
-        onDone: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-        pause: dart.functionType(dart.void, [], [Future]),
-        resume: dart.functionType(dart.void, []),
-        cancel: dart.functionType(Future, []),
-        asFuture: dart.functionType(Future, [], [dart.dynamic]),
-        [_sendDone]: dart.functionType(dart.void, [])
+        [_schedule]: [dart.void, []],
+        onData: [dart.void, [dart.functionType(dart.void, [T])]],
+        onError: [dart.void, [core.Function]],
+        onDone: [dart.void, [dart.functionType(dart.void, [])]],
+        pause: [dart.void, [], [Future]],
+        resume: [dart.void, []],
+        cancel: [Future, []],
+        asFuture: [Future, [], [dart.dynamic]],
+        [_sendDone]: [dart.void, []]
       })
     });
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$();
   _DoneStreamSubscription._DONE_SENT = 1;
   _DoneStreamSubscription._SCHEDULED = 2;
   _DoneStreamSubscription._PAUSED = 4;
   let _source = Symbol('_source');
   let _onListenHandler = Symbol('_onListenHandler');
@@ skipping 68 matching lines @@
         this[_subscription].resume();
       }
       get [_isSubscriptionPaused]() {
         if (this[_subscription] == null)
           return false;
         return this[_subscription].isPaused;
       }
     }
     dart.setSignature(_AsBroadcastStream, {
       methods: () => ({
-        listen: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}),
-        [_onCancel]: dart.functionType(dart.void, []),
-        [_onListen]: dart.functionType(dart.void, []),
-        [_cancelSubscription]: dart.functionType(dart.void, []),
-        [_pauseSubscription]: dart.functionType(dart.void, [Future]),
-        [_resumeSubscription]: dart.functionType(dart.void, [])
+        listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}],
+        [_onCancel]: [dart.void, []],
+        [_onListen]: [dart.void, []],
+        [_cancelSubscription]: [dart.void, []],
+        [_pauseSubscription]: [dart.void, [Future]],
+        [_resumeSubscription]: [dart.void, []]
       })
     });
     return _AsBroadcastStream;
   });
   let _AsBroadcastStream = _AsBroadcastStream$();
   let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
     class _BroadcastSubscriptionWrapper extends core.Object {
       _BroadcastSubscriptionWrapper(stream) {
         this[_stream] = stream;
       }
@@ skipping 25 matching lines @@
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
     }
     _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_BroadcastSubscriptionWrapper, {
       methods: () => ({
-        onData: dart.functionType(dart.void, [dart.functionType(dart.void, [T])]),
-        onError: dart.functionType(dart.void, [core.Function]),
-        onDone: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-        pause: dart.functionType(dart.void, [], [Future]),
-        resume: dart.functionType(dart.void, []),
-        cancel: dart.functionType(Future, []),
-        asFuture: dart.functionType(Future, [], [dart.dynamic])
+        onData: [dart.void, [dart.functionType(dart.void, [T])]],
+        onError: [dart.void, [core.Function]],
+        onDone: [dart.void, [dart.functionType(dart.void, [])]],
+        pause: [dart.void, [], [Future]],
+        resume: [dart.void, []],
+        cancel: [Future, []],
+        asFuture: [Future, [], [dart.dynamic]]
       })
     });
     return _BroadcastSubscriptionWrapper;
   });
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _clear = Symbol('_clear');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
@@ skipping 98 matching lines @@
           return;
         }
         this[_subscription].pause();
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_DONE;
       }
     }
     _StreamIteratorImpl[dart.implements] = () => [StreamIterator$(T)];
     dart.setSignature(_StreamIteratorImpl, {
       methods: () => ({
-        moveNext: dart.functionType(Future$(core.bool), []),
-        [_clear]: dart.functionType(dart.void, []),
-        cancel: dart.functionType(Future, []),
-        [_onData]: dart.functionType(dart.void, [T]),
-        [_onError]: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
-        [_onDone]: dart.functionType(dart.void, [])
+        moveNext: [Future$(core.bool), []],
+        [_clear]: [dart.void, []],
+        cancel: [Future, []],
+        [_onData]: [dart.void, [T]],
+        [_onError]: [dart.void, [core.Object], [core.StackTrace]],
+        [_onDone]: [dart.void, []]
       })
     });
     return _StreamIteratorImpl;
   });
   let _StreamIteratorImpl = _StreamIteratorImpl$();
   _StreamIteratorImpl._STATE_FOUND = 0;
   _StreamIteratorImpl._STATE_DONE = 1;
   _StreamIteratorImpl._STATE_MOVING = 2;
   _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
   _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
@@ skipping 89 matching lines @@
         dart.as(sink, _EventSink$(T));
         sink[_addError](error, stackTrace);
       }
       [_handleDone](sink) {
         dart.as(sink, _EventSink$(T));
         sink[_close]();
       }
     }
     dart.setSignature(_ForwardingStream, {
       methods: () => ({
-        listen: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}),
-        [_createSubscription]: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]),
-        [_handleData]: dart.functionType(dart.void, [S, _EventSink$(T)]),
-        [_handleError]: dart.functionType(dart.void, [dart.dynamic, core.StackTrace, _EventSink$(T)]),
-        [_handleDone]: dart.functionType(dart.void, [_EventSink$(T)])
+        listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}],
+        [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
+        [_handleData]: [dart.void, [S, _EventSink$(T)]],
+        [_handleError]: [dart.void, [dart.dynamic, core.StackTrace, _EventSink$(T)]],
+        [_handleDone]: [dart.void, [_EventSink$(T)]]
       })
     });
     return _ForwardingStream;
   });
   let _ForwardingStream = _ForwardingStream$();
   let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
     class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
       _ForwardingStreamSubscription(stream, onData, onError, onDone, cancelOnError) {
         this[_stream] = stream;
         this[_subscription] = null;
@@ skipping 35 matching lines @@
       }
       [_handleError](error, stackTrace) {
         this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream][_handleDone](this);
       }
     }
     dart.setSignature(_ForwardingStreamSubscription, {
       methods: () => ({
-        [_add]: dart.functionType(dart.void, [T]),
-        [_addError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, []),
-        [_onCancel]: dart.functionType(Future, []),
-        [_handleData]: dart.functionType(dart.void, [S]),
-        [_handleError]: dart.functionType(dart.void, [dart.dynamic, core.StackTrace]),
-        [_handleDone]: dart.functionType(dart.void, [])
+        [_add]: [dart.void, [T]],
+        [_addError]: [dart.void, [core.Object, core.StackTrace]],
+        [_onPause]: [dart.void, []],
+        [_onResume]: [dart.void, []],
+        [_onCancel]: [Future, []],
+        [_handleData]: [dart.void, [S]],
+        [_handleError]: [dart.void, [dart.dynamic, core.StackTrace]],
+        [_handleDone]: [dart.void, []]
       })
     });
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
   let _Predicate$ = dart.generic(function(T) {
     let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
@@ skipping 24 matching lines @@
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         if (satisfies) {
           sink[_add](inputEvent);
         }
       }
     }
     dart.setSignature(_WhereStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [T, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _WhereStream;
   });
   let _WhereStream = _WhereStream$();
   let _Transformation$ = dart.generic(function(S, T) {
     let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
   let _transform = Symbol('_transform');
@@ skipping 12 matching lines @@
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         sink[_add](outputEvent);
       }
     }
     dart.setSignature(_MapStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [S, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _MapStream;
   });
   let _MapStream = _MapStream$();
   let _expand = Symbol('_expand');
   let _ExpandStream$ = dart.generic(function(S, T) {
     class _ExpandStream extends _ForwardingStream$(S, T) {
       _ExpandStream(source, expand) {
         this[_expand] = expand;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, S);
         dart.as(sink, _EventSink$(T));
         try {
           for (let value of this[_expand](inputEvent)) {
             sink[_add](value);
           }
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
         }
 
       }
     }
     dart.setSignature(_ExpandStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [S, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _ExpandStream;
   });
   let _ExpandStream = _ExpandStream$();
   let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
   let _HandleErrorStream$ = dart.generic(function(T) {
     class _HandleErrorStream extends _ForwardingStream$(T, T) {
       _HandleErrorStream(source, onError, test) {
         this[_transform] = onError;
         this[_test] = test;
@@ skipping 24 matching lines @@
             }
             return;
           }
 
         } else {
           sink[_addError](error, stackTrace);
         }
       }
     }
     dart.setSignature(_HandleErrorStream, {
-      methods: () => ({[_handleError]: dart.functionType(dart.void, [core.Object, core.StackTrace, _EventSink$(T)])})
+      methods: () => ({[_handleError]: [dart.void, [core.Object, core.StackTrace, _EventSink$(T)]]})
     });
     return _HandleErrorStream;
   });
   let _HandleErrorStream = _HandleErrorStream$();
   let _remaining = Symbol('_remaining');
   let _TakeStream$ = dart.generic(function(T) {
     class _TakeStream extends _ForwardingStream$(T, T) {
       _TakeStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number'))
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           sink[_add](inputEvent);
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           if (this[_remaining] == 0) {
             sink[_close]();
           }
         }
       }
     }
     dart.setSignature(_TakeStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [T, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeStream;
   });
   let _TakeStream = _TakeStream$();
   let _TakeWhileStream$ = dart.generic(function(T) {
     class _TakeWhileStream extends _ForwardingStream$(T, T) {
       _TakeWhileStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
@@ skipping 11 matching lines @@
         }
 
         if (satisfies) {
           sink[_add](inputEvent);
         } else {
           sink[_close]();
         }
       }
     }
     dart.setSignature(_TakeWhileStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [T, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeWhileStream;
   });
   let _TakeWhileStream = _TakeWhileStream$();
   let _SkipStream$ = dart.generic(function(T) {
     class _SkipStream extends _ForwardingStream$(T, T) {
       _SkipStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number') || dart.notNull(count) < 0)
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
         sink[_add](inputEvent);
       }
     }
     dart.setSignature(_SkipStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [T, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipStream;
   });
   let _SkipStream = _SkipStream$();
   let _hasFailed = Symbol('_hasFailed');
   let _SkipWhileStream$ = dart.generic(function(T) {
     class _SkipWhileStream extends _ForwardingStream$(T, T) {
       _SkipWhileStream(source, test) {
         this[_test] = test;
         this[_hasFailed] = false;
@@ skipping 16 matching lines @@
           return;
         }
 
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
           sink[_add](inputEvent);
         }
       }
     }
     dart.setSignature(_SkipWhileStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [T, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipWhileStream;
   });
   let _SkipWhileStream = _SkipWhileStream$();
   let _Equality$ = dart.generic(function(T) {
     let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
     return _Equality;
   });
   let _Equality = _Equality$();
   let _equals = Symbol('_equals');
@@ skipping 25 matching lines @@
           }
 
           if (!dart.notNull(isEqual)) {
             sink[_add](inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
     dart.setSignature(_DistinctStream, {
-      methods: () => ({[_handleData]: dart.functionType(dart.void, [T, _EventSink$(T)])})
+      methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
   dart.defineLazyProperties(_DistinctStream, {
     get _SENTINEL() {
       return new core.Object();
     },
     set _SENTINEL(_) {}
   });
@@ skipping 11 matching lines @@
           stackTrace = null;
         this[_sink][_addError](error, stackTrace);
       }
       close() {
         this[_sink][_close]();
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_EventSinkWrapper, {
       methods: () => ({
-        add: dart.functionType(dart.void, [T]),
-        addError: dart.functionType(dart.void, [dart.dynamic], [core.StackTrace]),
-        close: dart.functionType(dart.void, [])
+        add: [dart.void, [T]],
+        addError: [dart.void, [dart.dynamic], [core.StackTrace]],
+        close: [dart.void, []]
       })
     });
     return _EventSinkWrapper;
   });
   let _EventSinkWrapper = _EventSinkWrapper$();
   let _transformerSink = Symbol('_transformerSink');
   let _isSubscribed = Symbol('_isSubscribed');
   let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
@@ skipping 73 matching lines @@
           this[_transformerSink].close();
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
     }
     dart.setSignature(_SinkTransformerStreamSubscription, {
       methods: () => ({
-        [_add]: dart.functionType(dart.void, [T]),
-        [_addError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_close]: dart.functionType(dart.void, []),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, []),
-        [_onCancel]: dart.functionType(Future, []),
-        [_handleData]: dart.functionType(dart.void, [S]),
-        [_handleError]: dart.functionType(dart.void, [dart.dynamic], [dart.dynamic]),
-        [_handleDone]: dart.functionType(dart.void, [])
+        [_add]: [dart.void, [T]],
+        [_addError]: [dart.void, [core.Object, core.StackTrace]],
+        [_close]: [dart.void, []],
+        [_onPause]: [dart.void, []],
+        [_onResume]: [dart.void, []],
+        [_onCancel]: [Future, []],
+        [_handleData]: [dart.void, [S]],
+        [_handleError]: [dart.void, [dart.dynamic], [dart.dynamic]],
+        [_handleDone]: [dart.void, []]
       })
     });
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
   let _SinkMapper$ = dart.generic(function(S, T) {
     let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
     return _SinkMapper;
   });
   let _SinkMapper = _SinkMapper$();
   let _sinkMapper = Symbol('_sinkMapper');
   let _StreamSinkTransformer$ = dart.generic(function(S, T) {
     class _StreamSinkTransformer extends core.Object {
       _StreamSinkTransformer(sinkMapper) {
         this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return new (_BoundSinkStream$(S, T))(stream, this[_sinkMapper]);
       }
     }
     _StreamSinkTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     dart.setSignature(_StreamSinkTransformer, {
-      methods: () => ({bind: dart.functionType(Stream$(T), [Stream$(S)])})
+      methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
     });
     return _StreamSinkTransformer;
   });
   let _StreamSinkTransformer = _StreamSinkTransformer$();
   let _BoundSinkStream$ = dart.generic(function(S, T) {
     class _BoundSinkStream extends Stream$(T) {
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       _BoundSinkStream(stream, sinkMapper) {
         this[_stream] = stream;
         this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = new (_SinkTransformerStreamSubscription$(dart.dynamic, T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     dart.setSignature(_BoundSinkStream, {
-      methods: () => ({listen: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool})})
+      methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}]})
     });
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
   let _TransformDataHandler$ = dart.generic(function(S, T) {
     let _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return _TransformDataHandler;
   });
   let _TransformDataHandler = _TransformDataHandler$();
   let _TransformErrorHandler$ = dart.generic(function(T) {
@@ skipping 23 matching lines @@
           stackTrace = null;
         return this[_handleError](error, stackTrace, this[_sink]);
       }
       close() {
         return this[_handleDone](this[_sink]);
       }
     }
     _HandlerEventSink[dart.implements] = () => [EventSink$(S)];
     dart.setSignature(_HandlerEventSink, {
       methods: () => ({
-        add: dart.functionType(dart.void, [S]),
-        addError: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
-        close: dart.functionType(dart.void, [])
+        add: [dart.void, [S]],
+        addError: [dart.void, [core.Object], [core.StackTrace]],
+        close: [dart.void, []]
       })
     });
     return _HandlerEventSink;
   });
   let _HandlerEventSink = _HandlerEventSink$();
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
@@ skipping 17 matching lines @@
         sink.add(data);
       }
       static _defaultHandleError(error, stackTrace, sink) {
         sink.addError(error);
       }
       static _defaultHandleDone(sink) {
         sink.close();
       }
     }
     dart.setSignature(_StreamHandlerTransformer, {
-      methods: () => ({bind: dart.functionType(Stream$(T), [Stream$(S)])}),
+      methods: () => ({bind: [Stream$(T), [Stream$(S)]]}),
       statics: () => ({
-        _defaultHandleData: dart.functionType(dart.void, [dart.dynamic, EventSink]),
-        _defaultHandleError: dart.functionType(dart.void, [dart.dynamic, core.StackTrace, EventSink]),
-        _defaultHandleDone: dart.functionType(dart.void, [EventSink])
+        _defaultHandleData: [dart.void, [dart.dynamic, EventSink]],
+        _defaultHandleError: [dart.void, [dart.dynamic, core.StackTrace, EventSink]],
+        _defaultHandleDone: [dart.void, [EventSink]]
       }),
       names: ['_defaultHandleData', '_defaultHandleError', '_defaultHandleDone']
     });
     return _StreamHandlerTransformer;
   });
   let _StreamHandlerTransformer = _StreamHandlerTransformer$();
   let _SubscriptionTransformer$ = dart.generic(function(S, T) {
     let _SubscriptionTransformer = dart.typedef('_SubscriptionTransformer', () => dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool]));
     return _SubscriptionTransformer;
   });
   let _SubscriptionTransformer = _SubscriptionTransformer$();
   let _transformer = Symbol('_transformer');
   let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer) {
         this[_transformer] = transformer;
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return new (_BoundSubscriptionStream$(S, T))(stream, this[_transformer]);
       }
     }
     _StreamSubscriptionTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     dart.setSignature(_StreamSubscriptionTransformer, {
-      methods: () => ({bind: dart.functionType(Stream$(T), [Stream$(S)])})
+      methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
     });
     return _StreamSubscriptionTransformer;
   });
   let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$();
   let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
     class _BoundSubscriptionStream extends Stream$(T) {
       _BoundSubscriptionStream(stream, transformer) {
         this[_stream] = stream;
         this[_transformer] = transformer;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let result = this[_transformer](this[_stream], cancelOnError);
         result.onData(onData);
         result.onError(onError);
         result.onDone(onDone);
         return result;
       }
     }
     dart.setSignature(_BoundSubscriptionStream, {
-      methods: () => ({listen: dart.functionType(StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool})})
+      methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}]})
     });
     return _BoundSubscriptionStream;
   });
   let _BoundSubscriptionStream = _BoundSubscriptionStream$();
   let __CastType27$ = dart.generic(function(S, T) {
     let __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return __CastType27;
   });
   let __CastType27 = __CastType27$();
   let __CastType30$ = dart.generic(function(T) {
@@ skipping 26 matching lines @@
     static _createPeriodicTimer(duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
     }
   }
   dart.defineNamedConstructor(Timer, 'periodic');
   dart.setSignature(Timer, {
     statics: () => ({
-      run: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-      _createTimer: dart.functionType(Timer, [core.Duration, dart.functionType(dart.void, [])]),
-      _createPeriodicTimer: dart.functionType(Timer, [core.Duration, dart.functionType(dart.void, [Timer])])
+      run: [dart.void, [dart.functionType(dart.void, [])]],
+      _createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
+      _createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
     }),
     names: ['run', '_createTimer', '_createPeriodicTimer']
   });
   let __CastType34 = dart.typedef('__CastType34', () => dart.functionType(dart.void, [Timer]));
   let ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(dart.dynamic, []));
   let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   let HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]));
   let RunHandler = dart.typedef('RunHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
   let RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]));
@@ skipping 85 matching lines @@
       return previous;
     }
     static _leave(previous) {
       dart.assert(previous != null);
       Zone._current = previous;
     }
   }
   dart.defineNamedConstructor(Zone, '_');
   dart.setSignature(Zone, {
     statics: () => ({
-      _enter: dart.functionType(Zone, [Zone]),
-      _leave: dart.functionType(dart.void, [Zone])
+      _enter: [Zone, [Zone]],
+      _leave: [dart.void, [Zone]]
     }),
     names: ['_enter', '_leave']
   });
   class _Zone extends core.Object {
     _Zone() {
     }
     inSameErrorZone(otherZone) {
       return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
   _Zone[dart.implements] = () => [Zone];
   dart.setSignature(_Zone, {
-    methods: () => ({inSameErrorZone: dart.functionType(core.bool, [Zone])})
+    methods: () => ({inSameErrorZone: [core.bool, [Zone]]})
   });
   let _run = Symbol('_run');
   let _runUnary = Symbol('_runUnary');
   let _runBinary = Symbol('_runBinary');
   let _registerCallback = Symbol('_registerCallback');
   let _registerUnaryCallback = Symbol('_registerUnaryCallback');
   let _registerBinaryCallback = Symbol('_registerBinaryCallback');
   let _errorCallback = Symbol('_errorCallback');
   let _scheduleMicrotask = Symbol('_scheduleMicrotask');
   let _createTimer = Symbol('_createTimer');
@@ skipping 166 matching lines @@
     }
     createPeriodicTimer(duration, f) {
       return Timer._createPeriodicTimer(duration, f);
     }
     print(line) {
       _internal.printToConsole(line);
     }
   }
   dart.setSignature(_RootZone, {
     methods: () => ({
-      runGuarded: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [])]),
-      runUnaryGuarded: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]),
-      runBinaryGuarded: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]),
-      bindCallback: dart.functionType(ZoneCallback, [dart.functionType(dart.dynamic, [])], {unGuarde: core.bool}),
-      bindUnaryCallback: dart.functionType(ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {unGuarde: core.bool}),
-      bindBinaryCallback: dart.functionType(ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {unGuarde: core.bool}),
-      get: dart.functionType(dart.dynamic, [core.Object]),
-      handleUncaughtError: dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]),
-      fork: dart.functionType(Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}),
-      run: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [])]),
-      runUnary: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]),
-      runBinary: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]),
-      registerCallback: dart.functionType(ZoneCallback, [dart.functionType(dart.dynamic, [])]),
-      registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]),
-      registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]),
-      errorCallback: dart.functionType(AsyncError, [core.Object, core.StackTrace]),
-      scheduleMicrotask: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-      createTimer: dart.functionType(Timer, [core.Duration, dart.functionType(dart.void, [])]),
-      createPeriodicTimer: dart.functionType(Timer, [core.Duration, dart.functionType(dart.void, [Timer])]),
-      print: dart.functionType(dart.void, [core.String])
+      runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
+      runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
+      runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
+      bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {unGuarde: core.bool}],
+      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {unGuarde: core.bool}],
+      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {unGuarde: core.bool}],
+      get: [dart.dynamic, [core.Object]],
+      handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
+      fork: [Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}],
+      run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
+      runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
+      runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
+      registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
+      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
+      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+      errorCallback: [AsyncError, [core.Object, core.StackTrace]],
+      scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
+      createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
+      createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
+      print: [dart.void, [core.String]]
     })
   });
   let _ROOT_ZONE = dart.const(new _RootZone());
   Zone.ROOT = _ROOT_ZONE;
   Zone._current = _ROOT_ZONE;
   function _parentDelegate(zone) {
     if (zone.parent == null)
       return null;
     return zone.parent[_delegate];
   }
@@ skipping 67 matching lines @@
     }
     fork(zone, specification, zoneValues) {
       let implementation = this[_delegationTarget][_fork];
       let implZone = implementation.zone;
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
     }
   }
   _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
   dart.setSignature(_ZoneDelegate, {
     methods: () => ({
-      handleUncaughtError: dart.functionType(dart.dynamic, [Zone, dart.dynamic, core.StackTrace]),
-      run: dart.functionType(dart.dynamic, [Zone, dart.functionType(dart.dynamic, [])]),
-      runUnary: dart.functionType(dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]),
-      runBinary: dart.functionType(dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]),
-      registerCallback: dart.functionType(ZoneCallback, [Zone, dart.functionType(dart.dynamic, [])]),
-      registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic])]),
-      registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]),
-      errorCallback: dart.functionType(AsyncError, [Zone, core.Object, core.StackTrace]),
-      scheduleMicrotask: dart.functionType(dart.void, [Zone, dart.functionType(dart.dynamic, [])]),
-      createTimer: dart.functionType(Timer, [Zone, core.Duration, dart.functionType(dart.void, [])]),
-      createPeriodicTimer: dart.functionType(Timer, [Zone, core.Duration, dart.functionType(dart.void, [Timer])]),
-      print: dart.functionType(dart.void, [Zone, core.String]),
-      fork: dart.functionType(Zone, [Zone, ZoneSpecification, core.Map])
+      handleUncaughtError: [dart.dynamic, [Zone, dart.dynamic, core.StackTrace]],
+      run: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [])]],
+      runUnary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
+      runBinary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
+      registerCallback: [ZoneCallback, [Zone, dart.functionType(dart.dynamic, [])]],
+      registerUnaryCallback: [ZoneUnaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic])]],
+      registerBinaryCallback: [ZoneBinaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+      errorCallback: [AsyncError, [Zone, core.Object, core.StackTrace]],
+      scheduleMicrotask: [dart.void, [Zone, dart.functionType(dart.dynamic, [])]],
+      createTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [])]],
+      createPeriodicTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [Timer])]],
+      print: [dart.void, [Zone, core.String]],
+      fork: [Zone, [Zone, ZoneSpecification, core.Map]]
     })
   });
   let _delegateCache = Symbol('_delegateCache');
   class _CustomZone extends _Zone {
     get [_delegate]() {
       if (this[_delegateCache] != null)
         return this[_delegateCache];
       this[_delegateCache] = new _ZoneDelegate(this);
       return this[_delegateCache];
     }
@@ skipping 179 matching lines @@
     }
     print(line) {
       let implementation = this[_print];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
       return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, line);
     }
   }
   dart.setSignature(_CustomZone, {
     methods: () => ({
-      runGuarded: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [])]),
-      runUnaryGuarded: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]),
-      runBinaryGuarded: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]),
-      bindCallback: dart.functionType(ZoneCallback, [dart.functionType(dart.dynamic, [])], {unGuarde: core.bool}),
-      bindUnaryCallback: dart.functionType(ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {unGuarde: core.bool}),
-      bindBinaryCallback: dart.functionType(ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {unGuarde: core.bool}),
-      get: dart.functionType(dart.dynamic, [core.Object]),
-      handleUncaughtError: dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]),
-      fork: dart.functionType(Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}),
-      run: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [])]),
-      runUnary: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]),
-      runBinary: dart.functionType(dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]),
-      registerCallback: dart.functionType(ZoneCallback, [dart.functionType(dart.dynamic, [])]),
-      registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]),
-      registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]),
-      errorCallback: dart.functionType(AsyncError, [core.Object, core.StackTrace]),
-      scheduleMicrotask: dart.functionType(dart.void, [dart.functionType(dart.void, [])]),
-      createTimer: dart.functionType(Timer, [core.Duration, dart.functionType(dart.void, [])]),
-      createPeriodicTimer: dart.functionType(Timer, [core.Duration, dart.functionType(dart.void, [Timer])]),
-      print: dart.functionType(dart.void, [core.String])
+      runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
+      runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
+      runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
+      bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {unGuarde: core.bool}],
+      bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])], {unGuarde: core.bool}],
+      bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {unGuarde: core.bool}],
+      get: [dart.dynamic, [core.Object]],
+      handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
+      fork: [Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}],
+      run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
+      runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
+      runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
+      registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
+      registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
+      registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
+      errorCallback: [AsyncError, [core.Object, core.StackTrace]],
+      scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
+      createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
+      createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
+      print: [dart.void, [core.String]]
     })
   });
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
     _schedulePriorityAsyncCallback(dart.fn(() => {
       throw new _UncaughtAsyncError(error, stackTrace);
     }));
   }
   dart.fn(_rootHandleUncaughtError, dart.void, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
   function _rootRun(self, parent, zone, f) {
     if (dart.equals(Zone._current, zone))
@@ skipping 230 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async, core, _internal, _js_helper, _isolate_helper, collection);