Tag closures with their types

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: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dcall(errorHandler, error, stackTrace);
     } else {
       return dart.dcall(errorHandler, error);
     }
   }
-  // Function _registerErrorHandler: (Function, Zone) → Function
+  dart.fn(_invokeErrorHandler, dart.dynamic, [core.Function, core.Object, core.StackTrace]);
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
       return zone.registerUnaryCallback(dart.as(errorHandler, __CastType0));
     }
   }
+  dart.fn(_registerErrorHandler, () => dart.functionType(core.Function, [core.Function, Zone]));
   class AsyncError extends core.Object {
     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, [])})
+  });
   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])}),
+    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) {
     class Stream extends core.Object {
       Stream() {
       }
       fromFuture(future) {
         let controller = dart.as(new (StreamController$(T))({sync: true}), _StreamController$(T));
-        future.then(value => {
+        future.then(dart.fn(value => {
           controller[_add](dart.as(value, T));
           controller[_closeUnchecked]();
-        }, {
-          onError: (error, stackTrace) => {
+        }), {onError: dart.fn((error, stackTrace) => {
             controller[_addError](error, dart.as(stackTrace, core.StackTrace));
             controller[_closeUnchecked]();
-          }
-        });
+          })});
         return controller.stream;
       }
       fromIterable(data) {
-        return new (_GeneratedStreamImpl$(T))(() => new (_IterablePendingEvents$(T))(data));
+        return new (_GeneratedStreamImpl$(T))(dart.fn(() => new (_IterablePendingEvents$(T))(data), _IterablePendingEvents$(T), []));
       }
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
-          computation = i => null;
+          computation = dart.fn(i => null, dart.bottom, [dart.dynamic]);
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
-        // Function sendEvent: () → void
         let sendEvent = () => {
           watch.reset();
           let data = computation((() => {
             let x = computationCount;
             computationCount = dart.notNull(x) + 1;
             return x;
           })());
           controller.add(data);
         };
-        // Function startPeriodicTimer: () → void
+        dart.fn(sendEvent, dart.void, []);
         let startPeriodicTimer = () => {
           dart.assert(timer == null);
-          timer = new Timer.periodic(period, timer => {
+          timer = new Timer.periodic(period, dart.fn(timer => {
             sendEvent();
-          });
+          }, dart.dynamic, [Timer]));
         };
-        controller = new (StreamController$(T))({
-          sync: true,
-          onListen: () => {
+        dart.fn(startPeriodicTimer, dart.void, []);
+        controller = new (StreamController$(T))({sync: true, onListen: dart.fn(() => {
             watch.start();
             startPeriodicTimer();
-          },
-          onPause: () => {
+          }), onPause: dart.fn(() => {
             timer.cancel();
             timer = null;
             watch.stop();
-          },
-          onResume: () => {
+          }), onResume: dart.fn(() => {
             dart.assert(timer == null);
             let elapsed = watch.elapsed;
             watch.start();
-            timer = new Timer(period['-'](elapsed), () => {
+            timer = new Timer(period['-'](elapsed), dart.fn(() => {
               timer = null;
               startPeriodicTimer();
               sendEvent();
-            });
-          },
-          onCancel: () => {
+            }));
+          }), onCancel: dart.fn(() => {
             if (timer != null)
               timer.cancel();
             timer = null;
-          }
-        });
+          })});
         return controller.stream;
       }
       eventTransformed(source, mapSink) {
         return new (_BoundSinkStream$(dart.dynamic, T))(source, dart.as(mapSink, _SinkMapper));
       }
       get isBroadcast() {
         return false;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         dart.as(onListen, dart.functionType(dart.void, [StreamSubscription$(T)]));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription$(T)]));
         return new (_AsBroadcastStream$(T))(this, dart.as(onListen, __CastType12), dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription])));
       }
       where(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         let controller = null;
         let subscription = null;
-        // Function onListen: () → void
         let onListen = (() => {
           let add = controller.add.bind(controller);
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           let addError = eventSink[_addError];
-          subscription = this.listen(event => {
+          subscription = this.listen(dart.fn(event => {
             dart.as(event, T);
             let newValue = null;
             try {
               newValue = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
               subscription.pause();
               dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
             } else {
               controller.add(newValue);
             }
-          }, {onError: dart.as(addError, core.Function), onDone: controller.close.bind(controller)});
+          }, dart.dynamic, [T]), {onError: dart.as(addError, core.Function), onDone: controller.close.bind(controller)});
         }).bind(this);
+        dart.fn(onListen, dart.void, []);
         if (this.isBroadcast) {
-          controller = new StreamController.broadcast({
-            onListen: onListen,
-            onCancel: () => {
+          controller = new StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
-            },
-            sync: true
-          });
+            }), sync: true});
         } else {
-          controller = new StreamController({
-            onListen: onListen,
-            onPause: () => {
+          controller = new StreamController({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
-            },
-            onResume: () => {
+            }), onResume: dart.fn(() => {
               subscription.resume();
-            },
-            onCancel: () => {
+            }), onCancel: dart.fn(() => {
               subscription.cancel();
-            },
-            sync: true
-          });
+            }), sync: true});
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         dart.as(convert, dart.functionType(Stream$(), [T]));
         let controller = null;
         let subscription = null;
