fixes #177, FunctionDeclarationStatement and closing over `this`

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: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
@@ skipping 75 matching lines @@
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
           computation = i => null;
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
-        function sendEvent() {
+        let sendEvent = () => {
           watch.reset();
           let data = computation((() => {
             let x = computationCount;
             computationCount = dart.notNull(x) + 1;
             return x;
           })());
           controller.add(data);
-        }
+        };
         // Function startPeriodicTimer: () → void
-        function startPeriodicTimer() {
+        let startPeriodicTimer = () => {
           dart.assert(timer == null);
           timer = new Timer.periodic(period, timer => {
             sendEvent();
           });
-        }
+        };
         controller = new (StreamController$(T))({
           sync: true,
           onListen: () => {
             watch.start();
             startPeriodicTimer();
           },
           onPause: () => {
             timer.cancel();
             timer = null;
             watch.stop();
@@ skipping 35 matching lines @@
       }
       map(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
-        function onListen() {
+        let onListen = (() => {
           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 => {
             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);
             }
           }, {onError: dart.as(addError, core.Function), onDone: controller.close.bind(controller)});
-        }
+        }).bind(this);
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({
             onListen: onListen,
             onCancel: () => {
               subscription.cancel();
             },
             sync: true
           });
         } else {
           controller = new StreamController({
@@ skipping 10 matching lines @@
             sync: true
           });
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         dart.as(convert, dart.functionType(Stream, [T]));
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
-        function onListen() {
+        let onListen = (() => {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           subscription = this.listen(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'));
             }
           }, {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close.bind(controller)});
-        }
+        }).bind(this);
         if (this.isBroadcast) {
           controller = new StreamController.broadcast({
             onListen: onListen,
             onCancel: () => {
               subscription.cancel();
             },
             sync: true
           });
         } else {
           controller = new StreamController({
@@ skipping 501 matching lines @@
       }
       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;
         // Function onData: (T) → void
-        function onData(event) {
+        let onData = event => {
           dart.as(event, T);
           timer.cancel();
           controller.add(event);
           timer = zone.createTimer(timeLimit, dart.as(timeout, __CastType17));
-        }
+        };
         // Function onError: (dynamic, StackTrace) → void
-        function onError(error, stackTrace) {
+        let onError = (error, stackTrace) => {
           timer.cancel();
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = controller;
           dart.dcall(eventSink[_addError], error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
-        }
+        };
         // Function onDone: () → void
-        function onDone() {
+        let onDone = () => {
           timer.cancel();
           controller.close();
-        }
+        };
         // Function onListen: () → void
-        function onListen() {
+        let onListen = (() => {
           zone = Zone.current;
           if (onTimeout == null) {
             timeout = () => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
             };
           } else {
             onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), __CastType18);
             let wrapper = new _ControllerEventSinkWrapper(null);
             timeout = () => {
               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);
         // Function onCancel: () → Future<dynamic>
-        function onCancel() {
+        let onCancel = () => {
           timer.cancel();
           let result = subscription.cancel();
           subscription = null;
           return result;
-        }
+        };
         controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, () => {
           timer.cancel();
           subscription.pause();
         }, () => {
           subscription.resume();
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }, onCancel);
         return controller.stream;
       }
     }
@@ skipping 327 matching lines @@
         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];
         // Function sendError: () → void
-        function 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);
         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]));
         // Function sendDone: () → void
-        function 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);
         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) {
         dart.assert(!dart.notNull(this[_inCallback]));
@@ skipping 622 matching lines @@
       static wait(futures, opts) {
         let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
         let cleanUp = opts && 'cleanUp' in opts ? opts.cleanUp : null;
         dart.as(cleanUp, dart.functionType(dart.void, [dart.dynamic]));
         let result = new (_Future$(core.List))();
         let values = null;
         let remaining = 0;
         let error = null;
         let stackTrace = null;
         // Function handleError: (dynamic, dynamic) → void
-        function handleError(theError, theStackTrace) {
+        let handleError = (theError, theStackTrace) => {
           remaining = dart.notNull(remaining) - 1;
           if (values != null) {
             if (cleanUp != null) {
               for (let value of values) {
                 if (value != null) {
                   new Future.sync(() => {
                     dart.dcall(cleanUp, value);
                   });
                 }
               }
             }
             values = null;
             if (remaining == 0 || dart.notNull(eagerError)) {
               result[_completeError](theError, dart.as(theStackTrace, core.StackTrace));
             } 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 = remaining;
           remaining = dart.notNull(pos) + 1;
           future.then(value => {
             remaining = dart.notNull(remaining) - 1;
             if (values != null) {
               values[core.$set](pos, value);
               if (remaining == 0) {
                 result[_completeWithValue](values);
               }
@@ skipping 508 matching lines @@
             if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErrorZone(zone))) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
               return;
             }
             let oldZone = null;
             if (!dart.notNull(core.identical(Zone.current, zone))) {
               oldZone = Zone._enter(zone);
             }
             // Function handleValueCallback: () → bool
-            function handleValueCallback() {
+            let handleValueCallback = () => {
               try {
                 listenerValueOrError = zone.runUnary(listener[_onValue], sourceValue);
                 return true;
               } catch (e) {
                 let s = dart.stackTrace(e);
                 listenerValueOrError = new AsyncError(e, s);
                 return false;
               }
 
-            }
+            };
             // Function handleError: () → void
-            function handleError() {
+            let handleError = () => {
               let asyncError = source[_error];
               let matchesTest = true;
               if (listener.hasErrorTest) {
                 let test = listener[_errorTest];
                 try {
                   matchesTest = dart.as(zone.runUnary(test, asyncError.error), core.bool);
                 } catch (e) {
                   let s = dart.stackTrace(e);
                   listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
@@ skipping 14 matching lines @@
                   listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
                   listenerHasValue = false;
                   return;
                 }
 
                 listenerHasValue = true;
               } else {
                 listenerValueOrError = asyncError;
                 listenerHasValue = false;
               }
-            }
+            };
             // Function handleWhenCompleteCallback: () → void
-            function handleWhenCompleteCallback() {
+            let handleWhenCompleteCallback = () => {
               let completeResult = null;
               try {
                 completeResult = zone.run(listener[_whenCompleteAction]);
               } catch (e) {
                 let s = dart.stackTrace(e);
                 if (dart.notNull(hasError) && dart.notNull(core.identical(source[_error].error, e))) {
                   listenerValueOrError = source[_error];
                 } else {
                   listenerValueOrError = new AsyncError(e, s);
                 }
@@ skipping 12 matching lines @@
                     if (stackTrace === void 0)
                       stackTrace = null;
                     if (!dart.is(completeResult, _Future)) {
                       completeResult = new _Future();
                       dart.dsend(completeResult, _setError, error, stackTrace);
                     }
                     _Future._propagateToListeners(dart.as(completeResult, _Future), new _FutureListener.chain(result));
                   }
                 });
               }
-            }
+            };
             if (!dart.notNull(hasError)) {
               if (listener.handlesValue) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
             if (listener.handlesComplete) {
               handleWhenCompleteCallback();
             }
@@ skipping 169 matching lines @@
     static _initializeScheduleImmediate() {
       _js_helper.requiresPreamble();
       if (self.scheduleImmediate != null) {
         return _AsyncRun._scheduleImmediateJsOverride;
       }
       if (dart.notNull(self.MutationObserver != null) && dart.notNull(self.document != null)) {
         let div = self.document.createElement("div");
         let span = self.document.createElement("span");
         let storedCallback = null;
         // Function internalCallback: (dynamic) → dynamic
-        function internalCallback(_) {
+        let internalCallback = _ => {
           _isolate_helper.leaveJsAsync();
           let f = storedCallback;
           storedCallback = null;
           dart.dcall(f);
-        }
+        };
         ;
         let observer = new self.MutationObserver(_js_helper.convertDartClosureToJS(internalCallback, 1));
         observer.observe(div, {childList: true});
         return callback => {
           dart.assert(storedCallback == null);
           _isolate_helper.enterJsAsync();
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
         };
       } else if (self.setImmediate != null) {
         return _AsyncRun._scheduleImmediateWithSetImmediate;
       }
       return _AsyncRun._scheduleImmediateWithTimer;
     }
     static _scheduleImmediateJsOverride(callback) {
       // Function internalCallback: () → dynamic
-      function internalCallback() {
+      let internalCallback = () => {
         _isolate_helper.leaveJsAsync();
         callback();
-      }
+      };
       ;
       _isolate_helper.enterJsAsync();
       self.scheduleImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
     static _scheduleImmediateWithSetImmediate(callback) {
       // Function internalCallback: () → dynamic
-      function internalCallback() {
+      let internalCallback = () => {
         _isolate_helper.leaveJsAsync();
         callback();
-      }
+      };
       ;
       _isolate_helper.enterJsAsync();
       self.setImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
     static _scheduleImmediateWithTimer(callback) {
       Timer._createTimer(core.Duration.ZERO, callback);
     }
   }
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
@@ skipping 333 matching lines @@
               let s = dart.stackTrace(e);
               result = new _Future();
               result[_asyncCompleteError](e, s);
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
         // Function complete: () → void
-        function complete() {
+        let complete = (() => {
           if (dart.notNull(this[_doneFuture] != null) && dart.notNull(this[_doneFuture][_mayComplete])) {
             this[_doneFuture][_asyncComplete](null);
           }
-        }
+        }).bind(this);
         if (result != null) {
           result = result.whenComplete(complete);
         } else {
           complete();
         }
         return result;
       }
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         if (this[_isAddingStream]) {
@@ skipping 2301 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);