Update to latest analyzer

lib/runtime/dart/async.js

 dart_library.library('dart/async', null, /* Imports */[
   "dart/_runtime",
   'dart/core',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/_isolate_helper'
 ], function(exports, dart, core, _internal, collection, _isolate_helper) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 57 matching lines @@
   const _completeError = Symbol('_completeError');
   const _complete = Symbol('_complete');
   const _sink = Symbol('_sink');
   const Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       static fromFuture(future) {
         let controller = dart.as(StreamController$(T).new({sync: true}), _StreamController$(T));
         future.then(dart.fn(value => {
-          controller[_add](dart.as(value, T));
+          dart.as(value, T);
+          controller[_add](value);
           controller[_closeUnchecked]();
-        }), {onError: dart.fn((error, stackTrace) => {
+        }, dart.dynamic, [T]), {onError: dart.fn((error, stackTrace) => {
             controller[_addError](error, dart.as(stackTrace, core.StackTrace));
             controller[_closeUnchecked]();
           })});
         return controller.stream;
       }
       static fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(dart.fn(() => new (_IterablePendingEvents$(T))(data), _IterablePendingEvents$(T), []));
       }
       static periodic(period, computation) {
         if (computation === void 0) computation = null;
-        if (computation == null) computation = dart.fn(i => null, dart.bottom, [dart.dynamic]);
+        if (computation == null) computation = dart.fn(i => null, T, [core.int]);
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         function sendEvent() {
           watch.reset();
           let data = computation((() => {
             let x = computationCount;
             computationCount = dart.notNull(x) + 1;
             return x;
           })());
           controller.add(data);
         }
         dart.fn(sendEvent, dart.void, []);
         function startPeriodicTimer() {
           dart.assert(timer == null);
           timer = Timer.periodic(period, dart.fn(timer => {
             sendEvent();
-          }, dart.dynamic, [Timer]));
+          }, dart.void, [Timer]));
         }
         dart.fn(startPeriodicTimer, dart.void, []);
         controller = StreamController$(T).new({sync: true, onListen: dart.fn(() => {
             watch.start();
             startPeriodicTimer();
-          }), onPause: dart.fn(() => {
+          }, dart.void, []), onPause: dart.fn(() => {
             timer.cancel();
             timer = null;
             watch.stop();
-          }), onResume: dart.fn(() => {
+          }, dart.void, []), onResume: dart.fn(() => {
             dart.assert(timer == null);
             let elapsed = watch.elapsed;
             watch.start();
             timer = Timer.new(period['-'](elapsed), dart.fn(() => {
               timer = null;
               startPeriodicTimer();
               sendEvent();
-            }));
-          }), onCancel: dart.fn(() => {
+            }, dart.void, []));
+          }, dart.void, []), onCancel: dart.fn(() => {
             if (timer != null) timer.cancel();
             timer = null;
           })});
         return controller.stream;
       }
       static eventTransformed(source, mapSink) {
-        return new (_BoundSinkStream$(dart.dynamic, T))(source, dart.as(mapSink, _SinkMapper));
+        return new (_BoundSinkStream$(dart.dynamic, T))(source, mapSink);
       }
       get isBroadcast() {
         return false;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         dart.as(onListen, dart.functionType(dart.void, [StreamSubscription$(T)]));
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription$(T)]));
         return new (_AsBroadcastStream$(T))(this, dart.as(onListen, __CastType12), dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription])));
@@ skipping 25 matching lines @@
               controller.addError(e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
               subscription.pause();
               dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
             } else {
               controller.add(newValue);
             }
-          }, dart.dynamic, [T]), {onError: addError, onDone: dart.bind(controller, 'close')});
+          }, dart.void, [T]), {onError: addError, onDone: dart.bind(controller, 'close')});
         }).bind(this);
         dart.fn(onListen, dart.void, []);
         if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
