fix #43, remove => workaround

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 624 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 = elementIndex + 1;
-        }, dart.void, [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), dart.void, []), cancelOnError: true});
+          }, 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 291 matching lines @@
         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[_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 1305 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 (dart.notNull(this[_isComplete])) {
-          this[_zone].scheduleMicrotask(dart.fn((() => {
+          this[_zone].scheduleMicrotask(dart.fn(() => {
             _Future$()._propagateToListeners(this, listener);
-          }).bind(this), dart.void, []));
+          }, 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 59 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), dart.void, []));
+              }, 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[_zone].scheduleMicrotask(dart.fn(() => {
           this[_completeWithValue](value);
-        }).bind(this), dart.void, []));
+        }, dart.void, []));
       }
       [_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), dart.void, []));
+        }, 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 706 matching lines @@
         let pendingEvents = this[_pendingEvents];
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_SUBSCRIBED);
         if (dart.notNull(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 (dart.notNull(this[_isAddingStream])) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           result = addState.cancel();
         }
         this[_varData] = null;
@@ skipping 254 matching lines @@
       }
       resume() {
         this.addSubscription.resume();
       }
       cancel() {
         let cancel2 = this.addSubscription.cancel();
         if (cancel2 == null) {
           this.addStreamFuture[_asyncComplete](null);
           return null;
         }
-        return cancel2.whenComplete(dart.fn((() => {
+        return cancel2.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 69 matching lines @@
       return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SCHEDULED);
     }
     schedule(dispatch) {
       if (dart.notNull(this.isScheduled)) return;
       dart.assert(!dart.notNull(this.isEmpty));
       if (dart.notNull(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), dart.void, []));
+      }, 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 1714 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 (dart.notNull(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 (dart.notNull(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 (dart.notNull(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 (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 342 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 (dart.notNull(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 (dart.notNull(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 (dart.notNull(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 169 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;
 });