Dart2js async-await. Bind the async-body to the current zone.

sdk/lib/_internal/compiler/js_lib/js_helper.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library _js_helper;
 
 import 'dart:_async_await_error_codes' as async_error_codes;
 
 import 'dart:_js_embedded_names' show
     DEFERRED_LIBRARY_URIS,
@@ skipping 18 matching lines @@
     isWorker,
     leaveJsAsync;
 
 import 'dart:async' show
     Completer,
     DeferredLoadException,
     Future,
     StreamController,
     Stream,
     StreamSubscription,
-    scheduleMicrotask;
+    scheduleMicrotask,
+    Zone;
 
 import 'dart:_foreign_helper' show
     DART_CLOSURE_TO_JS,
     JS,
     JS_BUILTIN,
     JS_CALL_IN_ISOLATE,
     JS_CONST,
     JS_CURRENT_ISOLATE,
     JS_CURRENT_ISOLATE_CONTEXT,
     JS_EFFECT,
@@ skipping 3683 matching lines @@
 /// If [asyncBody] is [async_error_codes.SUCCESS]/[async_error_codes.ERROR] it
 /// indicates a return or throw from the async function, and
 /// complete/completeError is called on [completer] with [object].
 ///
 /// Otherwise [asyncBody] is set up to be called when the future is completed
 /// with a code [async_error_codes.SUCCESS]/[async_error_codes.ERROR] depending
 /// on the success of the future.
 ///
 /// Returns the future of the completer for convenience of the first call.
 dynamic asyncHelper(dynamic object,
-                    dynamic /* js function */ bodyFunctionOrErrorCode,
-                    Completer completer) {
+    dynamic /* int | WrappedAsyncBody */ bodyFunctionOrErrorCode,
+    Completer completer) {
   if (identical(bodyFunctionOrErrorCode, async_error_codes.SUCCESS)) {
     completer.complete(object);
     return;
   } else if (identical(bodyFunctionOrErrorCode, async_error_codes.ERROR)) {
     // The error is a js-error.
     completer.completeError(unwrapException(object),
                             getTraceFromException(object));
     return;
   }
   Future future = object is Future ? object : new Future.value(object);
-  future.then(_wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-                                      async_error_codes.SUCCESS),
+  future.then(
+      (result) => bodyFunctionOrErrorCode(async_error_codes.SUCCESS, result),
       onError: (dynamic error, StackTrace stackTrace) {
         ExceptionAndStackTrace wrappedException =
             new ExceptionAndStackTrace(error, stackTrace);
-        Function wrapped =_wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-            async_error_codes.ERROR);
-        wrapped(wrappedException);
+        bodyFunctionOrErrorCode(async_error_codes.ERROR, wrappedException);
       });
   return completer.future;
 }
 
-Function _wrapJsFunctionForAsync(dynamic /* js function */ function,
-                                 int errorCode) {
+typedef void WrappedAsyncBody(int errorCode, dynamic result);
+
+WrappedAsyncBody _wrapJsFunctionForAsync(dynamic /* js function */ function) {
   var protected = JS('', """
     // Invokes [function] with [errorCode] and [result].
     //
     // If (and as long as) the invocation throws, calls [function] again,
     // with an error-code.
     function(errorCode, result) {
       while (true) {
         try {
           #(errorCode, result);
           break;
         } catch (error) {
           result = error;
           errorCode = #;
         }
       }
     }""", function, async_error_codes.ERROR);
-  return (result) {
+  return Zone.current.bindBinaryCallback((int errorCode, dynamic result) {
     JS('', '#(#, #)', protected, errorCode, result);
-  };
+  });
 }
 
 /// Implements the runtime support for async* functions.
 ///
 /// Called by the transformed function for each original return, await, yield,
 /// yield* and before starting the function.
 ///
 /// When the async* function wants to return it calls this function with
 /// [asyncBody] == [async_error_codes.SUCCESS], the asyncStarHelper takes this
 /// as signal to close the stream.
@@ skipping 19 matching lines @@
 /// yielded stream, and adds all events and errors to our own controller (taking
 /// care if the subscription has been paused or canceled) - when the sub-stream
 /// is done, schedules [asyncBody] again.
 ///
 /// If the async* function wants to do an await it calls this function with
 /// [object] not and [IterationMarker].
 ///
 /// If [object] is not a [Future], it is wrapped in a `Future.value`.
 /// The [asyncBody] is called on completion of the future (see [asyncHelper].
 void asyncStarHelper(dynamic object,
-                     dynamic /* int | js function */ bodyFunctionOrErrorCode,
-                     AsyncStarStreamController controller) {
+    dynamic /* int | WrappedAsyncBody */ bodyFunctionOrErrorCode,
+    AsyncStarStreamController controller) {
   if (identical(bodyFunctionOrErrorCode, async_error_codes.SUCCESS)) {
     // This happens on return from the async* function.
     if (controller.isCanceled) {
       controller.cancelationCompleter.complete();
     } else {
       controller.close();
     }
     return;
   } else if (identical(bodyFunctionOrErrorCode, async_error_codes.ERROR)) {
     // The error is a js-error.
     if (controller.isCanceled) {
       controller.cancelationCompleter.completeError(
           unwrapException(object),
           getTraceFromException(object));
     } else {
       controller.addError(unwrapException(object),
                           getTraceFromException(object));
       controller.close();
     }
     return;
   }
 
   if (object is IterationMarker) {
     if (controller.isCanceled) {
-      Function wrapped = _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-          async_error_codes.STREAM_WAS_CANCELED);
-      wrapped(null);
+      bodyFunctionOrErrorCode(async_error_codes.STREAM_WAS_CANCELED, null);
       return;
     }
     if (object.state == IterationMarker.YIELD_SINGLE) {
       controller.add(object.value);
 
       scheduleMicrotask(() {
         if (controller.isPaused) {
           // We only suspend the thread inside the microtask in order to allow
           // listeners on the output stream to pause in response to the just
           // output value, and have the stream immediately stop producing.
           controller.isSuspended = true;
           return;
         }
-        Function wrapped = _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-            async_error_codes.SUCCESS);
-        wrapped(null);
+        bodyFunctionOrErrorCode(null, async_error_codes.SUCCESS);
       });
       return;
     } else if (object.state == IterationMarker.YIELD_STAR) {
       Stream stream = object.value;
       // Errors of [stream] are passed though to the main stream. (see
       // [AsyncStreamController.addStream]).
       // TODO(sigurdm): The spec is not very clear here. Clarify with Gilad.
       controller.addStream(stream).then((_) {
         // No check for isPaused here because the spec 17.16.2 only
         // demands checks *before* each element in [stream] not after the last
         // one. On the other hand we check for isCanceled, as that check happens
         // after insertion of each element.
         int errorCode = controller.isCanceled
             ? async_error_codes.STREAM_WAS_CANCELED
             : async_error_codes.SUCCESS;
-        Function wrapped = _wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-                                errorCode);
-        wrapped(null);
+        bodyFunctionOrErrorCode(errorCode, null);
       });
       return;
     }
   }
 
   Future future = object is Future ? object : new Future.value(object);