-            }), sync: true});
+            }, dart.void, []), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
-            }), onResume: dart.fn(() => {
+            }, dart.void, []), onResume: dart.fn(() => {
               subscription.resume();
-            }), onCancel: dart.fn(() => {
+            }, dart.void, []), onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         dart.as(convert, dart.functionType(Stream$(), [T]));
         let controller = null;
         let subscription = null;
         const onListen = (function() {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = dart.as(controller, _EventSink$(T));
           subscription = this.listen(dart.fn(event => {
             dart.as(event, T);
             let newStream = null;
             try {
               newStream = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (newStream != null) {
               subscription.pause();
               controller.addStream(newStream).whenComplete(dart.bind(subscription, 'resume'));
             }
-          }, dart.dynamic, [T]), {onError: dart.bind(eventSink, _addError), onDone: dart.bind(controller, 'close')});
+          }, dart.void, [T]), {onError: dart.bind(eventSink, _addError), onDone: dart.bind(controller, 'close')});
         }).bind(this);
         dart.fn(onListen, dart.void, []);
         if (dart.notNull(this.isBroadcast)) {
           controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
               subscription.cancel();
-            }), sync: true});
+            }, dart.void, []), sync: true});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
-            }), onResume: dart.fn(() => {
+            }, dart.void, []), onResume: dart.fn(() => {
               subscription.resume();
-            }), onCancel: dart.fn(() => {
+            }, dart.void, []), onCancel: dart.fn(() => {
               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);
       }
