Async/await Promise dependency graph

src/js/harmony-async-await.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 32 matching lines @@
 function PromiseCastResolved(value) {
   if (IsPromise(value)) {
     return value;
   } else {
     var promise = PromiseCreate();
     ResolvePromise(promise, value);
     return promise;
   }
 }
 
-function AsyncFunctionAwait(generator, awaited, mark) {
+function AsyncFunctionAwait(generator, awaited, outerPromise) {
   // Promise.resolve(awaited).then(
   //     value => AsyncFunctionNext(value),
   //     error => AsyncFunctionThrow(error)
   // );
   var promise = PromiseCastResolved(awaited);
 
   var onFulfilled =
       (sentValue) => %_Call(AsyncFunctionNext, generator, sentValue);
   var onRejected =
       (sentError) => %_Call(AsyncFunctionThrow, generator, sentError);
 
-  if (mark && DEBUG_IS_ACTIVE && IsPromise(awaited)) {
-    // Mark the reject handler callback such that it does not influence
-    // catch prediction.
-    SET_PRIVATE(onRejected, promiseAwaitHandlerSymbol, true);
+  if (!IS_UNDEFINED(outerPromise) && DEBUG_IS_ACTIVE && IsPromise(awaited)) {
+    // Mark the reject handler callback to continue recursing to outerPromise
+    SET_PRIVATE(onRejected, promiseAwaitHandlerSymbol, outerPromise);
   }
 
   // Just forwarding the exception, so no debugEvent for throwawayCapability
   var throwawayCapability = NewPromiseCapability(GlobalPromise, false);
-  return PerformPromiseThen(promise, onFulfilled, onRejected,

[adamk, 2016/09/08 22:07:31]

AsyncFunctionAwait used to return something, but now it returns undefined. Was
that intentional?

[Dan Ehrenberg, 2016/09/08 22:34:46]

No one calls this; they call
AsyncFunctionAwaitCaught/AsyncFunctionAwaitUncaught, which return the outer
promise that's passed into them. We used to return the intermediate Promise,
which would end up resolving to the same thing, but the new form is cleaner and
more closely resembles the spec. Whatever the return value bubbles up to the
user because the first "await"'s return value is the actual Promise that the
async function returns.

+  PerformPromiseThen(promise, onFulfilled, onRejected,
                             throwawayCapability);
+
+  if (DEBUG_IS_ACTIVE) {
+    // Mark the dependency to outerPromise in case the throwaway Promise is
+    // found on the Promise stack
+    SET_PRIVATE(throwawayCapability.promise, promiseAwaitHandlerSymbol,
+                outerPromise);
+  }
 }
 
-function AsyncFunctionAwaitUncaught(generator, awaited) {
-  // TODO(littledan): Install a dependency edge from awaited to outerPromise
-  return AsyncFunctionAwait(generator, awaited, true);
+function AsyncFunctionAwaitUncaught(generator, awaited, outerPromise) {
+  AsyncFunctionAwait(generator, awaited, outerPromise);
+  return outerPromise;
 }
 
-function AsyncFunctionAwaitCaught(generator, awaited) {
+function AsyncFunctionAwaitCaught(generator, awaited, outerPromise) {
   if (DEBUG_IS_ACTIVE && IsPromise(awaited)) {
     SET_PRIVATE(awaited, promiseHandledHintSymbol, true);
   }
-  return AsyncFunctionAwait(generator, awaited, false);
+  AsyncFunctionAwait(generator, awaited, outerPromise);
+  return outerPromise;
 }
 
 // How the parser rejects promises from async/await desugaring
 function RejectPromiseNoDebugEvent(promise, reason) {
   return RejectPromise(promise, reason, false);
 }
 
 %InstallToContext([
   "async_function_await_caught", AsyncFunctionAwaitCaught,
   "async_function_await_uncaught", AsyncFunctionAwaitUncaught,
   "reject_promise_no_debug_event", RejectPromiseNoDebugEvent,
 ]);
 
 })