add checks needed for covariant generics, and List<E>

lib/runtime/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.dcall(errorHandler, error, stackTrace);
     } else {
       return dart.dcall(errorHandler, error);
     }
@@ skipping 63 matching lines @@
           }
         });
         return controller.stream;
       }
       fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(() => new (_IterablePendingEvents$(T))(data));
       }
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
+        dart.as(computation, dart.functionType(T, [core.int]));
         if (computation == null)
           computation = dart.as(i => null, __CastType12);
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
         function sendEvent() {
           watch.reset();
           let data = computation((() => {
@@ skipping 40 matching lines @@
         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, __CastType14), dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription])));
       }
       where(test) {
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function 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 => {
+            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)) {
@@ skipping 30 matching lines @@
         return controller.stream;
       }
       asyncExpand(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           subscription = this.listen(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) {
@@ skipping 22 matching lines @@
             onCancel: () => {
               subscription.cancel();
             },
             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) {
         return new (_ExpandStream$(T, dart.dynamic))(this, convert);
       }
       pipe(streamConsumer) {
         return streamConsumer.addStream(this).then(_ => streamConsumer.close());
       }
       transform(streamTransformer) {
         return streamTransformer.bind(this);
       }
       reduce(combine) {
         let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
         subscription = this.listen(element => {
+          dart.as(element, T);
           if (seenFirst) {
             _runUserCode(() => combine(value, element), newValue => {
+              dart.as(newValue, T);
               value = newValue;
             }, dart.as(_cancelAndErrorClosure(subscription, result), __CastType16));
           } else {
             value = element;
             seenFirst = true;
           }
         }, {
           onError: result[_completeError].bind(result),
           onDone: () => {
             if (!dart.notNull(seenFirst)) {
@@ skipping 10 matching lines @@
           },
           cancelOnError: true
         });
         return result;
       }
       fold(initialValue, combine) {
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
         subscription = this.listen(element => {
+          dart.as(element, T);
           _runUserCode(() => dart.dcall(combine, value, element), newValue => {
             value = newValue;
           }, dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
         }, {
           onError: (e, st) => {
             result[_completeError](e, dart.as(st, core.StackTrace));
           },
           onDone: () => {
             result[_complete](value);
           },
           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 => {
+          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 => {
             result[_completeError](e);
           },
           onDone: () => {
             result[_complete](dart.toString(buffer));
           },
           cancelOnError: true
         });
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(element => {
+          dart.as(element, T);
           _runUserCode(() => dart.equals(element, needle), 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: () => {
             future[_complete](false);
           },
           cancelOnError: true
         });
         return future;
       }
       forEach(action) {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen(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: () => {
             future[_complete](null);
           },
           cancelOnError: true
         });
         return future;
       }
       every(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(element => {
+          dart.as(element, T);
           _runUserCode(() => test(element), 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: () => {
             future[_complete](true);
           },
           cancelOnError: true
         });
         return future;
       }
       any(test) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(element => {
+          dart.as(element, T);
           _runUserCode(() => test(element), 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: () => {
             future[_complete](false);
           },
@@ skipping 26 matching lines @@
             future[_complete](true);
           },
           cancelOnError: true
         });
         return future;
       }
       toList() {
         let result = dart.setType([], core.List$(T));
         let future = new (_Future$(core.List$(T)))();
         this.listen(data => {
+          dart.as(data, T);
           result[core.$add](data);
         }, {
           onError: future[_completeError].bind(future),
           onDone: () => {
             future[_complete](result);
           },
           cancelOnError: true
         });
         return future;
       }
       toSet() {
         let result = new (core.Set$(T))();
         let future = new (_Future$(core.Set$(T)))();
         this.listen(data => {
+          dart.as(data, T);
           result.add(data);
         }, {
           onError: future[_completeError].bind(future),
           onDone: () => {
             future[_complete](result);
           },
           cancelOnError: true
         });
         return future;
       }
@@ skipping 10 matching lines @@
       }
       skip(count) {
         return new (_SkipStream$(T))(this, count);
       }
       skipWhile(test) {
         return new (_SkipWhileStream$(T))(this, test);
       }
       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 => {
+          dart.as(value, T);
           _cancelAndValue(subscription, future, value);
         }, {
           onError: future[_completeError].bind(future),
           onDone: () => {
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           },
           cancelOnError: true
         });
         return future;
       }
       get last() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(value => {
+          dart.as(value, T);
           foundResult = true;
           result = value;
         }, {
           onError: future[_completeError].bind(future),
           onDone: () => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           },
           cancelOnError: true
         });
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(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;
           }
@@ skipping 12 matching lines @@
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           },
           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 => {
+          dart.as(value, T);
           _runUserCode(() => test(value), 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: () => {
             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
         });
         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 => {
+          dart.as(value, T);
           _runUserCode(() => true == test(value), 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: () => {
             if (foundResult) {
@@ skipping 15 matching lines @@
           cancelOnError: true
         });
         return future;
       }
       singleWhere(test) {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(value => {
+          dart.as(value, T);
           _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);
                 }
 
@@ skipping 22 matching lines @@
         });
         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 => {
+          dart.as(value, T);
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
         }, {
           onError: future[_completeError].bind(future),
           onDone: (() => {
             future[_completeError](new core.RangeError.index(index, this, "index", null, elementIndex));
           }).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
         function onData(event) {
+          dart.as(event, T);
           timer.cancel();
           controller.add(event);
           timer = zone.createTimer(timeLimit, dart.as(timeout, __CastType19));
         }
         // Function onError: (dynamic, StackTrace) → void
         function onError(error, stackTrace) {
           timer.cancel();
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           dart.dcall(eventSink[_addError], error, stackTrace);
@@ skipping 43 matching lines @@
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     return Stream;
   });
   let Stream = Stream$();
   let _StreamImpl$ = dart.generic(function(T) {
     class _StreamImpl extends Stream$(T) {
       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) {
         return new (_BufferingStreamSubscription$(T))(onData, onError, onDone, cancelOnError);
       }
       [_onListen](subscription) {}
@@ skipping 225 matching lines @@
         this[_cancelFuture] = this[_onCancel]();
       }
       [_incrementPauseCount]() {
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
       }
       [_decrementPauseCount]() {
         dart.assert(this[_isPaused]);
         this[_state] = dart.notNull(this[_state]) - dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT);
       }
       [_add](data) {
+        dart.as(data, T);
         dart.assert(!dart.notNull(this[_isClosed]));
         if (this[_isCanceled])
           return;
         if (this[_canFire]) {
           this[_sendData](data);
         } else {
           this[_addPending](new _DelayedData(data));
         }
       }
       [_addError](error, stackTrace) {
@@ skipping 32 matching lines @@
           pending = this[_pending] = new _StreamImplEvents();
         pending.add(event);
         if (!dart.notNull(this[_hasPending])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING);
           if (!dart.notNull(this[_isPaused])) {
             this[_pending].schedule(this);
           }
         }
       }
       [_sendData](data) {
+        dart.as(data, T);
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
         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) {
@@ skipping 264 matching lines @@
       [_recordPause](subscription) {}
       [_recordResume](subscription) {}
       [_addEventError]() {
         if (this.isClosed) {
           return new core.StateError("Cannot add new events after calling close");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add new events while doing an addStream");
       }
       add(data) {
+        dart.as(data, T);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_sendData](data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
@@ skipping 13 matching lines @@
           throw this[_addEventError]();
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_CLOSED);
         let doneFuture = this[_ensureDoneFuture]();
         this[_sendDone]();
         return doneFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       addStream(stream, opts) {
+        dart.as(stream, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_ADDSTREAM);
         this[_addStreamState] = new (_AddStreamState$(T))(this, stream, cancelOnError);
         return this[_addStreamState].addStreamFuture;
       }
       [_add](data) {
+        dart.as(data, T);
         this[_sendData](data);
       }
       [_addError](error, stackTrace) {
         this[_sendError](error, stackTrace);
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = this[_addStreamState];
         this[_addStreamState] = null;
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_ADDSTREAM);
@@ skipping 44 matching lines @@
     _BroadcastStreamController._STATE_ADDSTREAM = 8;
     return _BroadcastStreamController;
   });
   let _BroadcastStreamController = _BroadcastStreamController$();
   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]();
           }
@@ skipping 24 matching lines @@
     }
     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);
         for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           subscription[_addPending](new _DelayedData(data));
         }
       }
       [_sendError](error, stackTrace) {
         for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           subscription[_addPending](new _DelayedError(error, stackTrace));
         }
@@ skipping 24 matching lines @@
       get [_hasPending]() {
         return dart.notNull(this[_pending] != null) && !dart.notNull(this[_pending].isEmpty);
       }
       [_addPendingEvent](event) {
         if (this[_pending] == null) {
           this[_pending] = new _StreamImplEvents();
         }
         this[_pending].add(event);
       }
       add(data) {
+        dart.as(data, T);
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
           this[_addPendingEvent](new (_DelayedData$(T))(data));
           return;
         }
         super.add(data);
         while (this[_hasPending]) {
           this[_pending].handleNext(this);
         }
       }
       addError(error, stackTrace) {
@@ skipping 151 matching lines @@
           if (replacement != null) {
             error = _nonNullError(replacement.error);
             stackTrace = replacement.stackTrace;
           }
         }
         return new _Future$(T).immediateError(error, stackTrace);
       }
       delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
+        dart.as(computation, dart.functionType(T, []));
         let result = new (_Future$(T))();
         new Timer(duration, () => {
           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
         function handleError(theError, theStackTrace) {
           remaining = dart.notNull(remaining) - 1;
           if (values != null) {
             if (cleanUp != null) {
@@ skipping 318 matching lines @@
       set [_isChained](value) {
         if (value) {
           dart.assert(!dart.notNull(this[_isComplete]));
           this[_state] = _Future._CHAINED;
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future._INCOMPLETE;
         }
       }
       then(f, opts) {
+        dart.as(f, dart.functionType(dart.dynamic, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           f = dart.as(result[_zone].registerUnaryCallback(f), __CastType6);
           if (onError != null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
         }
         this[_addListener](new _FutureListener.then(result, f, onError));
         return result;
       }
       catchError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
+        dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         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), __CastType8);
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
@@ skipping 14 matching lines @@
       }
       get [_value]() {
         dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasValue]));
         return dart.as(this[_resultOrListeners], T);
       }
       get [_error]() {
         dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasError]));
         return dart.as(this[_resultOrListeners], AsyncError);
       }
       [_setValue](value) {
+        dart.as(value, T);
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_state] = _Future._VALUE;
         this[_resultOrListeners] = value;
       }
       [_setErrorObject](error) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_state] = _Future._ERROR;
         this[_resultOrListeners] = error;
       }
       [_setError](error, stackTrace) {
@@ skipping 268 matching lines @@
             result[_setValue](listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
             result[_setErrorObject](asyncError);
           }
           source = result;
         }
       }
       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, () => {
             result[_completeError](new TimeoutException("Future not completed", timeLimit));
           });
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
           timer = new Timer(timeLimit, () => {
             try {
               result[_complete](zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
               result[_completeError](e, s);
             }
 
           });
         }
         this.then(v => {
+          dart.as(v, T);
           if (timer.isActive) {
             timer.cancel();
             result[_completeWithValue](v);
           }
         }, {
           onError: (e, s) => {
             if (timer.isActive) {
               timer.cancel();
               result[_completeError](e, dart.as(s, core.StackTrace));
             }
@@ skipping 172 matching lines @@
     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]));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
+        dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription]));
         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});
       }
     }
     return StreamView;
   });
   let StreamView = StreamView$();
   let StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {}
     return StreamConsumer;
@@ skipping 26 matching lines @@
     }
     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)];
     return _ControllerEventSinkWrapper;
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
   let __CastType12$ = dart.generic(function(T) {
     let __CastType12 = dart.typedef('__CastType12', () => dart.functionType(T, [core.int]));
     return __CastType12;
   });
   let __CastType12 = __CastType12$();
   let __CastType14 = dart.typedef('__CastType14', () => dart.functionType(dart.void, [StreamSubscription]));
   let __CastType16 = dart.typedef('__CastType16', () => dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]));
   let __CastType19 = dart.typedef('__CastType19', () => dart.functionType(dart.void, []));
   let __CastType20 = dart.typedef('__CastType20', () => 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;
+        dart.as(onListen, dart.functionType(dart.void, []));
         let onPause = opts && 'onPause' in opts ? opts.onPause : null;
+        dart.as(onPause, dart.functionType(dart.void, []));
         let onResume = opts && 'onResume' in opts ? opts.onResume : null;
+        dart.as(onResume, dart.functionType(dart.void, []));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
+        dart.as(onCancel, dart.functionType(dart.dynamic, []));
         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;
+        dart.as(onListen, dart.functionType(dart.void, []));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
+        dart.as(onCancel, dart.functionType(dart.void, []));
         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');
     return StreamController;
   });
   let StreamController = StreamController$();
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
@@ skipping 76 matching lines @@
         return dart.as(this[_varData], _ControllerSubscription);
       }
       [_badEventState]() {
         if (this.isClosed) {
           return new core.StateError("Cannot add event after closing");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add event while adding a stream");
       }
       addStream(source, opts) {
+        dart.as(source, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         if (this[_isCanceled])
           return new _Future.immediate(null);
         let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
         this[_varData] = addState;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController._STATE_ADDSTREAM);
         return addState.addStreamFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] == null) {
           this[_doneFuture] = this[_isCanceled] ? Future._nullFuture : new _Future();
         }
         return this[_doneFuture];
       }
       add(value) {
+        dart.as(value, T);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         this[_add](value);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
@@ skipping 15 matching lines @@
       }
       [_closeUnchecked]() {
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController._STATE_CLOSED);
         if (this.hasListener) {
           this[_sendDone]();
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(dart.const(new _DelayedDone()));
         }
       }
       [_add](value) {
+        dart.as(value, T);
         if (this.hasListener) {
           this[_sendData](value);
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new (_DelayedData$(T))(value));
         }
       }
       [_addError](error, stackTrace) {
         if (this.hasListener) {
           this[_sendError](error, stackTrace);
         } else if (this[_isInitialState]) {
@@ skipping 83 matching lines @@
     _StreamController._STATE_CANCELED = 2;
     _StreamController._STATE_SUBSCRIPTION_MASK = 3;
     _StreamController._STATE_CLOSED = 4;
     _StreamController._STATE_ADDSTREAM = 8;
     return _StreamController;
   });
   let _StreamController = _StreamController$();
   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)];
     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)];