@@ skipping 19 matching lines @@
           dart.as(element, T);
           if (dart.notNull(seenFirst)) {
             _runUserCode(dart.fn(() => combine(value, element), T, []), dart.fn(newValue => {
               dart.as(newValue, T);
               value = newValue;
             }, dart.dynamic, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
           } else {
             value = element;
             seenFirst = true;
           }
-        }, dart.dynamic, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(result, _completeError), onDone: dart.fn(() => {
             if (!dart.notNull(seenFirst)) {
               try {
                 dart.throw(_internal.IterableElementError.noElement());
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
               result[_complete](value);
             }
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return result;
       }
       fold(initialValue, combine) {
         dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, T]));
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
-          _runUserCode(dart.fn(() => dart.dcall(combine, value, element)), dart.fn(newValue => {
-            value = newValue;
+          _runUserCode(dart.fn(() => combine(value, element), dart.dynamic, []), dart.fn(newValue => {
+            value = dart.as(newValue, dart.dynamic);
           }), dart.as(_cancelAndErrorClosure(subscription, result), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.fn((e, st) => {
+        }, dart.void, [T]), {onError: dart.fn((e, st) => {
             result[_completeError](e, dart.as(st, core.StackTrace));
           }), onDone: dart.fn(() => {
             result[_complete](value);
-          }), cancelOnError: true});
+          }, dart.void, []), 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(dart.fn(element => {
           dart.as(element, T);
           if (!dart.notNull(first)) {
             buffer.write(separator);
           }
           first = false;
           try {
             buffer.write(element);
           } catch (e) {
             let s = dart.stackTrace(e);
             _cancelAndErrorWithReplacement(subscription, result, e, s);
           }
 
-        }, dart.dynamic, [T]), {onError: dart.fn(e => {
+        }, dart.void, [T]), {onError: dart.fn(e => {
             result[_completeError](e);
           }), onDone: dart.fn(() => {
             result[_complete](dart.toString(buffer));
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => dart.equals(element, needle), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, true);
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](false);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [T]));
         let future = new _Future();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => action(element), dart.void, []), dart.fn(_ => {
           }), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](null);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       every(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (!dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, false);
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](true);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       any(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(element => {
           dart.as(element, T);
           _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, true);
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](false);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
         this.listen(dart.fn(_ => {
+          dart.as(_, T);
           count = dart.notNull(count) + 1;
-        }), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](count);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.fn(_ => {
+          dart.as(_, T);
           _cancelAndValue(subscription, future, false);
-        }), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](true);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       toList() {
         let result = dart.list([], T);
         let future = new (_Future$(core.List$(T)))();
         this.listen(dart.fn(data => {
           dart.as(data, T);
           result[dartx.add](data);
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](result);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       toSet() {
         let result = core.Set$(T).new();
         let future = new (_Future$(core.Set$(T)))();
         this.listen(dart.fn(data => {
           dart.as(data, T);
           result.add(data);
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_complete](result);
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0) futureValue = null;
         return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
       }
       take(count) {
         return new (_TakeStream$(T))(this, count);
       }
       takeWhile(test) {
@@ skipping 11 matching lines @@
         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(dart.fn(value => {
           dart.as(value, T);
           _cancelAndValue(subscription, future, value);
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             try {
               dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       get last() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           foundResult = true;
           result = value;
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           if (dart.notNull(foundResult)) {
             try {
               dart.throw(_internal.IterableElementError.tooMany());
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }), cancelOnError: true});
+          }, dart.void, []), 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(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, value);
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
               dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }), cancelOnError: true});
+          }, dart.void, []), 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(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               foundResult = true;
               result = value;
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind(future, _completeError));
               return;
             }
             try {
               dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
         dart.as(test, dart.functionType(core.bool, [T]));
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.fn(isMatch => {
             if (dart.notNull(isMatch)) {
               if (dart.notNull(foundResult)) {
                 try {
                   dart.throw(_internal.IterableElementError.tooMany());
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
           }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             if (dart.notNull(foundResult)) {
               future[_complete](result);
               return;
             }
             try {
               dart.throw(_internal.IterableElementError.noElement());
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }), cancelOnError: true});
+          }, dart.void, []), cancelOnError: true});
         return future;
       }
       elementAt(index) {
         if (!(typeof index == 'number') || dart.notNull(index) < 0) dart.throw(new core.ArgumentError(index));
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen(dart.fn(value => {
           dart.as(value, T);
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
-        }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn((() => {
+        }, dart.void, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn((() => {
             future[_completeError](core.RangeError.index(index, this, "index", null, elementIndex));
-          }).bind(this)), cancelOnError: true});
+          }).bind(this), dart.void, []), 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 timeout2 = null;
@@ skipping 39 matching lines @@
         function onCancel() {
           timer.cancel();
           let result = subscription.cancel();
           subscription = null;
           return result;
         }
         dart.fn(onCancel, Future, []);
         controller = dart.notNull(this.isBroadcast) ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, dart.fn(() => {
           timer.cancel();
           subscription.pause();
-        }), dart.fn(() => {
+        }, dart.void, []), dart.fn(() => {
           subscription.resume();
           timer = zone.createTimer(timeLimit, dart.as(timeout2, dart.functionType(dart.void, [])));
-        }), onCancel);
+        }, dart.void, []), onCancel);
         return controller.stream;
       }
     }
     dart.setSignature(Stream, {
       constructors: () => ({
         Stream: [Stream$(T), []],
         fromFuture: [Stream$(T), [Future$(T)]],
         fromIterable: [Stream$(T), [core.Iterable$(T)]],
         periodic: [Stream$(T), [core.Duration], [dart.functionType(T, [core.int])]],
         eventTransformed: [Stream$(T), [Stream$(), dart.functionType(EventSink, [EventSink$(T)])]]
@@ skipping 227 matching lines @@
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
         if (dart.notNull(this[_isCanceled])) return this[_cancelFuture];
         this[_cancel]();
         return this[_cancelFuture];
       }
       asFuture(futureValue) {
         if (futureValue === void 0) futureValue = null;
         let result = new (_Future$(T))();
         this[_onDone] = dart.fn(() => {
           result[_complete](futureValue);
-        });
+        }, dart.void, []);
         this[_onError] = dart.fn(((error, stackTrace) => {
           this.cancel();
           result[_completeError](error, dart.as(stackTrace, core.StackTrace));
         }).bind(this));
         return result;
       }
       get [_isInputPaused]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED)) != 0;
       }
       get [_isClosed]() {
@@ skipping 550 matching lines @@
           subscription[_add](data);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
           if (dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
           return;
         }
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_add](data);
-        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
+        }, dart.void, [_BufferingStreamSubscription$(T)]));
       }
       [_sendError](error, stackTrace) {
         if (dart.notNull(this[_isEmpty])) return;
         this[_forEachListener](dart.fn(subscription => {
           dart.as(subscription, _BufferingStreamSubscription$(T));
           subscription[_addError](error, stackTrace);
-        }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
+        }, dart.void, [_BufferingStreamSubscription$(T)]));
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
           this[_forEachListener](dart.as(dart.fn(subscription => {
             dart.as(subscription, _BroadcastSubscription$(T));
             subscription[_close]();
-          }, dart.dynamic, [_BroadcastSubscription$(T)]), __CastType2));
+          }, dart.void, [_BroadcastSubscription$(T)]), __CastType2));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     dart.setSignature(_SyncBroadcastStreamController, {
       constructors: () => ({_SyncBroadcastStreamController: [_SyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
@@ skipping 208 matching lines @@
       static new(computation) {
         let result = new (_Future$(T))();
         Timer.run(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        }));
+        }, dart.void, []));
         return dart.as(result, Future$(T));
       }
       static microtask(computation) {
         let result = new (_Future$(T))();
         scheduleMicrotask(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        }));