-        // Function onListen: () → void
         let onListen = (() => {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
-          subscription = this.listen(event => {
+          subscription = this.listen(dart.fn(event => {
             dart.as(event, T);
             let newStream = null;
             try {
               newStream = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (newStream != null) {
               subscription.pause();
               controller.addStream(newStream).whenComplete(dart.bind(subscription, 'resume'));
             }
-          }, {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close.bind(controller)});
+          }, dart.dynamic, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close.bind(controller)});
         }).bind(this);
+        dart.fn(onListen, dart.void, []);
         if (this.isBroadcast) {
-          controller = new StreamController.broadcast({
-            onListen: onListen,
-            onCancel: () => {
+          controller = new StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
-            },
-            sync: true
-          });
+            }), sync: true});
         } else {
-          controller = new StreamController({
-            onListen: onListen,
-            onPause: () => {
+          controller = new StreamController({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
-            },
-            onResume: () => {
+            }), onResume: dart.fn(() => {
               subscription.resume();
-            },
-            onCancel: () => {
+            }), onCancel: dart.fn(() => {
               subscription.cancel();
-            },
-            sync: true
-          });
+            }), sync: true});
         }
         return controller.stream;
       }
       handleError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
         dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         return new (_HandleErrorStream$(T))(this, onError, test);
       }
       expand(convert) {
         dart.as(convert, dart.functionType(core.Iterable, [T]));
         return new (_ExpandStream$(T, dart.dynamic))(this, convert);
       }
       pipe(streamConsumer) {
         dart.as(streamConsumer, StreamConsumer$(T));
-        return streamConsumer.addStream(this).then(_ => streamConsumer.close());
+        return streamConsumer.addStream(this).then(dart.fn(_ => streamConsumer.close(), Future, [dart.dynamic]));
       }
       transform(streamTransformer) {
         dart.as(streamTransformer, StreamTransformer$(T, dart.dynamic));
         return streamTransformer.bind(this);
       }
       reduce(combine) {
         dart.as(combine, dart.functionType(T, [T, T]));
         let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
-        subscription = this.listen(element => {
+        subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           if (seenFirst) {
-            _runUserCode(() => combine(value, element), newValue => {
+            _runUserCode(dart.fn(() => combine(value, element), T, []), dart.fn(newValue => {
               dart.as(newValue, T);
               value = newValue;
-            }, dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
+            }, dart.dynamic, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
           } else {
             value = element;
             seenFirst = true;
           }
-        }, {
-          onError: result[_completeError].bind(result),
-          onDone: () => {
+        }, dart.dynamic, [T]), {onError: result[_completeError].bind(result), onDone: dart.fn(() => {
             if (!dart.notNull(seenFirst)) {
               try {
                 throw _internal.IterableElementError.noElement();
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
               result[_complete](value);
             }
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return result;
       }
       fold(initialValue, combine) {
         dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, T]));
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
-        subscription = this.listen(element => {
+        subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(() => dart.dcall(combine, value, element), newValue => {
+          _runUserCode(dart.fn(() => dart.dcall(combine, value, element)), dart.fn(newValue => {
             value = newValue;
-          }, dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: (e, st) => {
+          }), dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: dart.fn((e, st) => {
             result[_completeError](e, dart.as(st, core.StackTrace));
-          },
-          onDone: () => {
+          }), onDone: dart.fn(() => {
             result[_complete](value);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return result;
       }
       join(separator) {
         if (separator === void 0)
           separator = "";
         let result = new (_Future$(core.String))();
         let buffer = new core.StringBuffer();
         let subscription = null;
         let first = true;
-        subscription = this.listen(element => {
+        subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           if (!dart.notNull(first)) {
             buffer.write(separator);
           }
           first = false;
           try {
             buffer.write(element);
           } catch (e) {
             let s = dart.stackTrace(e);
             _cancelAndErrorWithReplacement(subscription, result, e, s);
           }
 
-        }, {
-          onError: e => {
+        }, dart.dynamic, [T]), {onError: dart.fn(e => {
             result[_completeError](e);
-          },
-          onDone: () => {
+          }), onDone: dart.fn(() => {
             result[_complete](dart.toString(buffer));
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(element => {
+        subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(() => dart.equals(element, needle), isMatch => {
+          _runUserCode(dart.fn(() => dart.equals(element, needle), core.bool, []), dart.fn(isMatch => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](false);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [T]));
         let future = new _Future();
         let subscription = null;
-        subscription = this.listen(element => {
+        subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(() => action(element), _ => {
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+          _runUserCode(dart.fn(() => action(element), dart.void, []), dart.fn(_ => {
+          }), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](null);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       every(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(element => {
+        subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(() => test(element), isMatch => {
+          _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (!dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, false);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](true);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       any(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(element => {
+        subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(() => test(element), isMatch => {
+          _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](false);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
-        this.listen(_ => {
+        this.listen(dart.fn(_ => {
           count = dart.notNull(count) + 1;
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+        }), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](count);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(_ => {
+        subscription = this.listen(dart.fn(_ => {
           _cancelAndValue(subscription, future, false);
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+        }), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](true);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       toList() {
         let result = dart.setType([], core.List$(T));
         let future = new (_Future$(core.List$(T)))();
-        this.listen(data => {
+        this.listen(dart.fn(data => {
           dart.as(data, T);
           result[core.$add](data);
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](result);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       toSet() {
         let result = new (core.Set$(T))();
         let future = new (_Future$(core.Set$(T)))();
-        this.listen(data => {
+        this.listen(dart.fn(data => {
           dart.as(data, T);
           result.add(data);
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             future[_complete](result);
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
       }
       take(count) {
         return new (_TakeStream$(T))(this, count);
       }
@@ skipping 10 matching lines @@
       }
       distinct(equals) {
         if (equals === void 0)
           equals = null;
         dart.as(equals, dart.functionType(core.bool, [T, T]));
         return new (_DistinctStream$(T))(this, equals);
       }
       get first() {
         let future = new (_Future$(T))();
         let subscription = null;
-        subscription = this.listen(value => {
+        subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _cancelAndValue(subscription, future, value);
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       get last() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(value => {
+        subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           foundResult = true;
           result = value;
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(value => {
+        subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           if (foundResult) {
             try {
               throw _internal.IterableElementError.tooMany();
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       firstWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         dart.as(defaultValue, dart.functionType(core.Object, []));
         let future = new _Future();
         let subscription = null;
-        subscription = this.listen(value => {
+        subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
-          _runUserCode(() => test(value), isMatch => {
+          _runUserCode(dart.fn(() => test(value), core.bool, []), dart.fn(isMatch => {
             if (isMatch) {
               _cancelAndValue(subscription, future, value);
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete].bind(future), future[_completeError].bind(future));
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       lastWhere(test, opts) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         dart.as(defaultValue, dart.functionType(core.Object, []));
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(value => {
+        subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
-          _runUserCode(() => true == test(value), isMatch => {
+          _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (isMatch) {
               foundResult = true;
               result = value;
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete].bind(future), future[_completeError].bind(future));
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
-        subscription = this.listen(value => {
+        subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
-          _runUserCode(() => true == test(value), isMatch => {
+          _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (isMatch) {
               if (foundResult) {
                 try {
                   throw _internal.IterableElementError.tooMany();
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: () => {
+          }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn(() => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          },
-          cancelOnError: true
-        });
+          }), cancelOnError: true});
         return future;
       }
       elementAt(index) {
         if (!(typeof index == 'number') || dart.notNull(index) < 0)
           throw new core.ArgumentError(index);
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
-        subscription = this.listen(value => {
+        subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
-        }, {
-          onError: future[_completeError].bind(future),
-          onDone: (() => {
+        }, dart.dynamic, [T]), {onError: future[_completeError].bind(future), onDone: dart.fn((() => {
             future[_completeError](new core.RangeError.index(index, this, "index", null, elementIndex));
-          }).bind(this),
-          cancelOnError: true
-        });
+          }).bind(this)), cancelOnError: true});
         return future;
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(dart.void, [EventSink]));
         let controller = null;
         let subscription = null;
         let timer = null;
         let zone = null;
         let timeout = null;
-        // Function onData: (T) → void
         let onData = event => {
           dart.as(event, T);
           timer.cancel();
           controller.add(event);
           timer = zone.createTimer(timeLimit, dart.as(timeout, __CastType17));
         };
-        // Function onError: (dynamic, StackTrace) → void
+        dart.fn(onData, dart.void, [T]);
         let onError = (error, stackTrace) => {
           timer.cancel();
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           dart.dcall(eventSink[_addError], error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         };
-        // Function onDone: () → void
+        dart.fn(onError, dart.void, [dart.dynamic, core.StackTrace]);
         let onDone = () => {
           timer.cancel();
           controller.close();
         };
-        // Function onListen: () → void
+        dart.fn(onDone, dart.void, []);
         let onListen = (() => {
           zone = Zone.current;
           if (onTimeout == null) {
-            timeout = () => {
+            timeout = dart.fn(() => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
-            };
+            });
           } else {
             onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), __CastType18);
             let wrapper = new _ControllerEventSinkWrapper(null);
-            timeout = () => {
+            timeout = dart.fn(() => {
               wrapper[_sink] = controller;
               zone.runUnaryGuarded(onTimeout, wrapper);
               wrapper[_sink] = null;
-            };
+            });
           }
           subscription = this.listen(onData, {onError: onError, onDone: onDone});
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }).bind(this);
-        // Function onCancel: () → Future<dynamic>
+        dart.fn(onListen, dart.void, []);
         let onCancel = () => {
           timer.cancel();
           let result = subscription.cancel();
           subscription = null;
           return result;
         };
-        controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, () => {
+        dart.fn(onCancel, Future, []);
+        controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, dart.fn(() => {
           timer.cancel();
           subscription.pause();
-        }, () => {
+        }), dart.fn(() => {
           subscription.resume();
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
-        }, onCancel);
+        }), 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])})
+      })
+    });
     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() {
         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 = this[_createSubscription](onData, onError, onDone, cancelOnError);
         this[_onListen](subscription);
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_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])
+      })
+    });
     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) {
         this[_controller] = controller;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
         return dart.notNull(dart.hashCode(this[_controller])) ^ 892482866;
       }
       ['=='](other) {
         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])
+      })
+    });
     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)));
       }
       get isBroadcast() {
         return true;
       }
     }
+    dart.setSignature(_BroadcastStream, {});
     return _BroadcastStream;
   });
   let _BroadcastStream = _BroadcastStream$();
   let _next = Symbol('_next');
   let _previous = Symbol('_previous');
   class _BroadcastSubscriptionLink extends core.Object {
     _BroadcastSubscriptionLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
+  dart.setSignature(_BroadcastSubscriptionLink, {});
   let _zone = Symbol('_zone');
   let _state = Symbol('_state');
   let _onData = Symbol('_onData');
   let _onError = Symbol('_onError');
   let _onDone = Symbol('_onDone');
   let _cancelFuture = Symbol('_cancelFuture');
   let _pending = Symbol('_pending');
   let _setPendingEvents = Symbol('_setPendingEvents');
   let _extractPending = Symbol('_extractPending');
   let _isCanceled = Symbol('_isCanceled');
@@ skipping 102 matching lines @@
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
         if (this[_isCanceled])
           return this[_cancelFuture];
         this[_cancel]();
         return this[_cancelFuture];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new (_Future$(T))();
-        this[_onDone] = () => {
+        this[_onDone] = dart.fn(() => {
           result[_complete](futureValue);
-        };
-        this[_onError] = ((error, stackTrace) => {
+        });
+        this[_onError] = dart.fn(((error, stackTrace) => {
           this.cancel();
           result[_completeError](error, dart.as(stackTrace, core.StackTrace));
-        }).bind(this);
+        }).bind(this));
         return result;
       }
       get [_isInputPaused]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED)) != 0;
       }
       get [_isClosed]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED)) != 0;
       }
       get [_isCanceled]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED)) != 0;
@@ skipping 100 matching lines @@
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         this[_zone].runUnaryGuarded(this[_onData], data);
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         this[_checkState](wasInputPaused);
       }
       [_sendError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
-        // Function sendError: () → void
         let sendError = (() => {
           if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
             this[_zone].runBinaryGuarded(dart.as(this[_onError], __CastType22), error, stackTrace);
           } else {
             this[_zone].runUnaryGuarded(dart.as(this[_onError], __CastType25), error);
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
+        dart.fn(sendError, dart.void, []);
         if (this[_cancelOnError]) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
           this[_cancel]();
           if (dart.is(this[_cancelFuture], Future)) {
             this[_cancelFuture].whenComplete(sendError);
           } else {
             sendError();
           }
         } else {
           sendError();
           this[_checkState](wasInputPaused);
         }
       }
       [_sendDone]() {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
-        // Function sendDone: () → void
         let sendDone = (() => {
           if (!dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           this[_zone].runGuarded(this[_onDone]);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
+        dart.fn(sendDone, dart.void, []);
         this[_cancel]();
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
         if (dart.is(this[_cancelFuture], Future)) {
           this[_cancelFuture].whenComplete(sendDone);
         } else {
           sendDone();
         }
       }
       [_guardCallback](callback) {
         dart.assert(!dart.notNull(this[_inCallback]));
@@ skipping 27 matching lines @@
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           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])
+      })
+    });
     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, [])
+      })
+    });
     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');
   let _removeAfterFiring = Symbol('_removeAfterFiring');
   let _BroadcastSubscription$ = dart.generic(function(T) {
@@ skipping 21 matching lines @@
         dart.assert(this[_isFiring]);
         this[_eventState] = dart.notNull(this[_eventState]) | dart.notNull(_BroadcastSubscription$()._STATE_REMOVE_AFTER_FIRING);
       }
       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, [])
+      })
+    });
     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');
   let _isEmpty = Symbol('_isEmpty');
   let _hasOneListener = Symbol('_hasOneListener');
@@ skipping 207 matching lines @@
       }
       [_callOnCancel]() {
         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, [])
+      })
+    });
     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;
   let _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
         if (this[_isEmpty])
           return;
         if (this[_hasOneListener]) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_FIRING);
           let subscription = dart.as(this[_next], _BroadcastSubscription);
           subscription[_add](data);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
           if (this[_isEmpty]) {
             this[_callOnCancel]();
           }
           return;
         }
-        this[_forEachListener](subscription => {
+        this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_add](data);
-        });
+        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
       }
       [_sendError](error, stackTrace) {
         if (this[_isEmpty])
           return;
-        this[_forEachListener](subscription => {
+        this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_addError](error, stackTrace);
-        });
+        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          this[_forEachListener](dart.as(subscription => {
+          this[_forEachListener](dart.as(dart.fn(subscription => {
             dart.as(subscription, _BroadcastSubscription$(T));
             subscription[_close]();
-          }, __CastType2));
+          }, 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, [])
+      })
+    });
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
   let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
     class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _AsyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
@@ skipping 14 matching lines @@
             let subscription = dart.as(link, _BroadcastSubscription$(T));
             subscription[_addPending](dart.const(new _DelayedDone()));
           }
         } 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, [])
