fixes #43, remove => workaround

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _js_helper = dart.lazyImport(_js_helper);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _js_helper, _isolate_helper, collection) {
   'use strict';
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
@@ skipping 141 matching lines @@
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         dart.as(convert, dart.functionType(core.Object, [T]));
         return new (_MapStream$(T, core.Object))(this, convert);
       }
       asyncMap(convert) {
         dart.as(convert, dart.functionType(core.Object, [T]));
         let controller = null;
         let subscription = null;
-        let onListen = (() => {
+        let onListen = () => {
           let add = dart.bind(controller, 'add');
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           let addError = 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);
             }
           }, core.Object, [T]), {onError: dart.as(addError, core.Function), onDone: dart.bind(controller, 'close')});
-        }).bind(this);
+        };
         dart.fn(onListen, dart.void, []);
         if (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 = (() => {
+        let onListen = () => {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           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'));
             }
           }, core.Object, [T]), {onError: dart.as(eventSink[_addError], core.Function), onDone: dart.bind(controller, 'close')});
-        }).bind(this);
+        };
         dart.fn(onListen, dart.void, []);
         if (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();
@@ skipping 406 matching lines @@
         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;
-        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn((() => {
+        }, core.Object, [T]), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
             future[_completeError](core.RangeError.index(index, this, "index", null, elementIndex));
-          }).bind(this)), cancelOnError: true});
+          }), cancelOnError: true});
         return future;
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         dart.as(onTimeout, dart.functionType(dart.void, [EventSink]));
         let controller = null;
         let subscription = null;
         let timer = null;
         let zone = null;
         let timeout = null;
@@ skipping 10 matching lines @@
           let eventSink = controller;
           dart.dcall(eventSink[_addError], error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         };
         dart.fn(onError, dart.void, [core.Object, core.StackTrace]);
         let onDone = () => {
           timer.cancel();
           controller.close();
         };
         dart.fn(onDone, dart.void, []);
-        let onListen = (() => {
+        let onListen = () => {
           zone = Zone.current;
           if (onTimeout == null) {
             timeout = dart.fn(() => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
             });
           } else {
             onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), __CastType18);
             let wrapper = new _ControllerEventSinkWrapper(null);
             timeout = dart.fn(() => {
               wrapper[_sink] = controller;
               zone.runUnaryGuarded(onTimeout, wrapper);
               wrapper[_sink] = null;
             });
           }
           subscription = this.listen(onData, {onError: onError, onDone: onDone});
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
-        }).bind(this);
+        };
         dart.fn(onListen, dart.void, []);
         let onCancel = () => {
           timer.cancel();
           let result = subscription.cancel();
           subscription = null;
           return result;
         };
         dart.fn(onCancel, Future, []);
         controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, dart.fn(() => {
           timer.cancel();
@@ skipping 258 matching lines @@
         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);
         });
-        this[_onError] = dart.fn(((error, stackTrace) => {
+        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]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED)) != 0;
       }
       get [_isCanceled]() {
         return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED)) != 0;