+        }, dart.void, []));
         return dart.as(result, Future$(T));
       }
       static sync(computation) {
         try {
           let result = computation();
           return Future$(T).value(result);
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
           return Future$(T).error(error, stackTrace);
         }
@@ skipping 19 matching lines @@
         if (computation === void 0) computation = null;
         let result = new (_Future$(T))();
         Timer.new(duration, dart.fn(() => {
           try {
             result[_complete](computation == null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        }));
+        }, dart.void, []));
         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(theError, theStackTrace) {
           remaining = dart.notNull(remaining) - 1;
           if (values != null) {
             if (cleanUp != null) {
               for (let value2 of values) {
                 if (value2 != null) {
                   Future$().sync(dart.fn(() => {
-                    dart.dcall(cleanUp, value2);
+                    cleanUp(value2);
                   }));
                 }
               }
             }
             values = null;
             if (remaining == 0 || dart.notNull(eagerError)) {
               result[_completeError](theError, dart.as(theStackTrace, core.StackTrace));
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining == 0 && !dart.notNull(eagerError)) {
             result[_completeError](error, stackTrace);
           }
         }
         dart.fn(handleError, dart.void, [dart.dynamic, dart.dynamic]);
         for (let future of futures) {
           let pos = remaining;
           remaining = dart.notNull(pos) + 1;
           future.then(dart.fn(value => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
-              values[dartx.set](pos, value);
+              values[dartx.set](pos, dart.as(value, dart.dynamic));
               if (remaining == 0) {
                 result[_completeWithValue](values);
               }
             } else {
               if (cleanUp != null && value != null) {
                 Future$().sync(dart.fn(() => {
-                  dart.dcall(cleanUp, value);
+                  cleanUp(dart.as(value, dart.dynamic));
                 }));
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result[_completeError](error, stackTrace);
               }
             }
           }, dart.dynamic, [core.Object]), {onError: handleError});
         }
         if (remaining == 0) {
           return Future$(core.List).value(dart.const([]));
@@ skipping 380 matching lines @@
         this[_resultOrListeners] = error;
       }
       [_setError](error, stackTrace) {
         this[_setErrorObject](new AsyncError(error, stackTrace));
       }
       [_addListener](listener) {
         dart.assert(listener[_nextListener] == null);
         if (dart.notNull(this[_isComplete])) {
           this[_zone].scheduleMicrotask(dart.fn((() => {
             _Future$()._propagateToListeners(this, listener);
-          }).bind(this)));
+          }).bind(this), dart.void, []));
         } else {
           listener[_nextListener] = dart.as(this[_resultOrListeners], _FutureListener);
           this[_resultOrListeners] = listener;
         }
       }
       [_removeListeners]() {
         dart.assert(!dart.notNull(this[_isComplete]));
         let current = dart.as(this[_resultOrListeners], _FutureListener);
         this[_resultOrListeners] = null;
         let prev = null;
@@ skipping 61 matching lines @@
         dart.assert(!dart.notNull(this[_isComplete]));
         if (value == null) {
         } else if (dart.is(value, Future)) {
           let typedFuture = dart.as(value, Future$(T));
           if (dart.is(typedFuture, _Future$())) {
             let coreFuture = dart.as(typedFuture, _Future$(T));
             if (dart.notNull(coreFuture[_isComplete]) && dart.notNull(coreFuture[_hasError])) {
               this[_markPendingCompletion]();
               this[_zone].scheduleMicrotask(dart.fn((() => {
                 _Future$()._chainCoreFuture(coreFuture, this);
-              }).bind(this)));
+              }).bind(this), dart.void, []));
             } else {
               _Future$()._chainCoreFuture(coreFuture, this);
             }
           } else {
             _Future$()._chainForeignFuture(typedFuture, this);
           }
           return;
         } else {
           let typedValue = dart.as(value, T);
         }
         this[_markPendingCompletion]();
         this[_zone].scheduleMicrotask(dart.fn((() => {
           this[_completeWithValue](value);
-        }).bind(this)));
+        }).bind(this), dart.void, []));
       }
       [_asyncCompleteError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_markPendingCompletion]();
         this[_zone].scheduleMicrotask(dart.fn((() => {
           this[_completeError](error, stackTrace);
-        }).bind(this)));
+        }).bind(this), dart.void, []));
       }
       static _propagateToListeners(source, listeners) {
         while (true) {
           dart.assert(source[_isComplete]);
           let hasError = source[_hasError];
           if (listeners == null) {
             if (dart.notNull(hasError)) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
             }
@@ skipping 145 matching lines @@
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(dart.dynamic, []));
         if (dart.notNull(this[_isComplete])) return new (_Future$()).immediate(this);
         let result = new (_Future$())();
         let timer = null;
         if (onTimeout == null) {
           timer = Timer.new(timeLimit, dart.fn(() => {
             result[_completeError](new TimeoutException("Future not completed", timeLimit));
-          }));
+          }, dart.void, []));
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
           timer = Timer.new(timeLimit, dart.fn(() => {
             try {
               result[_complete](zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
               result[_completeError](e, s);
             }
 
-          }));
+          }, dart.void, []));
         }
         this.then(dart.fn(v => {
           dart.as(v, T);
           if (dart.notNull(timer.isActive)) {
             timer.cancel();
             result[_completeWithValue](v);
           }
         }, dart.dynamic, [T]), {onError: dart.fn((e, s) => {
             if (dart.notNull(timer.isActive)) {
               timer.cancel();
@@ skipping 38 matching lines @@
       names: ['_chainForeignFuture', '_chainCoreFuture', '_propagateToListeners']
     });
     return _Future;
   });
   let _Future = _Future$();
   _Future._INCOMPLETE = 0;
   _Future._PENDING_COMPLETE = 1;
   _Future._CHAINED = 2;
   _Future._VALUE = 4;
   _Future._ERROR = 8;
-  const __CastType6$ = dart.generic(function(T) {
-    const __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.dynamic, [T]));
+  const __CastType6$ = dart.generic(function(T, S) {
+    const __CastType6 = dart.typedef('__CastType6', () => dart.functionType(S, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
   const __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
   const __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   const _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
       this.callback = callback;
       this.next = null;
@@ skipping 192 matching lines @@
   let StreamConsumer = StreamConsumer$();
   const StreamSink$ = dart.generic(function(S) {
     class StreamSink extends core.Object {}
     StreamSink[dart.implements] = () => [StreamConsumer$(S), EventSink$(S)];
     return StreamSink;
   });
   let StreamSink = StreamSink$();
   const StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       static new(transformer) {
-        return new _StreamSubscriptionTransformer(transformer);
+        return new (_StreamSubscriptionTransformer$(S, T))(transformer);
       }
       static fromHandlers(opts) {
-        return new _StreamHandlerTransformer(opts);
+        return new (_StreamHandlerTransformer$(S, T))(opts);
       }
     }
     dart.setSignature(StreamTransformer, {
       constructors: () => ({
         new: [StreamTransformer$(S, T), [dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool])]],
         fromHandlers: [StreamTransformer$(S, T), [], {handleData: dart.functionType(dart.void, [S, EventSink$(T)]), handleError: dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]), handleDone: dart.functionType(dart.void, [EventSink$(T)])}]
       })
     });
     return StreamTransformer;
   });