+      })
+    });
     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;
         super._SyncBroadcastStreamController(onListen, onCancel);
       }
@@ skipping 43 matching lines @@
       }
       [_callOnCancel]() {
         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, [])
+      })
+    });
     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() {
         this[_pauseCount] = 0;
       }
@@ skipping 25 matching lines @@
       get isPaused() {
         return dart.notNull(this[_pauseCount]) > 0;
       }
       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])
+      })
+    });
     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), [])})
+  });
   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, [])})
+  });
   let _completeWithValue = Symbol('_completeWithValue');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new (_Future$(T))();
-        Timer.run(() => {
+        Timer.run(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        });
+        }));
         return dart.as(result, Future$(T));
       }
       microtask(computation) {
         let result = new (_Future$(T))();
-        scheduleMicrotask(() => {
+        scheduleMicrotask(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        });
+        }));
         return dart.as(result, Future$(T));
       }
       sync(computation) {
         try {
           let result = computation();
           return new (Future$(T)).value(result);
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
           return new (Future$(T)).error(error, stackTrace);
         }
@@ skipping 14 matching lines @@
             error = _nonNullError(replacement.error);
             stackTrace = replacement.stackTrace;
           }
         }
         return new (_Future$(T)).immediateError(error, stackTrace);
       }
       delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
         let result = new (_Future$(T))();
-        new Timer(duration, () => {
+        new Timer(duration, dart.fn(() => {
           try {
             result[_complete](computation == null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        });
+        }));
         return dart.as(result, Future$(T));
       }
       static wait(futures, opts) {
         let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
         let cleanUp = opts && 'cleanUp' in opts ? opts.cleanUp : null;
         dart.as(cleanUp, dart.functionType(dart.void, [dart.dynamic]));
         let result = new (_Future$(core.List))();
         let values = null;
         let remaining = 0;
         let error = null;
         let stackTrace = null;
-        // Function handleError: (dynamic, dynamic) → void
         let handleError = (theError, theStackTrace) => {
           remaining = dart.notNull(remaining) - 1;
           if (values != null) {
             if (cleanUp != null) {
               for (let value of values) {
                 if (value != null) {
-                  new (Future$()).sync(() => {
+                  new (Future$()).sync(dart.fn(() => {
                     dart.dcall(cleanUp, value);
-                  });
+                  }));
                 }
               }
             }
             values = null;
             if (remaining == 0 || dart.notNull(eagerError)) {
               result[_completeError](theError, dart.as(theStackTrace, core.StackTrace));
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining == 0 && !dart.notNull(eagerError)) {
             result[_completeError](error, stackTrace);
           }
         };
+        dart.fn(handleError, dart.void, [dart.dynamic, dart.dynamic]);
         for (let future of futures) {
           let pos = remaining;
           remaining = dart.notNull(pos) + 1;
-          future.then(value => {
+          future.then(dart.fn(value => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values[core.$set](pos, value);
               if (remaining == 0) {
                 result[_completeWithValue](values);
               }
             } else {
               if (dart.notNull(cleanUp != null) && dart.notNull(value != null)) {
-                new (Future$()).sync(() => {
+                new (Future$()).sync(dart.fn(() => {
                   dart.dcall(cleanUp, value);
-                });
+                }));
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
-          }, {onError: handleError});
+          }, dart.dynamic, [core.Object]), {onError: handleError});
         }
         if (remaining == 0) {
           return new (Future$(core.List)).value(dart.const([]));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
         let iterator = input[core.$iterator];
-        return Future$().doWhile(() => {
+        return Future$().doWhile(dart.fn(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
-          return new (Future$()).sync(() => dart.dcall(f, iterator.current)).then(_ => true);
-        });
+          return new (Future$()).sync(dart.fn(() => dart.dcall(f, iterator.current))).then(dart.fn(_ => true, core.bool, [dart.dynamic]));
+        }));
       }
       static doWhile(f) {
         dart.as(f, dart.functionType(dart.dynamic, []));
         let doneSignal = new _Future();
         let nextIteration = null;
-        nextIteration = Zone.current.bindUnaryCallback(keepGoing => {
+        nextIteration = Zone.current.bindUnaryCallback(dart.fn(keepGoing => {
           if (keepGoing) {
             new (Future$()).sync(f).then(dart.as(nextIteration, __CastType4), {onError: doneSignal[_completeError].bind(doneSignal)});
           } else {
             doneSignal[_complete](null);
           }
-        }, {runGuarded: true});
+        }, dart.dynamic, [core.bool]), {runGuarded: true});
         dart.dcall(nextIteration, true);
         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, [])])
+      }),
+      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, [])})
+  });
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
         return new (_AsyncCompleter$(T))();
       }
       sync() {
         return new (_SyncCompleter$(T))();
       }
     }
     dart.defineNamedConstructor(Completer, 'sync');
+    dart.setSignature(Completer, {});
     return Completer;
   });
   let Completer = Completer$();
-  // Function _completeWithErrorCallback: (_Future<dynamic>, dynamic, dynamic) → void
   function _completeWithErrorCallback(result, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result[_completeError](error, dart.as(stackTrace, core.StackTrace));
   }
-  // Function _nonNullError: (Object) → Object
+  dart.fn(_completeWithErrorCallback, () => dart.functionType(dart.void, [_Future, dart.dynamic, dart.dynamic]));
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
+  dart.fn(_nonNullError, core.Object, [core.Object]);
   let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let _FutureOnValue$ = dart.generic(function(T) {
     let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(dart.dynamic, [T]));
     return _FutureOnValue;
   });
   let _FutureOnValue = _FutureOnValue$();
   let _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
   let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(dart.dynamic, []));
   let _Completer$ = dart.generic(function(T) {
     class _Completer extends core.Object {
@@ skipping 11 matching lines @@
           error = _nonNullError(replacement.error);
           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])})
+    });
     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])
+      })
+    });
     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])
+      })
+    });
     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 {
     then(result, onValue, errorCallback) {
       this.result = result;
@@ skipping 51 matching lines @@
     }
     get [_whenCompleteAction]() {
       dart.assert(this.handlesComplete);
       return dart.as(this.callback, _FutureAction);
     }
   }
   dart.defineNamedConstructor(_FutureListener, 'then');
   dart.defineNamedConstructor(_FutureListener, 'catchError');
   dart.defineNamedConstructor(_FutureListener, 'whenComplete');
   dart.defineNamedConstructor(_FutureListener, 'chain');
+  dart.setSignature(_FutureListener, {});
   _FutureListener.MASK_VALUE = 1;
   _FutureListener.MASK_ERROR = 2;
   _FutureListener.MASK_TEST_ERROR = 4;
   _FutureListener.MASK_WHENCOMPLETE = 8;
   _FutureListener.STATE_CHAIN = 0;
   _FutureListener.STATE_THEN = _FutureListener.MASK_VALUE;
   _FutureListener.STATE_THEN_ONERROR = dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
   _FutureListener.STATE_CATCHERROR = _FutureListener.MASK_ERROR;
   _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(_FutureListener.MASK_ERROR) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
   _FutureListener.STATE_WHENCOMPLETE = _FutureListener.MASK_WHENCOMPLETE;
