Allow S->T <: dynamic->T

test/codegen/expect/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
@@ skipping 345 matching lines @@
       }
       [_sendError](error, stackTrace) {
         if (this[_isEmpty])
           return;
         this[_forEachListener](((subscription) => {
           subscription._addError(error, stackTrace);
         }).bind(this));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          this[_forEachListener](dart.as(((subscription) => {
+          this[_forEachListener](dart.closureWrap(((subscription) => {
             subscription._close();
-          }).bind(this), dart.throw_("Unimplemented type (_BufferingStreamSubscription<T>) → void")));
+          }).bind(this), "(_BufferingStreamSubscription<T>) → void"));
         } else {
           dart.assert(this[_doneFuture] !== null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture]._asyncComplete(null);
         }
       }
     }
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$(dart.dynamic);
@@ skipping 233 matching lines @@
         let error = null;
         let stackTrace = null;
         // Function handleError: (dynamic, dynamic) → void
         function 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(() => {
-                    cleanUp(value);
+                    dart.dinvokef(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);
           }
         }
         for (let future of futures) {
           let pos = (($tmp) => remaining = dart.notNull($tmp) + 1, $tmp)(remaining);
-          future.then(dart.as(((value) => {
+          future.then(((value) => {
             remaining = dart.notNull(remaining) - 1;
             if (values !== null) {
               values.set(pos, value);
               if (remaining === 0) {
                 result._completeWithValue(values);
               }
             } else {
               if (dart.notNull(cleanUp !== null) && dart.notNull(value !== null)) {
                 new Future.sync(() => {
-                  cleanUp(value);
+                  dart.dinvokef(cleanUp, value);
                 });
               }
               if (remaining === 0 && !dart.notNull(eagerError)) {
                 result._completeError(error, stackTrace);
               }
             }
-          }).bind(this), dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: handleError});
+          }).bind(this), {onError: handleError});
         }
         if (remaining === 0) {
           return dart.as(new Future.value(/* Unimplemented const */new List.from([])), Future$(core.List));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         let iterator = input.iterator;
         return doWhile((() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
-          return new Future.sync((() => f(iterator.current)).bind(this)).then((_) => true);
+          return new Future.sync((() => dart.dinvokef(f, iterator.current)).bind(this)).then((_) => true);
         }).bind(this));
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
-        nextIteration = Zone.current.bindUnaryCallback(dart.as(((keepGoing) => {
+        nextIteration = Zone.current.bindUnaryCallback(((keepGoing) => {
           if (keepGoing) {
             new Future.sync(f).then(dart.as(nextIteration, dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: doneSignal[_completeError]});
           } else {
             doneSignal._complete(null);
           }
-        }).bind(this), dart.throw_("Unimplemented type (dynamic) → dynamic")), {runGuarded: true});
+        }).bind(this), {runGuarded: true});
         dart.dinvokef(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.defineLazyProperties(Future, {
@@ skipping 244 matching lines @@
           this[_state] = _Future._CHAINED;
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future._INCOMPLETE;
         }
       }
       then(f, opt$) {
         let onError = opt$.onError === void 0 ? null : opt$.onError;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
-          f = result[_zone].registerUnaryCallback(dart.as(f, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+          f = dart.closureWrap(result[_zone].registerUnaryCallback(f), "(T) → dynamic");
           if (onError !== null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
         }
-        this[_addListener](new _FutureListener.then(result, dart.as(f, _FutureOnValue), onError));
+        this[_addListener](new _FutureListener.then(result, f, onError));
         return result;
       }
       catchError(onError, opt$) {
         let test = opt$.test === void 0 ? null : opt$.test;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           onError = _registerErrorHandler(onError, result[_zone]);
           if (test !== null)
-            test = dart.as(result[_zone].registerUnaryCallback(test), dart.throw_("Unimplemented type (dynamic) → bool"));
+            test = dart.closureWrap(result[_zone].registerUnaryCallback(test), "(dynamic) → bool");
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           action = result[_zone].registerCallback(action);
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
@@ skipping 487 matching lines @@
       return _initializeScheduleImmediate();
     }
   });
   let _sink = Symbol('_sink');
   let Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       Stream$fromFuture(future) {
         let controller = dart.as(new StreamController({sync: true}), _StreamController$(T));
-        future.then(((value) => {
+        future.then(dart.closureWrap(((value) => {
           controller._add(dart.as(value, T));
           controller._closeUnchecked();
-        }).bind(this), {onError: ((error, stackTrace) => {
+        }).bind(this), "(T) → dynamic"), {onError: ((error, stackTrace) => {
             controller._addError(error, dart.as(stackTrace, core.StackTrace));
             controller._closeUnchecked();
           }).bind(this)});
         return controller.stream;
       }
       Stream$fromIterable(data) {
         return new _GeneratedStreamImpl(() => new _IterablePendingEvents(data));
       }
       Stream$periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation === null)
-          computation = (i) => null;
+          computation = dart.closureWrap((i) => null, "(int) → T");
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
         function sendEvent() {
           watch.reset();
           let data = computation((($tmp) => computationCount = dart.notNull($tmp) + 1, $tmp)(computationCount));
           controller.add(data);
         }
@@ skipping 21 matching lines @@
               sendEvent();
             });
           }).bind(this), onCancel: (() => {
             if (timer !== null)
               timer.cancel();
             timer = null;
           }).bind(this)});
         return controller.stream;
       }
       Stream$eventTransformed(source, mapSink) {
-        return dart.as(new _BoundSinkStream(source, dart.as(mapSink, _SinkMapper)), Stream$(T));
+        return dart.as(new _BoundSinkStream(source, dart.closureWrap(mapSink, "(EventSink<dynamic>) → EventSink")), Stream$(T));
       }
       get isBroadcast() {
         return false;
       }
       asBroadcastStream(opt$) {
         let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
         let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
-        return new _AsBroadcastStream(this, dart.as(onListen, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")), dart.as(onCancel, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")));
+        return new _AsBroadcastStream(this, dart.closureWrap(onListen, "(StreamSubscription<dynamic>) → void"), dart.closureWrap(onCancel, "(StreamSubscription<dynamic>) → void"));
       }
       where(test) {
         return new _WhereStream(this, test);
       }
       map(convert) {
         return new _MapStream(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
@@ skipping 87 matching lines @@
       transform(streamTransformer) {
         return streamTransformer.bind(this);
       }
       reduce(combine) {
         let result = new _Future();
         let seenFirst = false;
         let value = null;
         let subscription = null;
         subscription = this.listen((element) => {
           if (seenFirst) {
-            _runUserCode(() => combine(value, element), dart.as((newValue) => {
+            _runUserCode(() => combine(value, element), (newValue) => {
               value = newValue;
-            }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+            }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
           } else {
             value = element;
             seenFirst = true;
           }
         }, {onError: result[_completeError], onDone: (() => {
             if (!dart.notNull(seenFirst)) {
               try {
                 throw _internal.IterableElementError.noElement();
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
               result._complete(value);
             }
           }).bind(this), cancelOnError: true});
         return result;
       }
       fold(initialValue, combine) {
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
         subscription = this.listen((element) => {
-          _runUserCode(() => combine(value, element), (newValue) => {
+          _runUserCode(() => dart.dinvokef(combine, value, element), (newValue) => {
             value = newValue;
           }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: ((e, st) => {
             result._completeError(e, dart.as(st, core.StackTrace));
           }).bind(this), onDone: (() => {
             result._complete(value);
           }).bind(this), cancelOnError: true});
         return result;
       }
       join(separator) {
@@ skipping 19 matching lines @@
             result._completeError(e);
           }).bind(this), onDone: (() => {
             result._complete(buffer.toString());
           }).bind(this), cancelOnError: true});
         return result;
       }
       contains(needle) {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((element) => {
-          _runUserCode(() => dart.equals(element, needle), dart.as((isMatch) => {
+          _runUserCode(() => dart.equals(element, needle), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(false);
           }).bind(this), cancelOnError: true});
         return future;
       }
       forEach(action) {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => action(element), (_) => {
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(null);
           }).bind(this), cancelOnError: true});
         return future;
       }
       every(test) {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((element) => {
-          _runUserCode(() => test(element), dart.as((isMatch) => {
+          _runUserCode(() => test(element), (isMatch) => {
             if (!dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, false);
             }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(true);
           }).bind(this), cancelOnError: true});
         return future;
       }
       any(test) {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((element) => {
-          _runUserCode(() => test(element), dart.as((isMatch) => {
+          _runUserCode(() => test(element), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(false);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new _Future();
         let count = 0;
-        this.listen((_) => {
+        this.listen(dart.closureWrap((_) => {
           count = dart.notNull(count) + 1;
-        }, {onError: future[_completeError], onDone: (() => {
+        }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
             future._complete(count);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get isEmpty() {
         let future = new _Future();
         let subscription = null;
-        subscription = this.listen((_) => {
+        subscription = this.listen(dart.closureWrap((_) => {
           _cancelAndValue(subscription, future, false);
-        }, {onError: future[_completeError], onDone: (() => {
+        }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
             future._complete(true);
           }).bind(this), cancelOnError: true});
         return future;
       }
       toList() {
         let result = new List.from([]);
         let future = new _Future();
         this.listen(((data) => {
           result.add(data);
         }).bind(this), {onError: future[_completeError], onDone: (() => {
@@ skipping 13 matching lines @@
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
       }
       take(count) {
         return dart.as(new _TakeStream(this, count), Stream$(T));
       }
       takeWhile(test) {
-        return dart.as(new _TakeWhileStream(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool"))), Stream$(T));
+        return dart.as(new _TakeWhileStream(this, test), Stream$(T));
       }
       skip(count) {
         return dart.as(new _SkipStream(this, count), Stream$(T));
       }
       skipWhile(test) {
-        return dart.as(new _SkipWhileStream(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool"))), Stream$(T));
+        return dart.as(new _SkipWhileStream(this, test), Stream$(T));
       }
       distinct(equals) {
         if (equals === void 0)
           equals = null;
-        return dart.as(new _DistinctStream(this, dart.as(equals, dart.throw_("Unimplemented type (dynamic, dynamic) → bool"))), Stream$(T));
+        return dart.as(new _DistinctStream(this, equals), Stream$(T));
       }
       get first() {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((value) => {
           _cancelAndValue(subscription, future, value);
         }, {
           onError: future[_completeError],
           onDone: () => {
             try {
@@ skipping 62 matching lines @@
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       firstWhere(test, opt$) {
         let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((value) => {
-          _runUserCode(() => test(value), dart.as((isMatch) => {
+          _runUserCode(() => test(value), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, value);
             }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             if (defaultValue !== null) {
               _runUserCode(defaultValue, future[_complete], future[_completeError]);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       lastWhere(test, opt$) {
         let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
-          _runUserCode(() => true === test(value), dart.as((isMatch) => {
+          _runUserCode(() => true === test(value), (isMatch) => {
             if (isMatch) {
               foundResult = true;
               result = value;
             }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             if (defaultValue !== null) {
               _runUserCode(defaultValue, future[_complete], future[_completeError]);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
-          _runUserCode(() => true === test(value), dart.as((isMatch) => {
+          _runUserCode(() => true === test(value), (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.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
@@ skipping 46 matching lines @@
           controller.close();
         }
         // Function onListen: () → void
         function onListen() {
           zone = Zone.current;
           if (onTimeout === null) {
             timeout = (() => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
             }).bind(this);
           } else {
-            onTimeout = zone.registerUnaryCallback(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+            onTimeout = dart.closureWrap(zone.registerUnaryCallback(onTimeout), "(EventSink<dynamic>) → void");
             let wrapper = new _ControllerEventSinkWrapper(null);
             timeout = (() => {
               wrapper[_sink] = controller;
-              zone.runUnaryGuarded(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")), wrapper);
+              zone.runUnaryGuarded(onTimeout, wrapper);
               wrapper[_sink] = null;
             }).bind(this);
           }
           subscription = this.listen(onData, {onError: onError, onDone: onDone});
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
         }
         // Function onCancel: () → Future<dynamic>
         function onCancel() {
           timer.cancel();
           let result = subscription.cancel();
@@ skipping 295 matching lines @@
         dart.assert(this[_isAddingStream]);
         let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
         this[_varData] = addState.varData;
         this[_state] = ~dart.notNull(_StreamController._STATE_ADDSTREAM);
         addState.complete();
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         if (!dart.notNull(this[_isInitialState])) {
           throw new core.StateError("Stream has already been listened to.");
         }
-        let subscription = new _ControllerSubscription(this, dart.as(onData, dart.throw_("Unimplemented type (dynamic) → void")), onError, onDone, cancelOnError);
+        let subscription = new _ControllerSubscription(this, onData, onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
         this[_state] = _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);
@@ skipping 221 matching lines @@
         return this[_target].done;
       }
     }
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
-        this.addSubscription = source.listen(dart.as(controller[_add], dart.throw_("Unimplemented type (dynamic) → void")), {onError: dart.as(cancelOnError ? makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
+        this.addSubscription = source.listen(controller[_add], {onError: dart.as(cancelOnError ? makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return ((e, s) => {
           controller._addError(e, s);
           controller._close();
         }).bind(this);
       }
       pause() {
         this.addSubscription.pause();
       }
@@ skipping 85 matching lines @@
         }
       }
       [_extractPending]() {
         dart.assert(this[_isCanceled]);
         let events = this[_pending];
         this[_pending] = null;
         return events;
       }
       onData(handleData) {
         if (handleData === null)
-          handleData = _nullDataHandler;
-        this[_onData] = this[_zone].registerUnaryCallback(dart.as(handleData, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+          handleData = dart.closureWrap(_nullDataHandler, "(T) → void");
+        this[_onData] = dart.closureWrap(this[_zone].registerUnaryCallback(handleData), "(T) → void");
       }
       onError(handleError) {
         if (handleError === null)
           handleError = _nullErrorHandler;
         this[_onError] = _registerErrorHandler(handleError, this[_zone]);
       }
       onDone(handleDone) {
         if (handleDone === null)
           handleDone = _nullDoneHandler;
         this[_onDone] = this[_zone].registerCallback(handleDone);
@@ skipping 150 matching lines @@
             this[_pending].schedule(this);
           }
         }
       }
       [_sendData](data) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
-        this[_zone].runUnaryGuarded(dart.as(this[_onData], dart.throw_("Unimplemented type (dynamic) → dynamic")), data);
+        this[_zone].runUnaryGuarded(this[_onData], data);
         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
         function sendError() {
@@ skipping 117 matching lines @@
         this[_isUsed] = false;
         super._StreamImpl();
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         if (this[_isUsed])
           throw new core.StateError("Stream has already been listened to.");
         this[_isUsed] = true;
         return ((_) => {
           _._setPendingEvents(this[_pending]());
           return _;
-        }).bind(this)(new _BufferingStreamSubscription(dart.as(onData, dart.throw_("Unimplemented type (dynamic) → void")), onError, onDone, cancelOnError));
+        }).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
       }
     }
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$(dart.dynamic);
   let _iterator = Symbol('_iterator');
   let _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data.iterator;
@@ skipping 250 matching lines @@
   let _onListenHandler = Symbol('_onListenHandler');
   let _onCancelHandler = Symbol('_onCancelHandler');
   let _cancelSubscription = Symbol('_cancelSubscription');
   let _pauseSubscription = Symbol('_pauseSubscription');
   let _resumeSubscription = Symbol('_resumeSubscription');
   let _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
   let _AsBroadcastStream$ = dart.generic(function(T) {
     class _AsBroadcastStream extends Stream$(T) {
       _AsBroadcastStream($_source, onListenHandler, onCancelHandler) {
         this[_source] = $_source;
-        this[_onListenHandler] = Zone.current.registerUnaryCallback(dart.as(onListenHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
-        this[_onCancelHandler] = Zone.current.registerUnaryCallback(dart.as(onCancelHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+        this[_onListenHandler] = dart.closureWrap(Zone.current.registerUnaryCallback(onListenHandler), "(StreamSubscription<dynamic>) → void");
+        this[_onCancelHandler] = dart.closureWrap(Zone.current.registerUnaryCallback(onCancelHandler), "(StreamSubscription<dynamic>) → void");
         this[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
         this[_controller] = new _AsBroadcastStreamController(this[_onListen], this[_onCancel]);
       }
       get isBroadcast() {
         return true;
       }
       listen(onData, opt$) {
         let onError = opt$.onError === void 0 ? null : opt$.onError;
         let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
         let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
         if (dart.notNull(this[_controller] === null) || dart.notNull(this[_controller].isClosed)) {
           return new _DoneStreamSubscription(onDone);
         }
         if (this[_subscription] === null) {
           this[_subscription] = this[_source].listen(this[_controller].add, {onError: this[_controller].addError, onDone: this[_controller].close});
         }
         cancelOnError = core.identical(true, cancelOnError);
         return this[_controller]._subscribe(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
         let shutdown = dart.notNull(this[_controller] === null) || dart.notNull(this[_controller].isClosed);
         if (this[_onCancelHandler] !== null) {
-          this[_zone].runUnary(dart.as(this[_onCancelHandler], dart.throw_("Unimplemented type (dynamic) → dynamic")), new _BroadcastSubscriptionWrapper(this));
+          this[_zone].runUnary(this[_onCancelHandler], new _BroadcastSubscriptionWrapper(this));
         }
         if (shutdown) {
           if (this[_subscription] !== null) {
             this[_subscription].cancel();
             this[_subscription] = null;
           }
         }
       }
       [_onListen]() {
         if (this[_onListenHandler] !== null) {
-          this[_zone].runUnary(dart.as(this[_onListenHandler], dart.throw_("Unimplemented type (dynamic) → dynamic")), new _BroadcastSubscriptionWrapper(this));
+          this[_zone].runUnary(this[_onListenHandler], new _BroadcastSubscriptionWrapper(this));
         }
       }
       [_cancelSubscription]() {
         if (this[_subscription] === null)
           return;
         let subscription = this[_subscription];
         this[_subscription] = null;
         this[_controller] = null;
         subscription.cancel();
       }
@@ skipping 162 matching lines @@
     _StreamIteratorImpl._STATE_MOVING = 2;
     _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
     _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
     _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
     return _StreamIteratorImpl;
   });
   let _StreamIteratorImpl = _StreamIteratorImpl$(dart.dynamic);
   // Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackTrace) → dynamic) → dynamic
   function _runUserCode(userCode, onSuccess, onError) {
     try {
-      onSuccess(userCode());
+      dart.dinvokef(onSuccess, userCode());
     } catch (e) {
       let s = dart.stackTrace(e);
       let replacement = Zone.current.errorCallback(e, s);
       if (replacement === null) {
-        onError(e, s);
+        dart.dinvokef(onError, e, s);
       } else {
         let error = _nonNullError(replacement.error);
         let stackTrace = replacement.stackTrace;
-        onError(error, stackTrace);
+        dart.dinvokef(onError, error, stackTrace);
       }
     }
 
   }
   // Function _cancelAndError: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
   function _cancelAndError(subscription, future, error, stackTrace) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
       cancelFuture.whenComplete(() => future._completeError(error, stackTrace));
     } else {
@@ skipping 138 matching lines @@
         }
       }
     }
     return _WhereStream;
   });
   let _WhereStream = _WhereStream$(dart.dynamic);
   let _transform = Symbol('_transform');
   let _MapStream$ = dart.generic(function(S, T) {
     class _MapStream extends _ForwardingStream$(S, T) {
       _MapStream(source, transform) {
-        this[_transform] = dart.as(transform, _Transformation);
+        this[_transform] = transform;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         let outputEvent = null;
         try {
-          outputEvent = dart.as(this[_transform](inputEvent), T);
+          outputEvent = dart.as(dart.dinvokef(this[_transform], inputEvent), T);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         sink._add(outputEvent);
       }
     }
     return _MapStream;
@@ skipping 25 matching lines @@
     class _HandleErrorStream extends _ForwardingStream$(T, T) {
       _HandleErrorStream(source, onError, test) {
         this[_transform] = onError;
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleError](error, stackTrace, sink) {
         let matches = true;
         if (this[_test] !== null) {
           try {
-            matches = this[_test](error);
+            matches = dart.dinvokef(this[_test], error);
           } catch (e) {
             let s = dart.stackTrace(e);
             _addErrorWithReplacement(sink, e, s);
             return;
           }
 
         }
         if (matches) {
           try {
             _invokeErrorHandler(this[_transform], error, stackTrace);
@@ skipping 285 matching lines @@
       _BoundSinkStream($_stream, $_sinkMapper) {
         this[_stream] = $_stream;
         this[_sinkMapper] = $_sinkMapper;
         super.Stream();
       }
       listen(onData, opt$) {
         let onError = opt$.onError === void 0 ? null : opt$.onError;
         let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
         let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
         cancelOnError = core.identical(true, cancelOnError);
-        let subscription = dart.as(new _SinkTransformerStreamSubscription(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), dart.as(onData, dart.throw_("Unimplemented type (dynamic) → void")), onError, onDone, cancelOnError), StreamSubscription$(T));
+        let subscription = dart.as(new _SinkTransformerStreamSubscription(this[_stream], dart.closureWrap(this[_sinkMapper], "(EventSink<dynamic>) → EventSink"), onData, onError, onDone, cancelOnError), StreamSubscription$(T));
         return subscription;
       }
     }
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$(dart.dynamic, dart.dynamic);
   let _HandlerEventSink$ = dart.generic(function(S, T) {
     class _HandlerEventSink extends core.Object {
       _HandlerEventSink($_handleData, $_handleError, $_handleDone, $_sink) {
         this[_handleData] = $_handleData;
@@ skipping 18 matching lines @@
   let _HandlerEventSink = _HandlerEventSink$(dart.dynamic, dart.dynamic);
   let _defaultHandleData = Symbol('_defaultHandleData');
   let _defaultHandleError = Symbol('_defaultHandleError');
   let _defaultHandleDone = Symbol('_defaultHandleDone');
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opt$) {
         let handleData = opt$.handleData === void 0 ? null : opt$.handleData;
         let handleError = opt$.handleError === void 0 ? null : opt$.handleError;
         let handleDone = opt$.handleDone === void 0 ? null : opt$.handleDone;
-        super._StreamSinkTransformer(dart.as((outputSink) => {
+        super._StreamSinkTransformer(dart.closureWrap((outputSink) => {
           if (handleData === null)
-            handleData = _defaultHandleData;
+            handleData = dart.closureWrap(_defaultHandleData, "(S, EventSink<T>) → void");
           if (handleError === null)
-            handleError = _defaultHandleError;
+            handleError = dart.closureWrap(_defaultHandleError, "(Object, StackTrace, EventSink<T>) → void");
           if (handleDone === null)
             handleDone = _defaultHandleDone;
           return new _HandlerEventSink(handleData, handleError, handleDone, outputSink);
-        }, _SinkMapper));
+        }, "(EventSink<T>) → EventSink<S>"));
       }
       bind(stream) {
         return super.bind(stream);
       }
       static [_defaultHandleData](data, sink) {
         sink.add(data);
       }
       static [_defaultHandleError](error, stackTrace, sink) {
         sink.addError(error);
       }
@@ skipping 45 matching lines @@
     Timer(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createTimer(duration, callback);
       }
       return Zone.current.createTimer(duration, Zone.current.bindCallback(callback, {runGuarded: true}));
     }
     Timer$periodic(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createPeriodicTimer(duration, callback);
       }
-      return Zone.current.createPeriodicTimer(duration, Zone.current.bindUnaryCallback(dart.as(callback, dart.throw_("Unimplemented type (dynamic) → dynamic")), {runGuarded: true}));
+      return Zone.current.createPeriodicTimer(duration, dart.closureWrap(Zone.current.bindUnaryCallback(callback, {runGuarded: true}), "(Timer) → void"));
     }
     static run(callback) {
       new Timer(core.Duration.ZERO, callback);
     }
     static [_createTimer](duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl(milliseconds, callback);
     }
@@ skipping 404 matching lines @@
     let old = Zone._enter(zone);
     try {
       return f();
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic
   function _rootRunUnary(self, parent, zone, f, arg) {
     if (dart.equals(Zone[_current], zone))
-      return f(arg);
+      return dart.dinvokef(f, arg);
     let old = Zone._enter(zone);
     try {
-      return f(arg);
+      return dart.dinvokef(f, arg);
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic
   function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
     if (dart.equals(Zone[_current], zone))
-      return f(arg1, arg2);
+      return dart.dinvokef(f, arg1, arg2);
     let old = Zone._enter(zone);
     try {
-      return f(arg1, arg2);
+      return dart.dinvokef(f, arg1, arg2);
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
   function _rootRegisterCallback(self, parent, zone, f) {
     return f;
   }
   // Function _rootRegisterUnaryCallback: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback
   function _rootRegisterUnaryCallback(self, parent, zone, f) {
@@ skipping 18 matching lines @@
   // Function _rootCreateTimer: (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer
   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
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
-      callback = zone.bindUnaryCallback(dart.as(callback, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+      callback = dart.closureWrap(zone.bindUnaryCallback(callback), "(Timer) → void");
     }
     return Timer._createPeriodicTimer(duration, callback);
   }
   // Function _rootPrint: (Zone, ZoneDelegate, Zone, String) → void
   function _rootPrint(self, parent, zone, line) {
     _internal.printToConsole(line);
   }
   // Function _printToZone: (String) → void
   function _printToZone(line) {
     Zone.current.print(line);
@@ skipping 124 matching lines @@
         return _rootRun(null, null, this, f);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runUnaryGuarded(f, arg) {
       try {
         if (core.identical(_ROOT_ZONE, Zone[_current])) {
-          return f(arg);
+          return dart.dinvokef(f, arg);
         }
         return _rootRunUnary(null, null, this, f, arg);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
         if (core.identical(_ROOT_ZONE, Zone[_current])) {
-          return f(arg1, arg2);
+          return dart.dinvokef(f, arg1, arg2);
         }
         return _rootRunBinary(null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opt$) {
       let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
@@ skipping 30 matching lines @@
       let zoneValues = opt$.zoneValues === void 0 ? null : opt$.zoneValues;
       return _rootFork(null, null, this, specification, zoneValues);
     }
     run(f) {
       if (core.identical(Zone[_current], _ROOT_ZONE))
         return f();
       return _rootRun(null, null, this, f);
     }
     runUnary(f, arg) {
       if (core.identical(Zone[_current], _ROOT_ZONE))
-        return f(arg);
+        return dart.dinvokef(f, arg);
       return _rootRunUnary(null, null, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
       if (core.identical(Zone[_current], _ROOT_ZONE))
-        return f(arg1, arg2);
+        return dart.dinvokef(f, arg1, arg2);
       return _rootRunBinary(null, null, this, f, arg1, arg2);
     }
     registerCallback(f) {
       return f;
     }
     registerUnaryCallback(f) {
       return f;
     }
     registerBinaryCallback(f) {
       return f;
@@ skipping 90 matching lines @@
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.AsyncError = AsyncError;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));