additional SDK fixes. This gets all of them, once we upgrade to new analyzer

lib/runtime/dart/async.js

 dart_library.library('dart/async', null, /* Imports */[
   "dart_runtime/dart",
   '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 146 matching lines @@
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         let controller = null;
         let subscription = null;
         let onListen = (function() {
           let add = dart.bind(controller, 'add');
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
-          let eventSink = controller;
-          let addError = eventSink[_addError];
+          let eventSink = dart.as(controller, _EventSink$(T));
+          let addError = dart.bind(eventSink, _addError);
           subscription = this.listen(dart.fn(event => {
             dart.as(event, T);
             let newValue = null;
             try {
               newValue = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
               return;
             }
 
             if (dart.is(newValue, Future)) {
               subscription.pause();
               dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
             } else {
               controller.add(newValue);
             }
-          }, dart.dynamic, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
+          }, dart.dynamic, [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});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
             }), onResume: dart.fn(() => {
               subscription.resume();
             }), 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;
         let onListen = (function() {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
-          let eventSink = controller;
+          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.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
+          }, dart.dynamic, [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});
         } else {
           controller = StreamController.new({onListen: onListen, onPause: dart.fn(() => {
               subscription.pause();
             }), onResume: dart.fn(() => {
@@ skipping 430 matching lines @@
         function onData(event) {
           dart.as(event, T);
           timer.cancel();
           controller.add(event);
           timer = zone.createTimer(timeLimit, dart.as(timeout, __CastType17));
         }
         dart.fn(onData, dart.void, [T]);
         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);
+          let eventSink = dart.as(controller, _EventSink$(T));
+          eventSink[_addError](error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         dart.fn(onError, dart.void, [dart.dynamic, core.StackTrace]);
         function onDone() {
           timer.cancel();
           controller.close();
         }
         dart.fn(onDone, dart.void, []);
         let onListen = (function() {
           zone = Zone.current;
@@ skipping 697 matching lines @@
             onDone = _nullDoneHandler;
           return new (_DoneStreamSubscription$(T))(onDone);
         }
         let subscription = new (_BroadcastSubscription$(T))(this, onData, onError, onDone, cancelOnError);
         this[_addListener](dart.as(subscription, _BroadcastSubscription$(T)));
         if (dart.notNull(core.identical(this[_next], this[_previous]))) {
           _runGuarded(this[_onListen]);
         }
         return dart.as(subscription, StreamSubscription$(T));
       }
-      [_recordCancel](subscription) {
-        dart.as(subscription, StreamSubscription$(T));
+      [_recordCancel](sub) {
+        dart.as(sub, StreamSubscription$(T));
+        let subscription = dart.as(sub, _BroadcastSubscription$(T));
         if (dart.notNull(core.identical(subscription[_next], subscription)))
           return null;
         dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
-        if (dart.notNull(dart.as(subscription[_isFiring], core.bool))) {
-          dart.dcall(subscription[_setRemoveAfterFiring]);
+        if (dart.notNull(subscription[_isFiring])) {
+          subscription[_setRemoveAfterFiring]();
         } else {
           dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
-          this[_removeListener](dart.as(subscription, _BroadcastSubscription$(T)));
+          this[_removeListener](subscription);
           if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
             this[_callOnCancel]();
           }
         }
         return null;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_recordResume](subscription) {
@@ skipping 4497 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;
 });