@@ skipping 114 matching lines @@
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_state] = _Future$()._ERROR;
         this[_resultOrListeners] = error;
       }
       [_setError](error, stackTrace) {
         this[_setErrorObject](new AsyncError(error, stackTrace));
       }
       [_addListener](listener) {
         dart.assert(listener[_nextListener] == null);
         if (this[_isComplete]) {
-          this[_zone].scheduleMicrotask((() => {
+          this[_zone].scheduleMicrotask(dart.fn((() => {
             _Future$()._propagateToListeners(this, listener);
-          }).bind(this));
+          }).bind(this)));
         } else {
           listener[_nextListener] = dart.as(this[_resultOrListeners], _FutureListener);
           this[_resultOrListeners] = listener;
         }
       }
       [_removeListeners]() {
         dart.assert(!dart.notNull(this[_isComplete]));
         let current = dart.as(this[_resultOrListeners], _FutureListener);
         this[_resultOrListeners] = null;
         let prev = null;
         while (current != null) {
           let next = current[_nextListener];
           current[_nextListener] = prev;
           prev = current;
           current = next;
         }
         return prev;
       }
       static _chainForeignFuture(source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(!dart.is(source, _Future$()));
         target[_isChained] = true;
-        source.then(value => {
+        source.then(dart.fn(value => {
           dart.assert(target[_isChained]);
           target[_completeWithValue](value);
-        }, {
-          onError: (error, stackTrace) => {
+        }), {onError: dart.fn((error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
             target[_completeError](error, dart.as(stackTrace, core.StackTrace));
-          }
-        });
+          }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
       }
       static _chainCoreFuture(source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(dart.is(source, _Future$()));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
         if (source[_isComplete]) {
           _Future$()._propagateToListeners(source, listener);
         } else {
           source[_addListener](listener);
@@ skipping 30 matching lines @@
       }
       [_asyncComplete](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         if (value == null) {
         } else if (dart.is(value, Future)) {
           let typedFuture = dart.as(value, Future$(T));
           if (dart.is(typedFuture, _Future$())) {
             let coreFuture = dart.as(typedFuture, _Future$(T));
             if (dart.notNull(coreFuture[_isComplete]) && dart.notNull(coreFuture[_hasError])) {
               this[_markPendingCompletion]();
-              this[_zone].scheduleMicrotask((() => {
+              this[_zone].scheduleMicrotask(dart.fn((() => {
                 _Future$()._chainCoreFuture(coreFuture, this);
-              }).bind(this));
+              }).bind(this)));
             } else {
               _Future$()._chainCoreFuture(coreFuture, this);
             }
           } else {
             _Future$()._chainForeignFuture(typedFuture, this);
           }
           return;
         } else {
           let typedValue = dart.as(value, T);
         }
         this[_markPendingCompletion]();
-        this[_zone].scheduleMicrotask((() => {
+        this[_zone].scheduleMicrotask(dart.fn((() => {
           this[_completeWithValue](value);
-        }).bind(this));
+        }).bind(this)));
       }
       [_asyncCompleteError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_markPendingCompletion]();
-        this[_zone].scheduleMicrotask((() => {
+        this[_zone].scheduleMicrotask(dart.fn((() => {
           this[_completeError](error, stackTrace);
-        }).bind(this));
+        }).bind(this)));
       }
       static _propagateToListeners(source, listeners) {
         while (true) {
           dart.assert(source[_isComplete]);
           let hasError = source[_hasError];
           if (listeners == null) {
             if (hasError) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
             }
@@ skipping 14 matching lines @@
             let zone = listener[_zone];
             if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErrorZone(zone))) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
               return;
             }
             let oldZone = null;
             if (!dart.notNull(core.identical(Zone.current, zone))) {
               oldZone = Zone._enter(zone);
             }
-            // Function handleValueCallback: () → bool
             let handleValueCallback = () => {
               try {
                 listenerValueOrError = zone.runUnary(listener[_onValue], sourceValue);
                 return true;
               } catch (e) {
                 let s = dart.stackTrace(e);
                 listenerValueOrError = new AsyncError(e, s);
                 return false;
               }
 
             };
-            // Function handleError: () → void
+            dart.fn(handleValueCallback, core.bool, []);
             let handleError = () => {
               let asyncError = source[_error];
               let matchesTest = true;
               if (listener.hasErrorTest) {
                 let test = listener[_errorTest];
                 try {
                   matchesTest = dart.as(zone.runUnary(test, asyncError.error), core.bool);
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
@@ skipping 16 matching lines @@
                   listenerHasValue = false;
                   return;
                 }
 
                 listenerHasValue = true;
               } else {
                 listenerValueOrError = asyncError;
                 listenerHasValue = false;
               }
             };
-            // Function handleWhenCompleteCallback: () → void
+            dart.fn(handleError, dart.void, []);
             let handleWhenCompleteCallback = () => {
               let completeResult = null;
               try {
                 completeResult = zone.run(listener[_whenCompleteAction]);
               } catch (e) {
                 let s = dart.stackTrace(e);
                 if (dart.notNull(hasError) && dart.notNull(core.identical(source[_error].error, e))) {
                   listenerValueOrError = source[_error];
                 } else {
                   listenerValueOrError = new AsyncError(e, s);
                 }
                 listenerHasValue = false;
                 return;
               }
 
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
                 result[_isChained] = true;
                 isPropagationAborted = true;
-                dart.dsend(completeResult, 'then', ignored => {
+                dart.dsend(completeResult, 'then', dart.fn(ignored => {
                   _Future$()._propagateToListeners(source, new _FutureListener.chain(result));
-                }, {
-                  onError: (error, stackTrace) => {
+                }), {onError: dart.fn((error, stackTrace) => {
                     if (stackTrace === void 0)
                       stackTrace = null;
                     if (!dart.is(completeResult, _Future$())) {
                       completeResult = new (_Future$())();
                       dart.dsend(completeResult, _setError, error, stackTrace);
                     }
                     _Future$()._propagateToListeners(dart.as(completeResult, _Future$()), new _FutureListener.chain(result));
-                  }
-                });
+                  }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
               }
             };
+            dart.fn(handleWhenCompleteCallback, dart.void, []);
             if (!dart.notNull(hasError)) {
               if (listener.handlesValue) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
             if (listener.handlesComplete) {
               handleWhenCompleteCallback();
             }
@@ skipping 31 matching lines @@
         }
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(dart.dynamic, []));
         if (this[_isComplete])
           return new (_Future$()).immediate(this);
         let result = new (_Future$())();
         let timer = null;
         if (onTimeout == null) {
-          timer = new Timer(timeLimit, () => {
+          timer = new Timer(timeLimit, dart.fn(() => {
             result[_completeError](new TimeoutException("Future not completed", timeLimit));
-          });
+          }));
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
-          timer = new Timer(timeLimit, () => {
+          timer = new Timer(timeLimit, dart.fn(() => {
             try {
               result[_complete](zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
               result[_completeError](e, s);
             }
 
-          });
+          }));
         }
-        this.then(v => {
+        this.then(dart.fn(v => {
           dart.as(v, T);
           if (timer.isActive) {
             timer.cancel();
             result[_completeWithValue](v);
           }
-        }, {
-          onError: (e, s) => {
+        }, dart.dynamic, [T]), {onError: dart.fn((e, s) => {
             if (timer.isActive) {
               timer.cancel();
               result[_completeError](e, dart.as(s, core.StackTrace));
             }
-          }
-        });
+          })});
         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, [])})
+      }),
+      statics: () => ({
+        _chainForeignFuture: dart.functionType(dart.void, [Future, _Future$()]),
+        _chainCoreFuture: dart.functionType(dart.void, [_Future$(), _Future$()]),
+        _propagateToListeners: dart.functionType(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;
   _Future._ERROR = 8;
   let __CastType6$ = dart.generic(function(T) {
     let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.dynamic, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
   let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
   let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
       this.callback = callback;
       this.next = null;
     }
   }
+  dart.setSignature(_AsyncCallbackEntry, {});
   exports._nextCallback = null;
   exports._lastCallback = null;
   exports._lastPriorityCallback = null;
   exports._isInCallbackLoop = false;
-  // Function _asyncRunCallbackLoop: () → void
   function _asyncRunCallbackLoop() {
     while (exports._nextCallback != null) {
       exports._lastPriorityCallback = null;
       let entry = exports._nextCallback;
       exports._nextCallback = entry.next;
       if (exports._nextCallback == null)
         exports._lastCallback = null;
       entry.callback();
     }
   }
-  // Function _asyncRunCallback: () → void
+  dart.fn(_asyncRunCallbackLoop, dart.void, []);
   function _asyncRunCallback() {
     exports._isInCallbackLoop = true;
     try {
       _asyncRunCallbackLoop();
     } finally {
       exports._lastPriorityCallback = null;
       exports._isInCallbackLoop = false;
       if (exports._nextCallback != null)
         _AsyncRun._scheduleImmediate(_asyncRunCallback);
     }
   }
-  // Function _scheduleAsyncCallback: (dynamic) → void
+  dart.fn(_asyncRunCallback, dart.void, []);
   function _scheduleAsyncCallback(callback) {
     if (exports._nextCallback == null) {
       exports._nextCallback = exports._lastCallback = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       if (!dart.notNull(exports._isInCallbackLoop)) {
         _AsyncRun._scheduleImmediate(_asyncRunCallback);
       }
     } else {
       let newEntry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
       exports._lastCallback.next = newEntry;
       exports._lastCallback = newEntry;
     }
   }
-  // Function _schedulePriorityAsyncCallback: (dynamic) → void
+  dart.fn(_scheduleAsyncCallback, dart.void, [dart.dynamic]);
   function _schedulePriorityAsyncCallback(callback) {
     let entry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
     if (exports._nextCallback == null) {
       _scheduleAsyncCallback(callback);
       exports._lastPriorityCallback = exports._lastCallback;
     } else if (exports._lastPriorityCallback == null) {
       entry.next = exports._nextCallback;
       exports._nextCallback = exports._lastPriorityCallback = entry;
     } else {
       entry.next = exports._lastPriorityCallback.next;
       exports._lastPriorityCallback.next = entry;
       exports._lastPriorityCallback = entry;
       if (entry.next == null) {
         exports._lastCallback = entry;
       }
     }
   }
-  // Function scheduleMicrotask: (() → void) → void
+  dart.fn(_schedulePriorityAsyncCallback, dart.void, [dart.dynamic]);
   function scheduleMicrotask(callback) {
     if (core.identical(_ROOT_ZONE, Zone.current)) {
       _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
       return;
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
+  dart.fn(scheduleMicrotask, dart.void, [dart.functionType(dart.void, [])]);
   class _AsyncRun extends core.Object {
     static _scheduleImmediate(callback) {
       dart.dcall(_AsyncRun.scheduleImmediateClosure, callback);
     }
     static _initializeScheduleImmediate() {
       _js_helper.requiresPreamble();
       if (self.scheduleImmediate != null) {
         return _AsyncRun._scheduleImmediateJsOverride;
       }
       if (dart.notNull(self.MutationObserver != null) && dart.notNull(self.document != null)) {
         let div = self.document.createElement("div");
         let span = self.document.createElement("span");
         let storedCallback = null;
-        // Function internalCallback: (dynamic) → dynamic
         let internalCallback = _ => {
           _isolate_helper.leaveJsAsync();
           let f = storedCallback;
           storedCallback = null;
           dart.dcall(f);
         };
+        dart.fn(internalCallback);
         ;
         let observer = new self.MutationObserver(_js_helper.convertDartClosureToJS(internalCallback, 1));
         observer.observe(div, {childList: true});
-        return callback => {
+        return dart.fn(callback => {
           dart.assert(storedCallback == null);
           _isolate_helper.enterJsAsync();
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
-        };
+        }, dart.dynamic, [dart.functionType(dart.void, [])]);
       } else if (self.setImmediate != null) {
         return _AsyncRun._scheduleImmediateWithSetImmediate;
       }
       return _AsyncRun._scheduleImmediateWithTimer;
     }
     static _scheduleImmediateJsOverride(callback) {
-      // Function internalCallback: () → dynamic
       let internalCallback = () => {
         _isolate_helper.leaveJsAsync();
         callback();
       };
+      dart.fn(internalCallback);
       ;
       _isolate_helper.enterJsAsync();
       self.scheduleImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
     static _scheduleImmediateWithSetImmediate(callback) {
-      // Function internalCallback: () → dynamic
       let internalCallback = () => {
         _isolate_helper.leaveJsAsync();
         callback();
       };
+      dart.fn(internalCallback);
       ;
       _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, [])])
+    }),
+    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 {}
+    dart.setSignature(StreamSubscription, {});
     return StreamSubscription;
   });
   let StreamSubscription = StreamSubscription$();
   let EventSink$ = dart.generic(function(T) {
     class EventSink extends core.Object {}
     EventSink[dart.implements] = () => [core.Sink$(T)];
+    dart.setSignature(EventSink, {});
     return EventSink;
   });
   let EventSink = EventSink$();
   let _stream = Symbol('_stream');
   let StreamView$ = dart.generic(function(T) {
     class StreamView extends Stream$(T) {
       StreamView(stream) {
         this[_stream] = stream;
         super.Stream();
       }
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         dart.as(onListen, dart.functionType(dart.void, [StreamSubscription$(T)]));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription$(T)]));
         return this[_stream].asBroadcastStream({onListen: onListen, onCancel: onCancel});
       }
       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;
         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})
