move => bind this workaround to js_ast

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.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
@@ skipping 43 matching lines @@
   let _addError = Symbol('_addError');
   let _completeError = Symbol('_completeError');
   let _complete = Symbol('_complete');
   let _sink = Symbol('_sink');
   let Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       fromFuture(future) {
         let controller = new (StreamController$(T))({sync: true});
-        future.then(dart.closureWrap(((value) => {
+        future.then(dart.closureWrap((value) => {
           controller._add(dart.as(value, T));
           controller._closeUnchecked();
-        }).bind(this), "(T) → dynamic"), {onError: ((error, stackTrace) => {
+        }, "(T) → dynamic"), {
+          onError: (error, stackTrace) => {
             controller._addError(error, dart.as(stackTrace, core.StackTrace));
             controller._closeUnchecked();
-          }).bind(this)});
+          }
+        });
         return controller.stream;
       }
       fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(() => new (_IterablePendingEvents$(T))(data));
       }
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
           computation = dart.closureWrap((i) => null, "(int) → T");
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
         function sendEvent() {
           watch.reset();
           let data = computation(((x) => computationCount = dart.notNull(x) + 1, x)(computationCount));
           controller.add(data);
         }
         // Function startPeriodicTimer: () → void
         function startPeriodicTimer() {
           dart.assert(timer == null);
           timer = new Timer.periodic(period, (timer) => {
             sendEvent();
           });
         }