@@ skipping 58 matching lines @@
     }
 
   }
   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)];
     return _StreamSinkWrapper;
   });
@@ skipping 172 matching lines @@
   function _nullDoneHandler() {
   }
   class _DelayedEvent extends core.Object {
     _DelayedEvent() {
       this.next = null;
     }
   }
   let _DelayedData$ = dart.generic(function(T) {
     class _DelayedData extends _DelayedEvent {
       _DelayedData(value) {
+        dart.as(value, T);
         this.value = value;
         super._DelayedEvent();
       }
       perform(dispatch) {
         dispatch[_sendData](this.value);
       }
     }
     return _DelayedData;
   });
   let _DelayedData = _DelayedData$();
@@ skipping 163 matching lines @@
         this[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
         this[_controller] = new (_AsBroadcastStreamController$(T))(this[_onListen].bind(this), this[_onCancel].bind(this));
       }
       get isBroadcast() {
         return true;
       }
       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;
         if (dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed)) {
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         if (this[_subscription] == null) {
           this[_subscription] = this[_source].listen(dart.bind(this[_controller], 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.bind(this[_controller], 'close')});
         }
         cancelOnError = core.identical(true, cancelOnError);
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
@@ skipping 143 matching lines @@
         if (this[_state] == _StreamIteratorImpl._STATE_MOVING) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
           hasNext[_complete](false);
         } else {
           this[_clear]();
         }
         return subscription.cancel();
       }
       [_onData](data) {
+        dart.as(data, T);
         if (this[_state] == _StreamIteratorImpl._STATE_MOVING) {
           this[_current] = data;
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_futureOrPrefetch] = null;
           this[_state] = _StreamIteratorImpl._STATE_FOUND;
           hasNext[_complete](true);
           return;
         }
         this[_subscription].pause();
         dart.assert(this[_futureOrPrefetch] == null);
@@ skipping 97 matching lines @@
   let _ForwardingStream$ = dart.generic(function(S, T) {
     class _ForwardingStream extends Stream$(T) {
       _ForwardingStream(source) {
         this[_source] = source;
         super.Stream();
       }
       get isBroadcast() {
         return this[_source].isBroadcast;
       }
       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);
         return this[_createSubscription](onData, onError, onDone, cancelOnError);
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         return new (_ForwardingStreamSubscription$(S, T))(this, onData, onError, onDone, cancelOnError);
       }
       [_handleData](data, sink) {
+        dart.as(data, S);
+        dart.as(sink, _EventSink$(T));
         let outputData = data;
         sink[_add](outputData);
       }
       [_handleError](error, stackTrace, sink) {
         sink[_addError](error, stackTrace);
       }
       [_handleDone](sink) {
         sink[_close]();
       }
     }
     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)});
       }
       [_add](data) {
+        dart.as(data, T);
         if (this[_isClosed])
           return;
         super[_add](data);
       }
       [_addError](error, stackTrace) {
         if (this[_isClosed])
           return;
         super[_addError](error, stackTrace);
       }
       [_onPause]() {
         if (this[_subscription] == null)
           return;
         this[_subscription].pause();
       }
       [_onResume]() {
         if (this[_subscription] == null)
           return;
         this[_subscription].resume();
       }
       [_onCancel]() {
         if (this[_subscription] != null) {
           let subscription = this[_subscription];
           this[_subscription] = null;
           subscription.cancel();
         }
         return null;
       }
       [_handleData](data) {
+        dart.as(data, S);
         this[_stream][_handleData](data, this);
       }
       [_handleError](error, stackTrace) {
         this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream][_handleDone](this);
       }
     }
     return _ForwardingStreamSubscription;