+      })
+    });
     return StreamView;
   });
   let StreamView = StreamView$();
   let StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {}
+    dart.setSignature(StreamConsumer, {});
     return StreamConsumer;
   });
   let StreamConsumer = StreamConsumer$();
   let StreamSink$ = dart.generic(function(S) {
     class StreamSink extends core.Object {}
     StreamSink[dart.implements] = () => [StreamConsumer$(S), EventSink$(S)];
+    dart.setSignature(StreamSink, {});
     return StreamSink;
   });
   let StreamSink = StreamSink$();
   let StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       StreamTransformer(transformer) {
         return new _StreamSubscriptionTransformer(transformer);
       }
       fromHandlers(opts) {
         return new _StreamHandlerTransformer(opts);
       }
     }
     dart.defineNamedConstructor(StreamTransformer, 'fromHandlers');
+    dart.setSignature(StreamTransformer, {});
     return StreamTransformer;
   });
   let StreamTransformer = StreamTransformer$();
   let StreamIterator$ = dart.generic(function(T) {
     class StreamIterator extends core.Object {
       StreamIterator(stream) {
         return new (_StreamIteratorImpl$(T))(stream);
       }
     }
+    dart.setSignature(StreamIterator, {});
     return StreamIterator;
   });
   let StreamIterator = StreamIterator$();
   let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
     class _ControllerEventSinkWrapper extends core.Object {
       _ControllerEventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
         this[_sink].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           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, [])
+      })
+    });
     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) {
     class StreamController extends core.Object {
       StreamController(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onPause = opts && 'onPause' in opts ? opts.onPause : null;
         let onResume = opts && 'onResume' in opts ? opts.onResume : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         if (dart.notNull(onListen == null) && dart.notNull(onPause == null) && dart.notNull(onResume == null) && dart.notNull(onCancel == null)) {
           return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
         }
         return sync ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
       }
       broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         return sync ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
     StreamController[dart.implements] = () => [StreamSink$(T)];
     dart.defineNamedConstructor(StreamController, 'broadcast');
+    dart.setSignature(StreamController, {});
     return StreamController;
   });
   let StreamController = StreamController$();
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_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)])
+      })
+    });
     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');
   let _badEventState = Symbol('_badEventState');
   let _StreamController$ = dart.generic(function(T) {
@@ skipping 154 matching lines @@
         let pendingEvents = this[_pendingEvents];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_SUBSCRIBED);
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.varData = subscription;
           addState.resume();
         } else {
           this[_varData] = subscription;
         }
         subscription[_setPendingEvents](pendingEvents);
-        subscription[_guardCallback]((() => {
+        subscription[_guardCallback](dart.fn((() => {
           _runGuarded(this[_onListen]);
-        }).bind(this));
+        }).bind(this)));
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         let result = null;
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           result = addState.cancel();
         }
         this[_varData] = null;
         this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController$()._STATE_SUBSCRIBED) | dart.notNull(_StreamController$()._STATE_ADDSTREAM)) | dart.notNull(_StreamController$()._STATE_CANCELED);
         if (this[_onCancel] != null) {
           if (result == null) {
             try {
               result = dart.as(this[_onCancel](), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
               result = new _Future();
               result[_asyncCompleteError](e, s);
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
-        // Function complete: () → void
         let complete = (() => {
           if (dart.notNull(this[_doneFuture] != null) && dart.notNull(this[_doneFuture][_mayComplete])) {
             this[_doneFuture][_asyncComplete](null);
           }
         }).bind(this);
+        dart.fn(complete, dart.void, []);
         if (result != null) {
           result = result.whenComplete(complete);
         } else {
           complete();
         }
         return result;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.pause();
         }
         _runGuarded(this[_onPause]);
       }
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         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)])
+      })
+    });
     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, [])
+      })
+    });
     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, [])
+      })
+    });
     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;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
+    dart.setSignature(_AsyncStreamController, {});
     return _AsyncStreamController;
   });
   let _AsyncStreamController = _AsyncStreamController$();
   let _SyncStreamController$ = dart.generic(function(T) {
     class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T)) {
       _SyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
+    dart.setSignature(_SyncStreamController, {});
     return _SyncStreamController;
   });
   let _SyncStreamController = _SyncStreamController$();
   class _NoCallbacks extends core.Object {
     get [_onListen]() {
       return null;
     }
     get [_onPause]() {
       return null;
     }
     get [_onResume]() {
       return null;
     }
     get [_onCancel]() {
       return null;
     }
   }
+  dart.setSignature(_NoCallbacks, {});
   class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController, _AsyncStreamControllerDispatch, _NoCallbacks) {}
   class _NoCallbackSyncStreamController extends dart.mixin(_StreamController, _SyncStreamControllerDispatch, _NoCallbacks) {}
   let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(dart.dynamic, []));
-  // Function _runGuarded: (() → dynamic) → Future<dynamic>
   function _runGuarded(notificationHandler) {
     if (notificationHandler == null)
       return null;
     try {
       let result = notificationHandler();
       if (dart.is(result, Future))
         return dart.as(result, Future);
       return null;
     } catch (e) {
       let s = dart.stackTrace(e);
       Zone.current.handleUncaughtError(e, s);
     }
 
   }
+  dart.fn(_runGuarded, Future, [_NotificationHandler]);
   let _target = Symbol('_target');
   let _StreamSinkWrapper$ = dart.generic(function(T) {
     class _StreamSinkWrapper extends core.Object {
       _StreamSinkWrapper(target) {
         this[_target] = target;
       }
       add(data) {
         dart.as(data, T);
         this[_target].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_target].addError(error, stackTrace);
       }
       close() {
         return this[_target].close();
       }
       addStream(source, opts) {
         dart.as(source, Stream$(T));
         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})
+      })
+    });
     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(controller[_add].bind(controller), {onError: cancelOnError ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : controller[_addError].bind(controller), onDone: controller[_close].bind(controller), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
-        return (e, s) => {
+        return dart.fn((e, s) => {
           controller[_addError](e, s);
           controller[_close]();
-        };
+        }, dart.dynamic, [dart.dynamic, core.StackTrace]);
       }
       pause() {
         this.addSubscription.pause();
       }
       resume() {
         this.addSubscription.resume();
       }
       cancel() {
         let cancel = this.addSubscription.cancel();
         if (cancel == null) {
           this.addStreamFuture[_asyncComplete](null);
           return null;
         }
-        return cancel.whenComplete((() => {
+        return cancel.whenComplete(dart.fn((() => {
           this.addStreamFuture[_asyncComplete](null);
-        }).bind(this));
+        }).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, [])
+      }),
+      statics: () => ({makeErrorHandler: dart.functionType(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);
         if (controller.isPaused) {
           this.addSubscription.pause();
         }
       }
     }
+    dart.setSignature(_StreamControllerAddStreamState, {});
     return _StreamControllerAddStreamState;
   });
   let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
   let _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
+    dart.setSignature(_EventSink, {});
     return _EventSink;
   });
   let _EventSink = _EventSink$();
   let _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {}
+    dart.setSignature(_EventDispatch, {});
     return _EventDispatch;
   });
   let _EventDispatch = _EventDispatch$();
   _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
   _BufferingStreamSubscription._STATE_CLOSED = 2;
   _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
   _BufferingStreamSubscription._STATE_CANCELED = 8;
   _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
   _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
   _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
@@ skipping 13 matching lines @@
         if (this[_isUsed])
           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])})
+    });
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$();
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
       this[_state] = _PendingEvents._STATE_UNSCHEDULED;
     }
     get isScheduled() {
       return this[_state] == _PendingEvents._STATE_SCHEDULED;
     }
     get [_eventScheduled]() {
       return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SCHEDULED);
     }
     schedule(dispatch) {
       if (this.isScheduled)
         return;
       dart.assert(!dart.notNull(this.isEmpty));
       if (this[_eventScheduled]) {
         dart.assert(this[_state] == _PendingEvents._STATE_CANCELED);
         this[_state] = _PendingEvents._STATE_SCHEDULED;
         return;
       }
-      scheduleMicrotask((() => {
+      scheduleMicrotask(dart.fn((() => {
         let oldState = this[_state];
         this[_state] = _PendingEvents._STATE_UNSCHEDULED;
         if (oldState == _PendingEvents._STATE_CANCELED)
           return;
         this.handleNext(dispatch);
-      }).bind(this));
+      }).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, [])
+    })
+  });
   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() {
         return this[_iterator] == null;
       }
@@ skipping 17 matching lines @@
           this[_iterator] = null;
           dispatch[_sendDone]();
         }
       }
       clear() {
         if (this.isScheduled)
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
+    dart.setSignature(_IterablePendingEvents, {
+      methods: () => ({
+        handleNext: dart.functionType(dart.void, [_EventDispatch]),
+        clear: dart.functionType(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$();
   let _DoneHandler = dart.typedef('_DoneHandler', () => dart.functionType(dart.void, []));
-  // Function _nullDataHandler: (dynamic) → void
   function _nullDataHandler(value) {
   }
-  // Function _nullErrorHandler: (dynamic, [StackTrace]) → void
+  dart.fn(_nullDataHandler, dart.void, [dart.dynamic]);
   function _nullErrorHandler(error, stackTrace) {
     if (stackTrace === void 0)
       stackTrace = null;
     Zone.current.handleUncaughtError(error, stackTrace);
   }
-  // Function _nullDoneHandler: () → void
+  dart.fn(_nullErrorHandler, dart.void, [dart.dynamic], [core.StackTrace]);
   function _nullDoneHandler() {
   }
+  dart.fn(_nullDoneHandler, dart.void, []);
   let _DelayedEvent$ = dart.generic(function(T) {
     class _DelayedEvent extends core.Object {
       _DelayedEvent() {
         this.next = null;
       }
     }
+    dart.setSignature(_DelayedEvent, {});
     return _DelayedEvent;
   });
   let _DelayedEvent = _DelayedEvent$();
   let _DelayedData$ = dart.generic(function(T) {
     class _DelayedData extends _DelayedEvent$(T) {
       _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)])})
+    });
     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])})
+  });
   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])})
+  });
   _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();
     }
     get isEmpty() {
@@ skipping 14 matching lines @@
         this.lastPendingEvent = null;
       }
       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, [])
+    })
+  });
   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])
+    })
+  });
   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;
         this[_zone] = Zone.current;
         this[_state] = 0;
@@ skipping 37 matching lines @@
           }
         }
       }
       cancel() {
         return null;
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
-        this[_onDone] = () => {
+        this[_onDone] = dart.fn(() => {
           result[_completeWithValue](null);
-        };
+        });
         return result;
       }
       [_sendDone]() {
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
         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, [])
+      })
+    });
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$();
   _DoneStreamSubscription._DONE_SENT = 1;
   _DoneStreamSubscription._SCHEDULED = 2;
   _DoneStreamSubscription._PAUSED = 4;
   let _source = Symbol('_source');
   let _onListenHandler = Symbol('_onListenHandler');
   let _onCancelHandler = Symbol('_onCancelHandler');
   let _cancelSubscription = Symbol('_cancelSubscription');
@@ skipping 64 matching lines @@
         if (this[_subscription] == null)
           return;
         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, [])
+      })
+    });
     return _AsBroadcastStream;
   });
   let _AsBroadcastStream = _AsBroadcastStream$();
   let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
     class _BroadcastSubscriptionWrapper extends core.Object {
       _BroadcastSubscriptionWrapper(stream) {
         this[_stream] = stream;
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
@@ skipping 21 matching lines @@
       get isPaused() {
         return this[_stream][_isSubscriptionPaused];
       }
       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])
+      })
+    });
     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 {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
@@ skipping 94 matching lines @@
           this[_clear]();
           hasNext[_complete](false);
           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, [])
+      })
+    });
     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;
   _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
   let __CastType20$ = dart.generic(function(T) {
     let __CastType20 = dart.typedef('__CastType20', () => dart.functionType(dart.void, [T]));
     return __CastType20;
   });
   let __CastType20 = __CastType20$();
   let __CastType22 = dart.typedef('__CastType22', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  // Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackTrace) → dynamic) → dynamic
   function _runUserCode(userCode, onSuccess, onError) {
     try {
       dart.dcall(onSuccess, userCode());
     } catch (e) {
       let s = dart.stackTrace(e);
       let replacement = Zone.current.errorCallback(e, s);
       if (replacement == null) {
         dart.dcall(onError, e, s);
       } else {
         let error = _nonNullError(replacement.error);
         let stackTrace = replacement.stackTrace;
         dart.dcall(onError, error, stackTrace);
       }
     }
 
   }
-  // Function _cancelAndError: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
+  dart.fn(_runUserCode, dart.dynamic, [dart.functionType(dart.dynamic, []), dart.functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])]);
   function _cancelAndError(subscription, future, error, stackTrace) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
-      cancelFuture.whenComplete(() => future[_completeError](error, stackTrace));
+      cancelFuture.whenComplete(dart.fn(() => future[_completeError](error, stackTrace), dart.void, []));
     } else {
       future[_completeError](error, stackTrace);
     }
   }
-  // Function _cancelAndErrorWithReplacement: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
+  dart.fn(_cancelAndError, dart.void, [StreamSubscription, _Future, dart.dynamic, core.StackTrace]);
   function _cancelAndErrorWithReplacement(subscription, future, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, stackTrace);
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     _cancelAndError(subscription, future, error, stackTrace);
   }
-  // Function _cancelAndErrorClosure: (StreamSubscription<dynamic>, _Future<dynamic>) → dynamic
+  dart.fn(_cancelAndErrorWithReplacement, dart.void, [StreamSubscription, _Future, dart.dynamic, core.StackTrace]);
   function _cancelAndErrorClosure(subscription, future) {
-    return (error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace);
+    return dart.fn((error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace), dart.void, [dart.dynamic, core.StackTrace]);
   }