@@ skipping 45 matching lines @@
   const __CastType18 = dart.typedef('__CastType18', () => dart.functionType(dart.void, [EventSink]));
   const StreamController$ = dart.generic(function(T) {
     class StreamController extends core.Object {
       static new(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onPause = opts && 'onPause' in opts ? opts.onPause : null;
         let onResume = opts && 'onResume' in opts ? opts.onResume : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         if (onListen == null && onPause == null && onResume == null && onCancel == null) {
-          return dart.as(dart.notNull(sync) ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
+          return dart.notNull(sync) ? new (_NoCallbackSyncStreamController$(T))() : new (_NoCallbackAsyncStreamController$(T))();
         }
         return dart.notNull(sync) ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
       }
       static broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         return dart.notNull(sync) ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
@@ skipping 368 matching lines @@
     get [_onPause]() {
       return null;
     }
     get [_onResume]() {
       return null;
     }
     get [_onCancel]() {
       return null;
     }
   }
-  class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController, _AsyncStreamControllerDispatch, _NoCallbacks) {
-    _NoCallbackAsyncStreamController() {
-      super._StreamController(...arguments);
+  const _NoCallbackAsyncStreamController$ = dart.generic(function(T) {
+    class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T), _NoCallbacks) {
+      _NoCallbackAsyncStreamController() {
+        super._StreamController(...arguments);
+      }
     }
-  }
-  class _NoCallbackSyncStreamController extends dart.mixin(_StreamController, _SyncStreamControllerDispatch, _NoCallbacks) {
-    _NoCallbackSyncStreamController() {
-      super._StreamController(...arguments);
+    return _NoCallbackAsyncStreamController;
+  });
+  let _NoCallbackAsyncStreamController = _NoCallbackAsyncStreamController$();
+  const _NoCallbackSyncStreamController$ = dart.generic(function(T) {
+    class _NoCallbackSyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T), _NoCallbacks) {
+      _NoCallbackSyncStreamController() {
+        super._StreamController(...arguments);
+      }
     }
-  }
+    return _NoCallbackSyncStreamController;
+  });
+  let _NoCallbackSyncStreamController = _NoCallbackSyncStreamController$();
   const _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(dart.dynamic, []));
   function _runGuarded(notificationHandler) {
     if (notificationHandler == null) return null;
     try {
       let result = notificationHandler();
       if (dart.is(result, Future)) return dart.as(result, Future);
       return null;
     } catch (e) {
       let s = dart.stackTrace(e);
       Zone.current.handleUncaughtError(e, s);
@@ skipping 37 matching lines @@
         addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}]
       })
     });
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$();
   const _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