@@ skipping 14 matching lines @@
     sink[_addError](error, dart.as(stackTrace, core.StackTrace));
   }
   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) {
@@ skipping 10 matching lines @@
   });
   let _Transformation = _Transformation$();
   let _transform = Symbol('_transform');
   let _MapStream$ = dart.generic(function(S, T) {
     class _MapStream extends _ForwardingStream$(S, T) {
       _MapStream(source, transform) {
         this[_transform] = transform;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
+        dart.as(inputEvent, S);
+        dart.as(sink, _EventSink$(T));
         let outputEvent = null;
         try {
           outputEvent = dart.as(dart.dcall(this[_transform], inputEvent), T);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         sink[_add](outputEvent);
       }
     }
     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);
         }
 
       }
@@ skipping 45 matching lines @@
   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]();
           }
         }
       }
     }
     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]();
         }
       }
     }
     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);
       }
     }
     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);
       }
       [_handleData](inputEvent, sink) {
+        dart.as(inputEvent, T);
+        dart.as(sink, _EventSink$(T));
         if (this[_hasFailed]) {
           sink[_add](inputEvent);
           return;
         }
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
@@ skipping 17 matching lines @@
   let _Equality = _Equality$();
   let _equals = Symbol('_equals');
   let _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream._SENTINEL;
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
+        dart.as(inputEvent, T);
+        dart.as(sink, _EventSink$(T));
         if (core.identical(this[_previous], _DistinctStream._SENTINEL)) {
           this[_previous] = inputEvent;
           return sink[_add](inputEvent);
         } else {
           let isEqual = null;
           try {
             if (this[_equals] == null) {
               isEqual = dart.equals(this[_previous], inputEvent);
             } else {
               isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
@@ skipping 19 matching lines @@
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
   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]();
       }
@@ skipping 11 matching lines @@
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
         this[_subscription] = source.listen(this[_handleData].bind(this), {onError: this[_handleError].bind(this), onDone: this[_handleDone].bind(this)});
       }
       get [_isSubscribed]() {
         return this[_subscription] != null;
       }
       [_add](data) {
+        dart.as(data, T);
         if (this[_isClosed]) {
           throw new core.StateError("Stream is already closed");
         }
         super[_add](data);
       }
       [_addError](error, stackTrace) {
         if (this[_isClosed]) {
           throw new core.StateError("Stream is already closed");
         }
         super[_addError](error, stackTrace);
@@ skipping 14 matching lines @@
       }
       [_onCancel]() {
         if (this[_isSubscribed]) {
           let subscription = this[_subscription];
           this[_subscription] = null;
           subscription.cancel();
         }
         return null;
       }
       [_handleData](data) {
+        dart.as(data, S);
         try {
           this[_transformerSink].add(data);
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
       [_handleError](error, stackTrace) {
         if (stackTrace === void 0)
@@ skipping 47 matching lines @@
     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(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
   let _TransformDataHandler$ = dart.generic(function(S, T) {
@@ skipping 13 matching lines @@
   let _TransformDoneHandler = _TransformDoneHandler$();
   let _HandlerEventSink$ = dart.generic(function(S, T) {
     class _HandlerEventSink extends core.Object {
       _HandlerEventSink(handleData, handleError, handleDone, sink) {
         this[_handleData] = handleData;
         this[_handleError] = handleError;
         this[_handleDone] = handleDone;
         this[_sink] = sink;
       }
       add(data) {
+        dart.as(data, S);
         return this[_handleData](data, this[_sink]);
       }
       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)];
     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;
+        dart.as(handleData, dart.functionType(dart.void, [S, EventSink$(T)]));
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
+        dart.as(handleError, dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
+        dart.as(handleDone, dart.functionType(dart.void, [EventSink$(T)]));
         super._StreamSinkTransformer(dart.as(outputSink => {
           if (handleData == null)
             handleData = dart.as(_StreamHandlerTransformer._defaultHandleData, __CastType29);
           if (handleError == null)
             handleError = dart.as(_StreamHandlerTransformer._defaultHandleError, __CastType32);
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer._defaultHandleDone;
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
         }, _SinkMapper$(S, T)));
       }
@@ skipping 33 matching lines @@
   });
   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;
       }
     }
     return _BoundSubscriptionStream;
@@ skipping 857 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 || (async = {}));