-  // Function _cancelAndValue: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic) → void
+  dart.fn(_cancelAndErrorClosure, dart.dynamic, [StreamSubscription, _Future]);
   function _cancelAndValue(subscription, future, value) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
-      cancelFuture.whenComplete(() => future[_complete](value));
+      cancelFuture.whenComplete(dart.fn(() => future[_complete](value), dart.void, []));
     } else {
       future[_complete](value);
     }
   }
+  dart.fn(_cancelAndValue, dart.void, [StreamSubscription, _Future, dart.dynamic]);
   let _handleData = Symbol('_handleData');
   let _handleError = Symbol('_handleError');
   let _handleDone = Symbol('_handleDone');
   let _ForwardingStream$ = dart.generic(function(S, T) {
     class _ForwardingStream extends Stream$(T) {
       _ForwardingStream(source) {
         this[_source] = source;
         super.Stream();
       }
       get isBroadcast() {
@@ skipping 21 matching lines @@
       }
       [_handleError](error, stackTrace, sink) {
         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)])
+      })
+    });
     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;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         this[_subscription] = this[_stream][_source].listen(this[_handleData].bind(this), {onError: this[_handleError].bind(this), onDone: this[_handleDone].bind(this)});
@@ skipping 31 matching lines @@
         dart.as(data, S);
         this[_stream][_handleData](data, this);
       }
       [_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, [])
+      })
+    });
     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$();
-  // Function _addErrorWithReplacement: (_EventSink<dynamic>, dynamic, dynamic) → void
   function _addErrorWithReplacement(sink, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     sink[_addError](error, dart.as(stackTrace, core.StackTrace));
   }
+  dart.fn(_addErrorWithReplacement, dart.void, [_EventSink, dart.dynamic, dart.dynamic]);
   let _test = Symbol('_test');
   let _WhereStream$ = dart.generic(function(T) {
     class _WhereStream extends _ForwardingStream$(T, T) {
       _WhereStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         if (satisfies) {
           sink[_add](inputEvent);
         }
       }
     }
+    dart.setSignature(_WhereStream, {
+      methods: () => ({[_handleData]: dart.functionType(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');
   let _MapStream$ = dart.generic(function(S, T) {
@@ skipping 10 matching lines @@
           outputEvent = dart.as(dart.dcall(this[_transform], inputEvent), T);
         } 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)])})
+    });
     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)])})
+    });
     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;
         super._ForwardingStream(source);
@@ skipping 22 matching lines @@
               _addErrorWithReplacement(sink, e, s);
             }
             return;
           }
 
         } else {
           sink[_addError](error, stackTrace);
         }
       }
     }
+    dart.setSignature(_HandleErrorStream, {
+      methods: () => ({[_handleError]: dart.functionType(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)])})
+    });
     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);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           sink[_close]();
           return;
         }
 
         if (satisfies) {
           sink[_add](inputEvent);
         } else {
           sink[_close]();
         }
       }
     }
+    dart.setSignature(_TakeWhileStream, {
+      methods: () => ({[_handleData]: dart.functionType(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)])})
+    });
     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;
         super._ForwardingStream(source);
@@ skipping 14 matching lines @@
           this[_hasFailed] = true;
           return;
         }
 
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
           sink[_add](inputEvent);
         }
       }
     }
+    dart.setSignature(_SkipWhileStream, {
+      methods: () => ({[_handleData]: dart.functionType(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');
   let _DistinctStream$ = dart.generic(function(T) {
@@ skipping 23 matching lines @@
             return null;
           }
 
           if (!dart.notNull(isEqual)) {
             sink[_add](inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
+    dart.setSignature(_DistinctStream, {
+      methods: () => ({[_handleData]: dart.functionType(dart.void, [T, _EventSink$(T)])})
+    });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
   dart.defineLazyProperties(_DistinctStream, {
     get _SENTINEL() {
       return new core.Object();
     },
     set _SENTINEL(_) {}
   });
   let _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
         this[_sink][_add](data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           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, [])
+      })
+    });
     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) {
         this[_transformerSink] = null;
         this[_subscription] = null;
@@ skipping 69 matching lines @@
         try {
           this[_subscription] = null;
           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, [])
+      })
+    });
     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)])})
+    });
     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})})
+    });
     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) {
     let _TransformErrorHandler = dart.typedef('_TransformErrorHandler', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
@@ skipping 20 matching lines @@
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           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, [])
+      })
+    });
     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;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
-        super._StreamSinkTransformer(dart.as(outputSink => {
+        super._StreamSinkTransformer(dart.as(dart.fn(outputSink => {
           dart.as(outputSink, EventSink$(T));
           if (handleData == null)
             handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData, __CastType27);
           if (handleError == null)
             handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleError, __CastType30);
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer$()._defaultHandleDone;
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
-        }, _SinkMapper$(S, T)));
+        }, dart.dynamic, [EventSink$(T)]), _SinkMapper$(S, T)));
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return super.bind(stream);
       }
       static _defaultHandleData(data, sink) {
         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)])}),
+      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])
+      }),
+      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)])})
+    });
     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})})
+    });
     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) {
     let __CastType30 = dart.typedef('__CastType30', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
@@ skipping 23 matching lines @@
       return new _isolate_helper.TimerImpl(milliseconds, callback);
     }
     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])])
+    }),
+    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]));
   let RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]));
   let RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
   let RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]));
   let RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandler', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]));
   let ErrorCallbackHandler = dart.typedef('ErrorCallbackHandler', () => dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]));
   let ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
   let CreateTimerHandler = dart.typedef('CreateTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]));
   let CreatePeriodicTimerHandler = dart.typedef('CreatePeriodicTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]));
   let PrintHandler = dart.typedef('PrintHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]));
   let ForkHandler = dart.typedef('ForkHandler', () => dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, func) {
       this.zone = zone;
       this.function = func;
     }
   }
+  dart.setSignature(_ZoneFunction, {});
   class ZoneSpecification extends core.Object {
     ZoneSpecification(opts) {
       return new _ZoneSpecification(opts);
     }
     from(other, opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
       let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
       let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
       let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
       let print = opts && 'print' in opts ? opts.print : null;
       let fork = opts && 'fork' in opts ? opts.fork : null;
       return new ZoneSpecification({handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other.run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: runBinary != null ? runBinary : other.runBinary, registerCallback: registerCallback != null ? registerCallback : other.registerCallback, registerUnaryCallback: registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, registerBinaryCallback: registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, errorCallback: errorCallback != null ? errorCallback : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer != null ? createTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, print: print != null ? print : other.print, fork: fork != null ? fork : other.fork});
     }
   }
   dart.defineNamedConstructor(ZoneSpecification, 'from');
+  dart.setSignature(ZoneSpecification, {});
   class _ZoneSpecification extends core.Object {
     _ZoneSpecification(opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
@@ skipping 11 matching lines @@
       this.registerBinaryCallback = registerBinaryCallback;
       this.errorCallback = errorCallback;
       this.scheduleMicrotask = scheduleMicrotask;
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
   _ZoneSpecification[dart.implements] = () => [ZoneSpecification];
+  dart.setSignature(_ZoneSpecification, {});
   class ZoneDelegate extends core.Object {}
+  dart.setSignature(ZoneDelegate, {});
   class Zone extends core.Object {
     _() {
     }
     static get current() {
       return Zone._current;
     }
     static _enter(zone) {
       dart.assert(zone != null);
       dart.assert(!dart.notNull(core.identical(zone, Zone._current)));
       let previous = Zone._current;
       Zone._current = zone;
       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])
+    }),
+    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])})
+  });
   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');
   let _createPeriodicTimer = Symbol('_createPeriodicTimer');
@@ skipping 91 matching lines @@
         return _rootRunBinary(null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
-        return (() => this.runGuarded(f)).bind(this);
+        return dart.fn((() => this.runGuarded(f)).bind(this));
       } else {
-        return (() => this.run(f)).bind(this);
+        return dart.fn((() => this.run(f)).bind(this));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
-        return (arg => this.runUnaryGuarded(f, arg)).bind(this);
+        return dart.fn((arg => this.runUnaryGuarded(f, arg)).bind(this));
       } else {
-        return (arg => this.runUnary(f, arg)).bind(this);
+        return dart.fn((arg => this.runUnary(f, arg)).bind(this));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
-        return ((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this);
+        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this));
       } else {
-        return ((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this);
+        return dart.fn(((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this));
       }
     }
     get(key) {
       return null;
     }
     handleUncaughtError(error, stackTrace) {
       return _rootHandleUncaughtError(null, null, this, error, stackTrace);
     }
     fork(opts) {
       let specification = opts && 'specification' in opts ? opts.specification : null;
@@ skipping 33 matching lines @@
     createTimer(duration, f) {
       return Timer._createTimer(duration, f);
     }
     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])
+    })
+  });
   let _ROOT_ZONE = dart.const(new _RootZone());
   Zone.ROOT = _ROOT_ZONE;
   Zone._current = _ROOT_ZONE;