-        controller = new (StreamController$(T))({sync: true, onListen: (() => {
+        controller = new (StreamController$(T))({
+          sync: true,
+          onListen: () => {
             watch.start();
             startPeriodicTimer();
-          }).bind(this), onPause: (() => {
+          },
+          onPause: () => {
             timer.cancel();
             timer = null;
             watch.stop();
-          }).bind(this), onResume: (() => {
+          },
+          onResume: () => {
             dart.assert(timer == null);
             let elapsed = watch.elapsed;
             watch.start();
             timer = new Timer(period['-'](elapsed), () => {
               timer = null;
               startPeriodicTimer();
               sendEvent();
             });
-          }).bind(this), onCancel: (() => {
+          },
+          onCancel: () => {
             if (timer != null)
               timer.cancel();
             timer = null;
-          }).bind(this)});
+          }
+        });
         return controller.stream;
       }
       eventTransformed(source, mapSink) {
         return dart.as(new _BoundSinkStream(source, dart.closureWrap(mapSink, "(EventSink<dynamic>) → EventSink")), Stream$(T));
       }
       get isBroadcast() {
         return false;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         return new (_AsBroadcastStream$(T))(this, dart.closureWrap(onListen, "(StreamSubscription<dynamic>) → void"), dart.closureWrap(onCancel, "(StreamSubscription<dynamic>) → void"));
       }
       where(test) {
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         return new (_MapStream$(T, dynamic))(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
           let add = controller.add;
           dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
           let eventSink = controller;
           let addError = eventSink[_addError];
-          subscription = this.listen(((event) => {
+          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.dinvoke(dart.dinvoke(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
             } else {
               controller.add(newValue);
             }
-          }).bind(this), {onError: dart.as(addError, core.Function), onDone: controller.close});
+          }, {onError: dart.as(addError, core.Function), onDone: controller.close});
         }
         if (this.isBroadcast) {
-          controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
+          controller = new StreamController.broadcast({
+            onListen: onListen,
+            onCancel: () => {
               subscription.cancel();
-            }).bind(this), sync: true});
+            },
+            sync: true
+          });
         } else {
-          controller = new StreamController({onListen: onListen, onPause: (() => {
+          controller = new StreamController({
+            onListen: onListen,
+            onPause: () => {
               subscription.pause();
-            }).bind(this), onResume: (() => {
+            },
+            onResume: () => {
               subscription.resume();
-            }).bind(this), onCancel: (() => {
+            },
+            onCancel: () => {
               subscription.cancel();
-            }).bind(this), sync: true});
+            },
+            sync: true
+          });
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
           dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
           let eventSink = controller;
-          subscription = this.listen(((event) => {
+          subscription = this.listen((event) => {
             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(subscription.resume);
             }
-          }).bind(this), {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close});
+          }, {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close});
         }
         if (this.isBroadcast) {
-          controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
+          controller = new StreamController.broadcast({
+            onListen: onListen,
+            onCancel: () => {
               subscription.cancel();
-            }).bind(this), sync: true});
+            },
+            sync: true
+          });
         } else {
-          controller = new StreamController({onListen: onListen, onPause: (() => {
+          controller = new StreamController({
+            onListen: onListen,
+            onPause: () => {
               subscription.pause();
-            }).bind(this), onResume: (() => {
+            },
+            onResume: () => {
               subscription.resume();
-            }).bind(this), onCancel: (() => {
+            },
+            onCancel: () => {
               subscription.cancel();
-            }).bind(this), sync: true});
+            },
+            sync: true
+          });
         }
         return controller.stream;
       }
       handleError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
         return new (_HandleErrorStream$(T))(this, onError, test);
       }
       expand(convert) {
         return new (_ExpandStream$(T, dynamic))(this, convert);
       }
       pipe(streamConsumer) {
-        return streamConsumer.addStream(this).then(((_) => streamConsumer.close()).bind(this));
+        return streamConsumer.addStream(this).then((_) => streamConsumer.close());
       }
       transform(streamTransformer) {
         return streamTransformer.bind(this);
       }
       reduce(combine) {
         let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
         subscription = this.listen((element) => {
           if (seenFirst) {
             _runUserCode(() => combine(value, element), (newValue) => {
               value = newValue;
             }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
           } else {
             value = element;
             seenFirst = true;
           }
-        }, {onError: result[_completeError], onDone: (() => {
+        }, {
+          onError: result[_completeError],
+          onDone: () => {
             if (!dart.notNull(seenFirst)) {
               try {
                 throw _internal.IterableElementError.noElement();
               } catch (e) {
                 let s = dart.stackTrace(e);
                 _completeWithErrorCallback(result, e, s);
               }
 
             } else {
               result._complete(value);
             }
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return result;
       }
       fold(initialValue, combine) {
         let result = new _Future();
         let value = initialValue;
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => dart.dinvokef(combine, value, element), (newValue) => {
             value = newValue;
           }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: ((e, st) => {
+        }, {
+          onError: (e, st) => {
             result._completeError(e, dart.as(st, core.StackTrace));
-          }).bind(this), onDone: (() => {
+          },
+          onDone: () => {
             result._complete(value);
-          }).bind(this), cancelOnError: true});
+          },
+          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(((element) => {
+        subscription = this.listen((element) => {
           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);
           }
 
-        }).bind(this), {onError: ((e) => {
+        }, {
+          onError: (e) => {
             result._completeError(e);
-          }).bind(this), onDone: (() => {
+          },
+          onDone: () => {
             result._complete(buffer.toString());
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return result;
       }
       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.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(false);
-          }).bind(this), cancelOnError: true});
+          },
+          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.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(null);
-          }).bind(this), cancelOnError: true});
+          },
+          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.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(true);
-          }).bind(this), cancelOnError: 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.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(false);
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
         this.listen(dart.closureWrap((_) => {
           count = dart.notNull(count) + 1;
-        }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
+        }, "(T) → void"), {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(count);
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.closureWrap((_) => {
           _cancelAndValue(subscription, future, false);
-        }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
+        }, "(T) → void"), {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(true);
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       toList() {
         let result = new core.List$(T).from([]);
         let future = new (_Future$(core.List$(T)))();
-        this.listen(((data) => {
+        this.listen((data) => {
           result.add(data);
-        }).bind(this), {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(result);
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       toSet() {
         let result = new (core.Set$(T))();
         let future = new (_Future$(core.Set$(T)))();
-        this.listen(((data) => {
+        this.listen((data) => {
           result.add(data);
-        }).bind(this), {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             future._complete(result);
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
       }
       take(count) {
         return dart.as(new _TakeStream(this, count), Stream$(T));
       }
@@ skipping 32 matching lines @@
         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], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       get single() {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           if (foundResult) {
             try {
               throw _internal.IterableElementError.tooMany();
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
             }
 
             return;
           }
           foundResult = true;
           result = value;
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }).bind(this), cancelOnError: true});
+          },
+          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.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete], future[_completeError]);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }).bind(this), cancelOnError: true});
+          },
+          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.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             if (defaultValue != null) {
               _runUserCode(defaultValue, future[_complete], future[_completeError]);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       singleWhere(test) {
         let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => true == test(value), (isMatch) => {
             if (isMatch) {
               if (foundResult) {
                 try {
                   throw _internal.IterableElementError.tooMany();
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   _cancelAndErrorWithReplacement(subscription, future, e, s);
                 }
 
                 return;
               }
               foundResult = true;
               result = value;
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
-          }).bind(this), cancelOnError: true});
+          },
+          cancelOnError: true
+        });
         return future;
       }
       elementAt(index) {
         if (dart.notNull(!(typeof index == 'number')) || dart.notNull(index) < 0)
           throw new core.ArgumentError(index);
         let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen((value) => {
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = 1;
-        }, {onError: future[_completeError], onDone: (() => {
+        }, {
+          onError: future[_completeError],
+          onDone: (() => {
             future._completeError(new core.RangeError.index(index, this, "index", null, elementIndex));
-          }).bind(this), cancelOnError: true});
+          }).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
@@ skipping 12 matching lines @@
         }
         // Function onDone: () → void
         function onDone() {
           timer.cancel();
           controller.close();
         }
         // Function onListen: () → void
         function onListen() {
           zone = Zone.current;
           if (onTimeout == null) {
-            timeout = (() => {
+            timeout = () => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
-            }).bind(this);
+            };
           } else {
             onTimeout = dart.closureWrap(zone.registerUnaryCallback(onTimeout), "(EventSink<dynamic>) → void");
             let wrapper = new _ControllerEventSinkWrapper(null);
-            timeout = (() => {
+            timeout = () => {
               wrapper[_sink] = controller;
               zone.runUnaryGuarded(onTimeout, wrapper);
               wrapper[_sink] = null;
-            }).bind(this);
+            };
           }
           subscription = this.listen(onData, {onError: onError, onDone: onDone});
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
         }
         // Function onCancel: () → Future<dynamic>
         function onCancel() {
           timer.cancel();
           let result = subscription.cancel();
           subscription = null;
           return result;
         }