-        this.addSubscription = source.listen(dart.bind(controller, _add), {onError: dart.notNull(cancelOnError) ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : dart.bind(controller, _addError), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
+        this.addSubscription = source.listen(dart.bind(controller, _add), {onError: dart.as(dart.notNull(cancelOnError) ? _AddStreamState$().makeErrorHandler(controller) : dart.bind(controller, _addError), core.Function), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return dart.fn((e, s) => {
           controller[_addError](e, s);
           controller[_close]();
         }, dart.dynamic, [dart.dynamic, core.StackTrace]);
       }
       pause() {
         this.addSubscription.pause();
       }
@@ skipping 69 matching lines @@
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending) {
         this[_pending] = pending;
         this[_isUsed] = false;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (dart.notNull(this[_isUsed])) dart.throw(new core.StateError("Stream has already been listened to."));
         this[_isUsed] = true;
-        return dart.as((() => {
-          let _ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
-          _[_setPendingEvents](this[_pending]());
-          return _;
-        }).bind(this)(), StreamSubscription$(T));
+        let _ = new (_BufferingStreamSubscription$(T))(onData, onError, onDone, cancelOnError);
+        _[_setPendingEvents](this[_pending]());
+        return _;
       }
     }
     dart.setSignature(_GeneratedStreamImpl, {
       constructors: () => ({_GeneratedStreamImpl: [_GeneratedStreamImpl$(T), [_EventGenerator]]}),
       methods: () => ({[_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$();
   const _eventScheduled = Symbol('_eventScheduled');
@@ skipping 13 matching lines @@
       if (dart.notNull(this[_eventScheduled])) {
         dart.assert(this[_state] == _PendingEvents._STATE_CANCELED);
         this[_state] = _PendingEvents._STATE_SCHEDULED;
         return;
       }
       scheduleMicrotask(dart.fn((() => {
         let oldState = this[_state];
         this[_state] = _PendingEvents._STATE_UNSCHEDULED;
         if (oldState == _PendingEvents._STATE_CANCELED) return;
         this.handleNext(dispatch);
-      }).bind(this)));
+      }).bind(this), dart.void, []));
       this[_state] = _PendingEvents._STATE_SCHEDULED;
     }
     cancelSchedule() {
       if (dart.notNull(this.isScheduled)) this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
   dart.setSignature(_PendingEvents, {
     methods: () => ({
       schedule: [dart.void, [_EventDispatch]],
       cancelSchedule: [dart.void, []]
@@ skipping 235 matching lines @@
         }
       }
       cancel() {
         return null;
       }
       asFuture(futureValue) {
         if (futureValue === void 0) futureValue = null;
         let result = new _Future();
         this[_onDone] = dart.fn(() => {
           result[_completeWithValue](null);
-        });
+        }, dart.void, []);
         return result;
       }
       [_sendDone]() {
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
         if (dart.notNull(this.isPaused)) return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._DONE_SENT);
         if (this[_onDone] != null) this[_zone].runGuarded(this[_onDone]);
       }
     }
     _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
