Async/await Promise dependency graph

src/js/harmony-async-await.js

Index: src/js/harmony-async-await.js
diff --git a/src/js/harmony-async-await.js b/src/js/harmony-async-await.js
index 3cacaf19e6f3dbadc9aa3583e0b26ba6728b89c3..35860c2251fc539903f9b1d603508b17f877eeee 100644
--- a/src/js/harmony-async-await.js
+++ b/src/js/harmony-async-await.js
@@ -50,7 +50,7 @@ function PromiseCastResolved(value) {
   }
 }
 
-function AsyncFunctionAwait(generator, awaited, mark) {
+function AsyncFunctionAwait(generator, awaited, outerPromise) {
   // Promise.resolve(awaited).then(
   //     value => AsyncFunctionNext(value),
   //     error => AsyncFunctionThrow(error)
@@ -62,28 +62,35 @@ function AsyncFunctionAwait(generator, awaited, mark) {
   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