-        controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, (() => {
+        controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, () => {
           timer.cancel();
           subscription.pause();
-        }).bind(this), (() => {
+        }, () => {
           subscription.resume();
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
-        }).bind(this), onCancel);
+        }, onCancel);
         return controller.stream;
       }
     }
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     return Stream;
   });
   let Stream = Stream$(dart.dynamic);
@@ skipping 191 matching lines @@
         this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL]);
         if (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] = (() => {
+        this[_onDone] = () => {
           result._complete(futureValue);
-        }).bind(this);
+        };
         this[_onError] = ((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 494 matching lines @@
         if (this[_hasOneListener]) {
           this[_state] = _BroadcastStreamController[_STATE_FIRING];
           let subscription = dart.as(this[_next], _BroadcastSubscription);
           subscription._add(data);
           this[_state] = ~dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
           if (this[_isEmpty]) {
             this[_callOnCancel]();
           }
           return;
         }
-        this[_forEachListener](((subscription) => {
+        this[_forEachListener]((subscription) => {
           subscription._add(data);
-        }).bind(this));
+        });
       }
       [_sendError](error, stackTrace) {
         if (this[_isEmpty])
           return;
-        this[_forEachListener](((subscription) => {
+        this[_forEachListener]((subscription) => {
           subscription._addError(error, stackTrace);
-        }).bind(this));
+        });
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          this[_forEachListener](dart.closureWrap(((subscription) => {
+          this[_forEachListener](dart.closureWrap((subscription) => {
             subscription._close();
-          }).bind(this), "(_BufferingStreamSubscription<T>) → void"));
+          }, "(_BufferingStreamSubscription<T>) → void"));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture]._asyncComplete(null);
         }
       }
     }
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$(dart.dynamic);
@@ skipping 149 matching lines @@
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new (_Future$(T))();
-        Timer.run((() => {
+        Timer.run(() => {
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        }).bind(this));
+        });
         return dart.as(result, Future$(T));
       }
       microtask(computation) {
         let result = new (_Future$(T))();
-        scheduleMicrotask((() => {
+        scheduleMicrotask(() => {
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        }).bind(this));
+        });
         return dart.as(result, Future$(T));
       }
       sync(computation) {
         try {
           let result = computation();
           return new Future$(T).value(result);
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
           return new Future$(T).error(error, stackTrace);
         }
@@ skipping 14 matching lines @@
             error = _nonNullError(replacement.error);
             stackTrace = replacement.stackTrace;
           }
         }
         return new _Future$(T).immediateError(error, stackTrace);
       }
       delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
         let result = new (_Future$(T))();