@@ skipping 938 matching lines @@
         this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
-        let subscription = new (_SinkTransformerStreamSubscription$(dart.dynamic, T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
+        let subscription = new (_SinkTransformerStreamSubscription$(dart.dynamic, T))(this[_stream], this[_sinkMapper], onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     dart.setSignature(_BoundSinkStream, {
       constructors: () => ({_BoundSinkStream: [_BoundSinkStream$(S, T), [Stream$(S), _SinkMapper$(S, T)]]}),
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]})
     });
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
@@ skipping 43 matching lines @@
     });
     return _HandlerEventSink;
   });
   let _HandlerEventSink = _HandlerEventSink$();
   const _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
-        super._StreamSinkTransformer(dart.as(dart.fn(outputSink => {
+        super._StreamSinkTransformer(dart.fn(outputSink => {
           dart.as(outputSink, EventSink$(T));
           if (handleData == null) handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData, __CastType27);
           if (handleError == null) handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleError, __CastType30);
           if (handleDone == null) handleDone = _StreamHandlerTransformer$()._defaultHandleDone;
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
-        }, dart.dynamic, [EventSink$(T)]), _SinkMapper$(S, T)));
+        }, EventSink$(S), [EventSink$(T)]));
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return super.bind(stream);
       }
       static _defaultHandleData(data, sink) {
         sink.add(data);
       }
       static _defaultHandleError(error, stackTrace, sink) {
         sink.addError(error);
@@ skipping 153 matching lines @@
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
       let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
       let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
       let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
       let print = opts && 'print' in opts ? opts.print : null;
       let fork = opts && 'fork' in opts ? opts.fork : null;
-      return ZoneSpecification.new({handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other.run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: runBinary != null ? runBinary : other.runBinary, registerCallback: registerCallback != null ? registerCallback : other.registerCallback, registerUnaryCallback: registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, registerBinaryCallback: registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, errorCallback: errorCallback != null ? errorCallback : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer != null ? createTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, print: print != null ? print : other.print, fork: fork != null ? fork : other.fork});
+      return ZoneSpecification.new({handleUncaughtError: dart.as(handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, __CastType36), run: dart.as(run != null ? run : other.run, __CastType42), runUnary: dart.as(runUnary != null ? runUnary : other.runUnary, __CastType47), runBinary: dart.as(runBinary != null ? runBinary : other.runBinary, __CastType54), registerCallback: dart.as(registerCallback != null ? registerCallback : other.registerCallback, __CastType63), registerUnaryCallback: dart.as(registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, __CastType68), registerBinaryCallback: dart.as(registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, __CastType74), errorCallback: dart.as(errorCallback != null ? errorCallback : other.errorCallback, __CastType81), scheduleMicrotask: dart.as(scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, __CastType87), createTimer: dart.as(createTimer != null ? createTimer : other.createTimer, __CastType92), createPeriodicTimer: dart.as(createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, __CastType98), print: dart.as(print != null ? print : other.print, __CastType105), fork: dart.as(fork != null ? fork : other.fork, __CastType110)});
     }
   }
   dart.setSignature(ZoneSpecification, {
     constructors: () => ({
       new: [ZoneSpecification, [], {handleUncaughtError: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]), run: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), runUnary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]), runBinary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]), registerCallback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]), registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]), errorCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), scheduleMicrotask: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), createTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), print: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}],
       from: [ZoneSpecification, [ZoneSpecification], {handleUncaughtError: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]), run: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), runUnary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]), runBinary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]), registerCallback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), registerUnaryCallback: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]), registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]), errorCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), scheduleMicrotask: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), createTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), print: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}]
     })
   });
   class _ZoneSpecification extends core.Object {
     _ZoneSpecification(opts) {
@@ skipping 651 matching lines @@
   dart.fn(_rootScheduleMicrotask, dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]);
   function _rootCreateTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       callback = zone.bindCallback(callback);
     }
     return Timer._createTimer(duration, callback);
   }
   dart.fn(_rootCreateTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]);
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
-      callback = dart.as(zone.bindUnaryCallback(callback), __CastType36);
+      callback = dart.as(zone.bindUnaryCallback(callback), __CastType116);
     }
     return Timer._createPeriodicTimer(duration, callback);
   }
   dart.fn(_rootCreatePeriodicTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]);
   function _rootPrint(self, parent, zone, line) {
     _internal.printToConsole(line);
   }
   dart.fn(_rootPrint, dart.void, [Zone, ZoneDelegate, Zone, core.String]);
   function _printToZone(line) {
     Zone.current.print(line);
@@ skipping 72 matching lines @@
     let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
     let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
     let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError != null) {
       errorHandler = dart.fn((self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
             return self.parent.runBinary(onError, error, stackTrace);
           }
-          return self.parent.runUnary(dart.as(onError, __CastType38), error);
+          return self.parent.runUnary(dart.as(onError, __CastType118), error);
         } catch (e) {
           let s = dart.stackTrace(e);
           if (dart.notNull(core.identical(e, error))) {
             return parent.handleUncaughtError(zone, error, stackTrace);
           } else {
             return parent.handleUncaughtError(zone, e, s);
           }
         }
 
       }, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]);
     }
     if (zoneSpecification == null) {
       zoneSpecification = ZoneSpecification.new({handleUncaughtError: errorHandler});
     } else if (errorHandler != null) {
       zoneSpecification = ZoneSpecification.from(zoneSpecification, {handleUncaughtError: errorHandler});
     }
     let zone = Zone.current.fork({specification: zoneSpecification, zoneValues: zoneValues});
     if (onError != null) {
       return zone.runGuarded(body);
     } else {
       return zone.run(body);
     }
   }
   dart.fn(runZoned, dart.dynamic, [dart.functionType(dart.dynamic, [])], {zoneValues: core.Map, zoneSpecification: ZoneSpecification, onError: core.Function});