-  // Function _parentDelegate: (_Zone) → ZoneDelegate
   function _parentDelegate(zone) {
     if (zone.parent == null)
       return null;
     return zone.parent[_delegate];
   }
+  dart.fn(_parentDelegate, ZoneDelegate, [_Zone]);
   let _delegationTarget = Symbol('_delegationTarget');
   class _ZoneDelegate extends core.Object {
     _ZoneDelegate(delegationTarget) {
       this[_delegationTarget] = delegationTarget;
     }
     handleUncaughtError(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_handleUncaughtError];
       let implZone = implementation.zone;
       return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace);
     }
@@ skipping 54 matching lines @@
       let implZone = implementation.zone;
       dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, line);
     }
     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])
+    })
+  });
   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];
     }
     _CustomZone(parent, specification, map) {
       this.parent = parent;
@@ skipping 54 matching lines @@
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerCallback(f);
       if (runGuarded) {
-        return (() => this.runGuarded(registered)).bind(this);
+        return dart.fn((() => this.runGuarded(registered)).bind(this));
       } else {
-        return (() => this.run(registered)).bind(this);
+        return dart.fn((() => this.run(registered)).bind(this));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerUnaryCallback(f);
       if (runGuarded) {
-        return (arg => this.runUnaryGuarded(registered, arg)).bind(this);
+        return dart.fn((arg => this.runUnaryGuarded(registered, arg)).bind(this));
       } else {
-        return (arg => this.runUnary(registered, arg)).bind(this);
+        return dart.fn((arg => this.runUnary(registered, arg)).bind(this));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerBinaryCallback(f);
       if (runGuarded) {
-        return ((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this);
+        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this));
       } else {
-        return ((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this);
+        return dart.fn(((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this));
       }
     }
     get(key) {
       let result = this[_map].get(key);
       if (dart.notNull(result != null) || dart.notNull(this[_map].containsKey(key)))
         return result;
       if (this.parent != null) {
         let value = this.parent.get(key);
         if (value != null) {
           this[_map].set(key, value);
@@ skipping 80 matching lines @@
       let parentDelegate = _parentDelegate(implementation.zone);
       return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, duration, f), Timer);
     }
     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);
     }
   }
-  // Function _rootHandleUncaughtError: (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → void
+  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])
+    })
+  });
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
-    _schedulePriorityAsyncCallback(() => {
+    _schedulePriorityAsyncCallback(dart.fn(() => {
       throw new _UncaughtAsyncError(error, stackTrace);
-    });
+    }));
   }
-  // Function _rootRun: (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic
+  dart.fn(_rootHandleUncaughtError, dart.void, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
   function _rootRun(self, parent, zone, f) {
     if (dart.equals(Zone._current, zone))
       return f();
     let old = Zone._enter(zone);
     try {
       return f();
     } finally {
       Zone._leave(old);
     }
   }
-  // Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic
+  dart.fn(_rootRun, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootRunUnary(self, parent, zone, f, arg) {
     if (dart.equals(Zone._current, zone))
       return dart.dcall(f, arg);
     let old = Zone._enter(zone);
     try {
       return dart.dcall(f, arg);
     } finally {
       Zone._leave(old);
     }
   }
-  // Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic
+  dart.fn(_rootRunUnary, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]);
   function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
     if (dart.equals(Zone._current, zone))
       return dart.dcall(f, arg1, arg2);
     let old = Zone._enter(zone);
     try {
       return dart.dcall(f, arg1, arg2);
     } finally {
       Zone._leave(old);
     }
   }
-  // Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
+  dart.fn(_rootRunBinary, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]);
   function _rootRegisterCallback(self, parent, zone, f) {
     return f;
   }
-  // Function _rootRegisterUnaryCallback: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback
+  dart.fn(_rootRegisterCallback, ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootRegisterUnaryCallback(self, parent, zone, f) {
     return f;
   }
-  // Function _rootRegisterBinaryCallback: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic) → ZoneBinaryCallback
+  dart.fn(_rootRegisterUnaryCallback, ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]);
   function _rootRegisterBinaryCallback(self, parent, zone, f) {
     return f;
   }
-  // Function _rootErrorCallback: (Zone, ZoneDelegate, Zone, Object, StackTrace) → AsyncError
+  dart.fn(_rootRegisterBinaryCallback, ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
   function _rootErrorCallback(self, parent, zone, error, stackTrace) {
     return null;
   }
-  // Function _rootScheduleMicrotask: (Zone, ZoneDelegate, Zone, () → dynamic) → void
+  dart.fn(_rootErrorCallback, AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]);
   function _rootScheduleMicrotask(self, parent, zone, f) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       let hasErrorHandler = !dart.notNull(_ROOT_ZONE.inSameErrorZone(zone));
       f = zone.bindCallback(f, {runGuarded: hasErrorHandler});
     }
     _scheduleAsyncCallback(f);
   }
-  // Function _rootCreateTimer: (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer
+  dart.fn(_rootScheduleMicrotask, dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootCreateTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       callback = zone.bindCallback(callback);
     }
     return Timer._createTimer(duration, callback);
   }
-  // Function _rootCreatePeriodicTimer: (Zone, ZoneDelegate, Zone, Duration, (Timer) → void) → Timer
+  dart.fn(_rootCreateTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]);
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       callback = dart.as(zone.bindUnaryCallback(callback), __CastType36);
     }
     return Timer._createPeriodicTimer(duration, callback);
   }
-  // Function _rootPrint: (Zone, ZoneDelegate, Zone, String) → void
+  dart.fn(_rootCreatePeriodicTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]);
   function _rootPrint(self, parent, zone, line) {
     _internal.printToConsole(line);
   }
-  // Function _printToZone: (String) → void
+  dart.fn(_rootPrint, dart.void, [Zone, ZoneDelegate, Zone, core.String]);
   function _printToZone(line) {
     Zone.current.print(line);
   }
-  // Function _rootFork: (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynamic, dynamic>) → Zone
+  dart.fn(_printToZone, dart.void, [core.String]);
   function _rootFork(self, parent, zone, specification, zoneValues) {
     _internal.printToZone = _printToZone;
     if (specification == null) {
       specification = dart.const(new ZoneSpecification());
     } else if (!dart.is(specification, _ZoneSpecification)) {
       throw new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor.");
     }
     let valueMap = null;
     if (zoneValues == null) {
       if (dart.is(zone, _Zone)) {
         valueMap = zone[_map];
       } else {
         valueMap = new collection.HashMap();
       }
     } else {
       valueMap = new collection.HashMap.from(zoneValues);
     }
     return new _CustomZone(dart.as(zone, _Zone), specification, valueMap);
   }
+  dart.fn(_rootFork, Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]);
   class _RootZoneSpecification extends core.Object {
     get handleUncaughtError() {
       return _rootHandleUncaughtError;
     }
     get run() {
       return _rootRun;
     }
     get runUnary() {
       return _rootRunUnary;
     }
@@ skipping 22 matching lines @@
       return _rootCreatePeriodicTimer;
     }
     get print() {
       return _rootPrint;
     }
     get fork() {
       return _rootFork;
     }
   }
   _RootZoneSpecification[dart.implements] = () => [ZoneSpecification];
+  dart.setSignature(_RootZoneSpecification, {});
   _RootZone._rootDelegate = null;
   dart.defineLazyProperties(_RootZone, {
     get _rootMap() {
       return new collection.HashMap();
     },
     set _rootMap(_) {}
   });
-  // Function runZoned: (() → dynamic, {zoneValues: Map<dynamic, dynamic>, zoneSpecification: ZoneSpecification, onError: Function}) → dynamic
   function runZoned(body, opts) {
     let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
     let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
     let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError != null) {
-      errorHandler = (self, parent, zone, error, stackTrace) => {
+      errorHandler = dart.fn((self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
             return self.parent.runBinary(onError, error, stackTrace);
           }
           return self.parent.runUnary(dart.as(onError, __CastType38), error);
         } catch (e) {
           let s = dart.stackTrace(e);
           if (core.identical(e, error)) {
             return parent.handleUncaughtError(zone, error, stackTrace);
           } else {
             return parent.handleUncaughtError(zone, e, s);
           }
         }
 
-      };
+      }, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
     }
     if (zoneSpecification == null) {
       zoneSpecification = new ZoneSpecification({handleUncaughtError: errorHandler});
     } else if (errorHandler != null) {
       zoneSpecification = new ZoneSpecification.from(zoneSpecification, {handleUncaughtError: errorHandler});
     }
     let zone = Zone.current.fork({specification: zoneSpecification, zoneValues: zoneValues});
     if (onError != null) {
       return zone.runGuarded(body);
     } else {
       return zone.run(body);
     }
   }
+  dart.fn(runZoned, dart.dynamic, [dart.functionType(dart.dynamic, [])], {oneValue: core.Map, oneSpecificatio: ZoneSpecification, nErro: core.Function});
   let __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.void, [Timer]));
   let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   dart.copyProperties(exports, {
     get _hasDocument() {
       return typeof document == 'object';
     }
   });
   // Exports:
   exports.AsyncError = AsyncError;
   exports.Stream$ = Stream$;
@@ skipping 37 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);