-        new Timer(duration, (() => {
+        new Timer(duration, () => {
           try {
             result._complete(computation == null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
-        }).bind(this));
+        });
         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;
         let result = new (_Future$(core.List))();
         let values = null;
         let remaining = 0;
         let error = null;
         let stackTrace = null;
@@ skipping 16 matching lines @@
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining == 0 && !dart.notNull(eagerError)) {
             result._completeError(error, stackTrace);
           }
         }
         for (let future of futures) {
           let pos = ((x) => remaining = dart.notNull(x) + 1, x)(remaining);
-          future.then(((value) => {
+          future.then((value) => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values.set(pos, value);
               if (remaining == 0) {
                 result._completeWithValue(values);
               }
             } else {
               if (dart.notNull(cleanUp != null) && dart.notNull(value != null)) {
                 new Future.sync(() => {
                   dart.dinvokef(cleanUp, value);
                 });
               }
               if (remaining == 0 && !dart.notNull(eagerError)) {
                 result._completeError(error, stackTrace);
               }
             }
-          }).bind(this), {onError: handleError});
+          }, {onError: handleError});
         }
         if (remaining == 0) {
           return dart.as(new Future.value(/* Unimplemented const */new core.List.from([])), Future$(core.List));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         let iterator = input.iterator;
-        return Future.doWhile((() => {
+        return Future.doWhile(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
-          return new Future.sync((() => dart.dinvokef(f, iterator.current)).bind(this)).then((_) => true);
-        }).bind(this));
+          return new Future.sync(() => dart.dinvokef(f, iterator.current)).then((_) => true);
+        });
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
-        nextIteration = Zone.current.bindUnaryCallback(((keepGoing) => {
+        nextIteration = Zone.current.bindUnaryCallback((keepGoing) => {
           if (keepGoing) {
             new Future.sync(f).then(dart.as(nextIteration, dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: doneSignal[_completeError]});
           } else {
             doneSignal._complete(null);
           }
-        }).bind(this), {runGuarded: true});
+        }, {runGuarded: true});
         dart.dinvokef(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.defineLazyProperties(Future, {
@@ skipping 332 matching lines @@
           current[_nextListener] = prev;
           prev = current;
           current = next;
         }
         return prev;
       }
       static [_chainForeignFuture](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(!dart.is(source, _Future));
         target[_isChained] = true;
-        source.then(((value) => {
+        source.then((value) => {
           dart.assert(target[_isChained]);
           target._completeWithValue(value);
-        }).bind(this), {onError: ((error, stackTrace) => {
+        }, {
+          onError: (error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
             target._completeError(error, dart.as(stackTrace, core.StackTrace));
-          }).bind(this)});
+          }
+        });
       }
       static [_chainCoreFuture](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(dart.is(source, _Future));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
         if (source[_isComplete]) {
           _Future[_propagateToListeners](source, listener);
         } else {
           source._addListener(listener);
@@ skipping 222 matching lines @@
           source = result;
         }
       }
       timeout(timeLimit, opts) {
         let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         if (this[_isComplete])
           return new _Future.immediate(this);
         let result = new _Future();
         let timer = null;
         if (onTimeout == null) {
-          timer = new Timer(timeLimit, (() => {
+          timer = new Timer(timeLimit, () => {
             result._completeError(new TimeoutException("Future not completed", timeLimit));
-          }).bind(this));
+          });
         } else {
           let zone = Zone.current;
           onTimeout = zone.registerCallback(onTimeout);
-          timer = new Timer(timeLimit, (() => {
+          timer = new Timer(timeLimit, () => {
             try {
               result._complete(zone.run(onTimeout));
             } catch (e) {
               let s = dart.stackTrace(e);
               result._completeError(e, s);
             }
 
-          }).bind(this));
+          });
         }
-        this.then(((v) => {
+        this.then((v) => {
           if (timer.isActive) {
             timer.cancel();
             result._completeWithValue(v);
           }
-        }).bind(this), {onError: ((e, s) => {
+        }, {
+          onError: (e, s) => {
             if (timer.isActive) {
               timer.cancel();
               result._completeError(e, dart.as(s, core.StackTrace));
             }
-          }).bind(this)});
+          }
+        });
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
     _Future._INCOMPLETE = 0;
     _Future._PENDING_COMPLETE = 1;
     _Future._CHAINED = 2;
     _Future._VALUE = 4;
@@ skipping 456 matching lines @@
         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 = ((_$) => {
                 _$._asyncCompleteError(e, s);
                 return _$;
-              }).bind(this)(new _Future());
+              })(new _Future());
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
         // Function complete: () → void
         function complete() {
           if (dart.notNull(this[_doneFuture] != null) && dart.notNull(this[_doneFuture][_mayComplete])) {
             this[_doneFuture]._asyncComplete(null);
@@ skipping 151 matching lines @@
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
   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});
       }
       static makeErrorHandler(controller) {
-        return ((e, s) => {
+        return (e, s) => {
           controller._addError(e, s);
           controller._close();
-        }).bind(this);
+        };
       }
       pause() {
         this.addSubscription.pause();
       }
       resume() {
         this.addSubscription.resume();
       }
       cancel() {
         let cancel = this.addSubscription.cancel();
         if (cancel == null) {
@@ skipping 290 matching lines @@
           }
         }
       }
       cancel() {
         return null;
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
-        this[_onDone] = (() => {
+        this[_onDone] = () => {
           result._completeWithValue(null);
-        }).bind(this);
+        };
         return result;
       }
       [_sendDone]() {
         this[_state] = ~dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
         if (this.isPaused)
           return;
         this[_state] = _DoneStreamSubscription[_DONE_SENT];
         if (this[_onDone] != null)
           this[_zone].runGuarded(this[_onDone]);
       }
@@ skipping 1688 matching lines @@
   exports.StreamIterator = StreamIterator;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));