-  future.then(_wrapJsFunctionForAsync(bodyFunctionOrErrorCode,
-                                      async_error_codes.SUCCESS),
-              onError: (error, StackTrace stackTrace) {
-                ExceptionAndStackTrace wrappedException =
-                    new ExceptionAndStackTrace(error, stackTrace);
-                Function wrapped = _wrapJsFunctionForAsync(
-                    bodyFunctionOrErrorCode, async_error_codes.ERROR);
-                return wrapped(wrappedException);
-              });
+  future.then(
+      (result) => bodyFunctionOrErrorCode(async_error_codes.SUCCESS, result),
+      onError: (error, StackTrace stackTrace) {
+        ExceptionAndStackTrace wrappedException =
+            new ExceptionAndStackTrace(error, stackTrace);
+        bodyFunctionOrErrorCode(async_error_codes.ERROR, wrappedException);
+      });
 }
 
 Stream streamOfController(AsyncStarStreamController controller) {
   return controller.stream;
 }
 
 /// A wrapper around a [StreamController] that keeps track of the state of
 /// the execution of an async* function.
 /// It can be in 1 of 3 states:
 ///
@@ skipping 25 matching lines @@
   add(event) => controller.add(event);
 
   addStream(Stream stream) {
     return controller.addStream(stream, cancelOnError: false);
   }
 
   addError(error, stackTrace) => controller.addError(error, stackTrace);
 
   close() => controller.close();
 
-  AsyncStarStreamController(body) {
+  AsyncStarStreamController(WrappedAsyncBody body) {
 
     _resumeBody() {
       scheduleMicrotask(() {
-        Function wrapped =
-            _wrapJsFunctionForAsync(body, async_error_codes.SUCCESS);
-        wrapped(null);
+        body(async_error_codes.SUCCESS, null);
       });
     }
 
     controller = new StreamController(
       onListen: () {
         _resumeBody();
       }, onResume: () {
         // Only schedule again if the async* function actually is suspended.
         // Resume directly instead of scheduling, so that the sequence
         // `pause-resume-pause` will result in one extra event produced.
         if (isSuspended) {
           isSuspended = false;
           _resumeBody();
         }
       }, onCancel: () {
         // If the async* is finished we ignore cancel events.
         if (!controller.isClosed) {
           cancelationCompleter = new Completer();
           if (isSuspended) {
             // Resume the suspended async* function to run finalizers.
             isSuspended = false;
             scheduleMicrotask(() {
-              Function wrapped =_wrapJsFunctionForAsync(body,
-                  async_error_codes.STREAM_WAS_CANCELED);
-              wrapped(null);
+              body(async_error_codes.STREAM_WAS_CANCELED, null);
             });
           }
           return cancelationCompleter.future;
         }
       });
   }
 }
 
 makeAsyncStarController(body) {
   return new AsyncStarStreamController(body);
@@ skipping 97 matching lines @@
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
   // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }