implement tear offs

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 138 matching lines @@
         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;
+          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 => {
             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', subscription.resume);
+              dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
             } else {
               controller.add(newValue);
             }
-          }, {onError: dart.as(addError, core.Function), onDone: controller.close});
+          }, {onError: dart.as(addError, core.Function), onDone: controller.close.bind(controller)});
         }
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({
             onListen: onListen,
             onCancel: () => {
               subscription.cancel();
             },
             sync: true
           });
         } else {
@@ skipping 25 matching lines @@
             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(subscription.resume);
+              controller.addStream(newStream).whenComplete(dart.bind(subscription, 'resume'));
             }
-          }, {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close});
+          }, {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close.bind(controller)});
         }
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({
             onListen: onListen,
             onCancel: () => {
               subscription.cancel();
             },
             sync: true
           });
         } else {
@@ skipping 34 matching lines @@
         subscription = this.listen(element => {
           if (seenFirst) {
             _runUserCode(() => combine(value, element), newValue => {
               value = newValue;
             }, dart.as(_cancelAndErrorClosure(subscription, result), __CastType16));
           } else {
             value = element;
             seenFirst = true;
           }
         }, {
-          onError: result[_completeError],
+          onError: result[_completeError].bind(result),
           onDone: () => {
             if (!dart.notNull(seenFirst)) {
               try {
                 throw _internal.IterableElementError.noElement();
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
@@ skipping 56 matching lines @@
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(element => {
           _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],
+          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 => {
           _runUserCode(() => action(element), _ => {
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
         }, {
-          onError: future[_completeError],
+          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 => {
           _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],
+          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 => {
           _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],
+          onError: future[_completeError].bind(future),
           onDone: () => {
             future[_complete](false);
           },
           cancelOnError: true
         });
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
         this.listen(_ => {
           count = dart.notNull(count) + 1;
         }, {
-          onError: future[_completeError],
+          onError: future[_completeError].bind(future),
           onDone: () => {
             future[_complete](count);
           },
           cancelOnError: true
         });
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(_ => {
           _cancelAndValue(subscription, future, false);
         }, {
-          onError: future[_completeError],
+          onError: future[_completeError].bind(future),
           onDone: () => {
             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 => {
           result[core.$add](data);
         }, {
-          onError: future[_completeError],
+          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 => {
           result.add(data);
         }, {
-          onError: future[_completeError],
+          onError: future[_completeError].bind(future),
           onDone: () => {
             future[_complete](result);
           },
           cancelOnError: true
         });
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
@@ skipping 15 matching lines @@
         if (equals === void 0)
           equals = null;
         return new (_DistinctStream$(T))(this, equals);
       }
       get first() {
         let future = new (_Future$(T))();
         let subscription = null;
         subscription = this.listen(value => {
           _cancelAndValue(subscription, future, value);
         }, {
-          onError: future[_completeError],
+          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 => {
           foundResult = true;
           result = value;
         }, {
-          onError: future[_completeError],
+          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);
@@ skipping 16 matching lines @@
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
         }, {
-          onError: future[_completeError],
+          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;
       }
       firstWhere(test, opts) {
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         let future = new _Future();
         let subscription = null;
         subscription = this.listen(value => {
           _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],
+          onError: future[_completeError].bind(future),
           onDone: () => {
             if (defaultValue != null) {
-              _runUserCode(defaultValue, future[_complete], future[_completeError]);
+              _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) {
         let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen(value => {
           _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],
+          onError: future[_completeError].bind(future),
           onDone: () => {
             if (foundResult) {
               future[_complete](result);
               return;
             }
             if (defaultValue != null) {
-              _runUserCode(defaultValue, future[_complete], future[_completeError]);
+              _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);
             }
 
           },
@@ skipping 17 matching lines @@
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])));
         }, {
-          onError: future[_completeError],
+          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);
@@ skipping 10 matching lines @@
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen(value => {
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = dart.notNull(elementIndex) + 1;
         }, {
-          onError: future[_completeError],
+          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;
         let controller = null;
         let subscription = null;
         let timer = null;
         let zone = null;
         let timeout = null;
         // Function onData: (T) → void
         function onData(event) {
           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.dsend(eventSink, _addError, error, stackTrace);
+          dart.dcall(eventSink[_addError], error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }
         // Function onDone: () → void
         function onDone() {
           timer.cancel();
           controller.close();
         }
         // Function onListen: () → void
         function onListen() {
           zone = Zone.current;
@@ skipping 198 matching lines @@
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (this[_isCanceled])
           return;
         let wasPaused = this[_isPaused];
         let wasInputPaused = this[_isInputPaused];
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription[_STATE_PAUSE_COUNT]) | dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
         if (resumeSignal != null)
-          resumeSignal.whenComplete(this.resume);
+          resumeSignal.whenComplete(this.resume.bind(this));
         if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] != null))
           this[_pending].cancelSchedule();
         if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
-          this[_guardCallback](this[_onPause]);
+          this[_guardCallback](this[_onPause].bind(this));
       }
       resume() {
         if (this[_isCanceled])
           return;
         if (this[_isPaused]) {
           this[_decrementPauseCount]();
           if (!dart.notNull(this[_isPaused])) {
             if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending].isEmpty)) {
               this[_pending].schedule(this);
             } else {
               dart.assert(this[_mayResumeInput]);
               this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
               if (!dart.notNull(this[_inCallback]))
-                this[_guardCallback](this[_onResume]);
+                this[_guardCallback](this[_onResume].bind(this));
             }
           }
         }
       }
       cancel() {
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL]);
         if (this[_isCanceled])
           return this[_cancelFuture];
         this[_cancel]();
         return this[_cancelFuture];
@@ skipping 644 matching lines @@
       _DoneSubscription() {
         this[_pauseCount] = 0;
       }
       onData(handleData) {}
       onError(handleError) {}
       onDone(handleDone) {}
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (resumeSignal != null)
-          resumeSignal.then(this[_resume]);
+          resumeSignal.then(this[_resume].bind(this));
         this[_pauseCount] = dart.notNull(this[_pauseCount]) + 1;
       }
       resume() {
         this[_resume](null);
       }
       [_resume](_) {
         if (dart.notNull(this[_pauseCount]) > 0) {
           this[_pauseCount] = dart.notNull(this[_pauseCount]) - 1;
         }
       }
@@ skipping 176 matching lines @@
           if (!dart.notNull(iterator.moveNext()))
             return false;
           return new Future.sync(() => dart.dcall(f, iterator.current)).then(_ => true);
         });
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(keepGoing => {
           if (keepGoing) {
-            new Future.sync(f).then(dart.as(nextIteration, __CastType4), {onError: doneSignal[_completeError]});
+            new Future.sync(f).then(dart.as(nextIteration, __CastType4), {onError: doneSignal[_completeError].bind(doneSignal)});
           } else {
             doneSignal[_complete](null);
           }
         }, {runGuarded: true});
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
@@ skipping 1281 matching lines @@
       }
     }
     _StreamSinkWrapper[dart.implements] = () => [StreamSink$(T)];
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$();
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
-        this.addSubscription = source.listen(controller[_add], {onError: dart.as(cancelOnError ? _AddStreamState.makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
+        this.addSubscription = source.listen(controller[_add].bind(controller), {onError: dart.as(cancelOnError ? _AddStreamState.makeErrorHandler(controller) : controller[_addError].bind(controller), core.Function), onDone: controller[_close].bind(controller), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return (e, s) => {
           controller[_addError](e, s);
           controller[_close]();
         };
       }
       pause() {
         this.addSubscription.pause();
       }
@@ skipping 270 matching lines @@
       }
       get [_isScheduled]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription[_SCHEDULED])) != 0;
       }
       get isPaused() {
         return dart.notNull(this[_state]) >= dart.notNull(_DoneStreamSubscription[_PAUSED]);
       }
       [_schedule]() {
         if (this[_isScheduled])
           return;
-        this[_zone].scheduleMicrotask(this[_sendDone]);
+        this[_zone].scheduleMicrotask(this[_sendDone].bind(this));
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
       }
       onData(handleData) {}
       onError(handleError) {}
       onDone(handleDone) {
         this[_onDone] = handleDone;
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         this[_state] = dart.notNull(this[_state]) + dart.notNull(_DoneStreamSubscription[_PAUSED]);
         if (resumeSignal != null)
-          resumeSignal.whenComplete(this.resume);
+          resumeSignal.whenComplete(this.resume.bind(this));
       }
       resume() {
         if (this.isPaused) {
           this[_state] = dart.notNull(this[_state]) - dart.notNull(_DoneStreamSubscription[_PAUSED]);
           if (!dart.notNull(this.isPaused) && !dart.notNull(this[_isSent])) {
             this[_schedule]();
           }
         }
       }
       cancel() {
@@ skipping 34 matching lines @@
   let _AsBroadcastStream$ = dart.generic(function(T) {
     class _AsBroadcastStream extends Stream$(T) {
       _AsBroadcastStream(source, onListenHandler, onCancelHandler) {
         this[_source] = source;
         this[_onListenHandler] = dart.as(Zone.current.registerUnaryCallback(onListenHandler), _broadcastCallback);
         this[_onCancelHandler] = dart.as(Zone.current.registerUnaryCallback(onCancelHandler), _broadcastCallback);
         this[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
-        this[_controller] = new (_AsBroadcastStreamController$(T))(this[_onListen], this[_onCancel]);
+        this[_controller] = new (_AsBroadcastStreamController$(T))(this[_onListen].bind(this), this[_onCancel].bind(this));
       }
       get isBroadcast() {
         return true;
       }
       listen(onData, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         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(this[_controller].add, {onError: this[_controller].addError, onDone: this[_controller].close});
+          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);
       }
       [_onCancel]() {
         let shutdown = dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed);
         if (this[_onCancelHandler] != null) {
           this[_zone].runUnary(this[_onCancelHandler], new _BroadcastSubscriptionWrapper(this));
         }
         if (shutdown) {
@@ skipping 83 matching lines @@
   let _STATE_EXTRA_ERROR = Symbol('_STATE_EXTRA_ERROR');
   let _clear = Symbol('_clear');
   let _STATE_EXTRA_DONE = Symbol('_STATE_EXTRA_DONE');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
         this[_current] = null;
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl[_STATE_FOUND];
-        this[_subscription] = stream.listen(this[_onData], {onError: this[_onError], onDone: this[_onDone], cancelOnError: true});
+        this[_subscription] = stream.listen(this[_onData].bind(this), {onError: this[_onError].bind(this), onDone: this[_onDone].bind(this), cancelOnError: true});
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_state] == _StreamIteratorImpl[_STATE_DONE]) {
           return new _Future$(core.bool).immediate(false);
         }
         if (this[_state] == _StreamIteratorImpl[_STATE_MOVING]) {
           throw new core.StateError("Already waiting for next.");
@@ skipping 185 matching lines @@
     }
     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], {onError: this[_handleError], onDone: this[_handleDone]});
+        this[_subscription] = this[_stream][_source].listen(this[_handleData].bind(this), {onError: this[_handleError].bind(this), onDone: this[_handleDone].bind(this)});
       }
       [_add](data) {
         if (this[_isClosed])
           return;
         super[_add](data);
       }
       [_addError](error, stackTrace) {
         if (this[_isClosed])
           return;
         super[_addError](error, stackTrace);
@@ skipping 331 matching lines @@
   let _transformerSink = Symbol('_transformerSink');
   let _isSubscribed = Symbol('_isSubscribed');
   let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
         this[_transformerSink] = null;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
-        this[_subscription] = source.listen(this[_handleData], {onError: this[_handleError], onDone: this[_handleDone]});
+        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) {
         if (this[_isClosed]) {
           throw new core.StateError("Stream is already closed");
         }
         super[_add](data);
       }
@@ skipping 1079 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 = {}));