@@ skipping 100 matching lines @@
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         this[_zone].runUnaryGuarded(this[_onData], data);
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         this[_checkState](wasInputPaused);
       }
       [_sendError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
-        let sendError = (() => {
+        let sendError = () => {
           if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
             this[_zone].runBinaryGuarded(dart.as(this[_onError], __CastType22), error, stackTrace);
           } else {
             this[_zone].runUnaryGuarded(dart.as(this[_onError], __CastType25), error);
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
-        }).bind(this);
+        };
         dart.fn(sendError, dart.void, []);
         if (this[_cancelOnError]) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
           this[_cancel]();
           if (dart.is(this[_cancelFuture], Future)) {
             this[_cancelFuture].whenComplete(sendError);
           } else {
             sendError();
           }
         } else {
           sendError();
           this[_checkState](wasInputPaused);
         }
       }
       [_sendDone]() {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
-        let sendDone = (() => {
+        let sendDone = () => {
           if (!dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           this[_zone].runGuarded(this[_onDone]);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
-        }).bind(this);
+        };
         dart.fn(sendDone, dart.void, []);
         this[_cancel]();
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
         if (dart.is(this[_cancelFuture], Future)) {
           this[_cancelFuture].whenComplete(sendDone);
         } else {
           sendDone();
         }
       }
       [_guardCallback](callback) {
@@ skipping 1175 matching lines @@
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_state] = _Future$()._ERROR;
         this[_resultOrListeners] = error;
       }
       [_setError](error, stackTrace) {
         this[_setErrorObject](new AsyncError(error, stackTrace));
       }
       [_addListener](listener) {
         dart.assert(listener[_nextListener] == null);
         if (this[_isComplete]) {
-          this[_zone].scheduleMicrotask(dart.fn((() => {
+          this[_zone].scheduleMicrotask(dart.fn(() => {
             _Future$()._propagateToListeners(this, listener);
-          }).bind(this)));
+          }));
         } 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 @@
       }
       [_asyncComplete](value) {
         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((() => {
+              this[_zone].scheduleMicrotask(dart.fn(() => {
                 _Future$()._chainCoreFuture(coreFuture, this);
-              }).bind(this)));
+              }));
             } 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[_zone].scheduleMicrotask(dart.fn(() => {
           this[_completeWithValue](value);
-        }).bind(this)));
+        }));
       }
       [_asyncCompleteError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_markPendingCompletion]();
-        this[_zone].scheduleMicrotask(dart.fn((() => {
+        this[_zone].scheduleMicrotask(dart.fn(() => {
           this[_completeError](error, stackTrace);
-        }).bind(this)));
+        }));
       }
       static _propagateToListeners(source, listeners) {
         while (true) {
           dart.assert(source[_isComplete]);
           let hasError = source[_hasError];
           if (listeners == null) {
             if (hasError) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
             }
@@ skipping 722 matching lines @@
         let pendingEvents = this[_pendingEvents];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_SUBSCRIBED);
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.varData = subscription;
           addState.resume();
         } else {
           this[_varData] = subscription;
         }
         subscription[_setPendingEvents](pendingEvents);
-        subscription[_guardCallback](dart.fn((() => {
+        subscription[_guardCallback](dart.fn(() => {
           _runGuarded(this[_onListen]);
-        }).bind(this)));
+        }));
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         let result = null;
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           result = addState.cancel();
         }
         this[_varData] = null;
         this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController$()._STATE_SUBSCRIBED) | dart.notNull(_StreamController$()._STATE_ADDSTREAM)) | dart.notNull(_StreamController$()._STATE_CANCELED);
         if (this[_onCancel] != null) {
           if (result == null) {
             try {
               result = dart.as(this[_onCancel](), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
               result = new _Future();
               result[_asyncCompleteError](e, s);
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
-        let complete = (() => {
+        let complete = () => {
           if (dart.notNull(this[_doneFuture] != null) && dart.notNull(this[_doneFuture][_mayComplete])) {
             this[_doneFuture][_asyncComplete](null);
           }
-        }).bind(this);
+        };
         dart.fn(complete, dart.void, []);
         if (result != null) {
           result = result.whenComplete(complete);
         } else {
           complete();
         }
         return result;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
@@ skipping 211 matching lines @@
       }
       resume() {
         this.addSubscription.resume();
       }
       cancel() {
         let cancel = this.addSubscription.cancel();
         if (cancel == null) {
           this.addStreamFuture[_asyncComplete](null);
           return null;
         }
-        return cancel.whenComplete(dart.fn((() => {
+        return cancel.whenComplete(dart.fn(() => {
           this.addStreamFuture[_asyncComplete](null);
-        }).bind(this)));
+        }));
       }
       complete() {
         this.addStreamFuture[_asyncComplete](null);
       }
     }
     dart.setSignature(_AddStreamState, {
       constructors: () => ({_AddStreamState: [_AddStreamState$(T), [_EventSink$(T), Stream, core.bool]]}),
       methods: () => ({
         pause: [dart.void, []],
         resume: [dart.void, []],
@@ skipping 52 matching lines @@
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (this[_isUsed])
           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));
+        })(), StreamSubscription$(T));
       }
     }
     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$();
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
       this[_state] = _PendingEvents._STATE_UNSCHEDULED;
     }
     get isScheduled() {
       return this[_state] == _PendingEvents._STATE_SCHEDULED;
     }
     get [_eventScheduled]() {
       return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SCHEDULED);
     }
     schedule(dispatch) {
       if (this.isScheduled)
         return;
       dart.assert(!dart.notNull(this.isEmpty));
       if (this[_eventScheduled]) {
         dart.assert(this[_state] == _PendingEvents._STATE_CANCELED);
         this[_state] = _PendingEvents._STATE_SCHEDULED;
         return;
       }
-      scheduleMicrotask(dart.fn((() => {
+      scheduleMicrotask(dart.fn(() => {
         let oldState = this[_state];
         this[_state] = _PendingEvents._STATE_UNSCHEDULED;
         if (oldState == _PendingEvents._STATE_CANCELED)
           return;
         this.handleNext(dispatch);
-      }).bind(this)));
+      }));
       this[_state] = _PendingEvents._STATE_SCHEDULED;
     }
     cancelSchedule() {
       if (this.isScheduled)
         this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
   dart.setSignature(_PendingEvents, {
     methods: () => ({
       schedule: [dart.void, [_EventDispatch]],
@@ skipping 1664 matching lines @@
         return _rootRunBinary(null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
-        return dart.fn((() => this.runGuarded(f)).bind(this));
+        return dart.fn(() => this.runGuarded(f));
       } else {
-        return dart.fn((() => this.run(f)).bind(this));
+        return dart.fn(() => this.run(f));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
-        return dart.fn((arg => this.runUnaryGuarded(f, arg)).bind(this));
+        return dart.fn(arg => this.runUnaryGuarded(f, arg));
       } else {
-        return dart.fn((arg => this.runUnary(f, arg)).bind(this));
+        return dart.fn(arg => this.runUnary(f, arg));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
-        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this));
+        return dart.fn((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2));
       } else {
-        return dart.fn(((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this));
+        return dart.fn((arg1, arg2) => this.runBinary(f, arg1, arg2));
       }
     }
     get(key) {
       return null;
     }
     handleUncaughtError(error, stackTrace) {
       return _rootHandleUncaughtError(null, null, this, error, stackTrace);
     }
     fork(opts) {
       let specification = opts && 'specification' in opts ? opts.specification : null;
@@ skipping 233 matching lines @@
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerCallback(f);
       if (runGuarded) {
-        return dart.fn((() => this.runGuarded(registered)).bind(this));
+        return dart.fn(() => this.runGuarded(registered));
       } else {
-        return dart.fn((() => this.run(registered)).bind(this));
+        return dart.fn(() => this.run(registered));
       }
     }
     bindUnaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerUnaryCallback(f);
       if (runGuarded) {
-        return dart.fn((arg => this.runUnaryGuarded(registered, arg)).bind(this));
+        return dart.fn(arg => this.runUnaryGuarded(registered, arg));
       } else {
-        return dart.fn((arg => this.runUnary(registered, arg)).bind(this));
+        return dart.fn(arg => this.runUnary(registered, arg));
       }
     }
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerBinaryCallback(f);
       if (runGuarded) {
-        return dart.fn(((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this));
+        return dart.fn((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2));
       } else {
-        return dart.fn(((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this));
+        return dart.fn((arg1, arg2) => this.runBinary(registered, arg1, arg2));
       }
     }
     get(key) {
       let result = this[_map].get(key);
       if (dart.notNull(result != null) || dart.notNull(this[_map].containsKey(key)))
         return result;
       if (this.parent != null) {
         let value = this.parent.get(key);
         if (value != null) {
           this[_map].set(key, value);
@@ skipping 352 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, core, _internal, _js_helper, _isolate_helper, collection);