-  const __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.void, [Timer]));
-  const __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]));
+  const __CastType42 = dart.typedef('__CastType42', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
+  const __CastType47 = dart.typedef('__CastType47', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]));
+  const __CastType54 = dart.typedef('__CastType54', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]));
+  const __CastType63 = dart.typedef('__CastType63', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
+  const __CastType68 = dart.typedef('__CastType68', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]));
+  const __CastType74 = dart.typedef('__CastType74', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]));
+  const __CastType81 = dart.typedef('__CastType81', () => dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]));
+  const __CastType87 = dart.typedef('__CastType87', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
+  const __CastType92 = dart.typedef('__CastType92', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]));
+  const __CastType98 = dart.typedef('__CastType98', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]));
+  const __CastType105 = dart.typedef('__CastType105', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]));
+  const __CastType110 = dart.typedef('__CastType110', () => dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
+  const __CastType116 = dart.typedef('__CastType116', () => dart.functionType(dart.void, [Timer]));
+  const __CastType118 = dart.typedef('__CastType118', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   dart.copyProperties(exports, {
     get _hasDocument() {
       return typeof document == 'object';
     }
   });
   // Exports:
   exports.AsyncError = AsyncError;
   exports.Stream$ = Stream$;
   exports.Stream = Stream;
   exports.DeferredLibrary = DeferredLibrary;
@@ skipping 35 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;
 });