Async/await Promise dependency graph

src/js/promise.js

 // Copyright 2012 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();
 
 // -------------------------------------------------------------------
 // Imports
 
 var InternalArray = utils.InternalArray;
+var GlobalSet = global.Set;
 var promiseAwaitHandlerSymbol =
     utils.ImportNow("promise_await_handler_symbol");
 var promiseCombinedDeferredSymbol =
     utils.ImportNow("promise_combined_deferred_symbol");
 var promiseHasHandlerSymbol =
     utils.ImportNow("promise_has_handler_symbol");
 var promiseRejectReactionsSymbol =
     utils.ImportNow("promise_reject_reactions_symbol");
 var promiseFulfillReactionsSymbol =
     utils.ImportNow("promise_fulfill_reactions_symbol");
 var promiseDeferredReactionsSymbol =
     utils.ImportNow("promise_deferred_reactions_symbol");
 var promiseHandledHintSymbol =
     utils.ImportNow("promise_handled_hint_symbol");
 var promiseRawSymbol = utils.ImportNow("promise_raw_symbol");
 var promiseStateSymbol = utils.ImportNow("promise_state_symbol");
 var promiseResultSymbol = utils.ImportNow("promise_result_symbol");
+var SetAdd;
+var SetHas;
 var SpeciesConstructor;
 var speciesSymbol = utils.ImportNow("species_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 
 utils.Import(function(from) {
   SpeciesConstructor = from.SpeciesConstructor;
+  SetAdd = from.SetAdd;

[adamk, 2016/09/15 22:39:40]

Nit: sort

[Dan Ehrenberg, 2016/09/17 00:04:31]

Done

+  SetHas = from.SetHas;
 });
 
 // -------------------------------------------------------------------
 
 // [[PromiseState]] values:
 const kPending = 0;
 const kFulfilled = +1;
 const kRejected = -1;
 
 var lastMicrotaskId = 0;
@@ skipping 181 matching lines @@
 // Define exported functions.
 
 // For bootstrapper.
 
 // ES#sec-ispromise IsPromise ( x )
 function IsPromise(x) {
   return IS_RECEIVER(x) && HAS_DEFINED_PRIVATE(x, promiseStateSymbol);
 }
 
 function PromiseCreate() {
-  return new GlobalPromise(PromiseNopResolver)
+  return new GlobalPromise(PromiseNopResolver);
 }
 
 // ES#sec-promise-resolve-functions
 // Promise Resolve Functions, steps 6-13
 function ResolvePromise(promise, resolution) {
   if (resolution === promise) {
     return RejectPromise(promise,
                          %make_type_error(kPromiseCyclic, resolution),
                          true);
   }
@@ skipping 30 matching lines @@
         SET_PRIVATE(resolution, promiseHasHandlerSymbol, true);
         return;
       }
     }
 
     if (IS_CALLABLE(then)) {
       // PromiseResolveThenableJob
       var id;
       var name = "PromiseResolveThenableJob";
       var instrumenting = DEBUG_IS_ACTIVE;
+      if (instrumenting && !IS_UNDEFINED(resolution) &&

[adamk, 2016/09/15 22:39:40]

No need to check !IS_UNDEFINED if you're checking IsPromise (which calls
IS_RECEIVER).

[Dan Ehrenberg, 2016/09/17 00:04:31]

Done

+          IsPromise(resolution)) {
+        // Mark the dependency of the new promise on the resolution
+        SET_PRIVATE(resolution, promiseAwaitHandlerSymbol, promise);
+      }
       %EnqueueMicrotask(function() {
         if (instrumenting) {
           %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
         }
         // These resolving functions simply forward the exception, so
         // don't create a new debugEvent.
         var callbacks = CreateResolvingFunctions(promise, false);
         try {
           %_Call(then, resolution, callbacks.resolve, callbacks.reject);
         } catch (e) {
           %_Call(callbacks.reject, UNDEFINED, e);
         }
         if (instrumenting) {
           %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
         }
       });
       if (instrumenting) {
         id = ++lastMicrotaskId;
         %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
       }
       return;
     }
   }
-  FulfillPromise(promise, kFulfilled, resolution, promiseFulfillReactionsSymbol);
+  FulfillPromise(promise, kFulfilled, resolution,
+                 promiseFulfillReactionsSymbol);
 }
 
 // ES#sec-rejectpromise
 // RejectPromise ( promise, reason )
 function RejectPromise(promise, reason, debugEvent) {
   // Check promise status to confirm that this reject has an effect.
   // Call runtime for callbacks to the debugger or for unhandled reject.
   // The debugEvent parameter sets whether a debug ExceptionEvent should
   // be triggered. It should be set to false when forwarding a rejection
   // rather than creating a new one.
@@ skipping 205 matching lines @@
     }
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 
 // Utility for debugger
 
-function PromiseHasUserDefinedRejectHandlerCheck(handler, deferred) {
-  // If this handler was installed by async/await, it does not indicate
-  // that there is a user-defined reject handler.
-  if (GET_PRIVATE(handler, promiseAwaitHandlerSymbol)) return false;
+function PromiseHasUserDefinedRejectHandlerCheck(handler, deferred, visited) {
+  // If this handler was installed by a locally uncaught await, recurse
+  // up to the outer Promise returned by that async function.
+  // In this case, the dependency subsumes any other things attached to the
+  // handler, as the dependency is only present due to async/await and is not
+  // a real catch handler.
+  var outerPromise = GET_PRIVATE(handler, promiseAwaitHandlerSymbol);
+  if (outerPromise) {
+    return PromiseHasUserDefinedRejectHandlerRecursive(outerPromise, visited);
+  }
   if (handler !== PromiseIdRejectHandler) {
     var combinedDeferred = GET_PRIVATE(handler, promiseCombinedDeferredSymbol);
     if (IS_UNDEFINED(combinedDeferred)) return true;
-    if (PromiseHasUserDefinedRejectHandlerRecursive(combinedDeferred.promise)) {
+    if (PromiseHasUserDefinedRejectHandlerRecursive(combinedDeferred.promise,
+                                                    visited)) {
       return true;
     }
-  } else if (PromiseHasUserDefinedRejectHandlerRecursive(deferred.promise)) {
+  } else if (PromiseHasUserDefinedRejectHandlerRecursive(deferred.promise,
+                                                         visited)) {
     return true;
   }
   return false;
 }
 
-function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
+function PromiseHasUserDefinedRejectHandlerRecursive(promise, visited) {
+  // Avoid visiting the Promise multiple times in case there is a cycle
+  // in the dependency graph.
+  if (%_Call(SetHas, visited, promise)) return false;

[adamk, 2016/09/15 22:39:40]

My brain is having trouble groking all the tests; are there tests covering this
cycle-handling?

+  %_Call(SetAdd, visited, promise);
+
   // If this promise was marked as being handled by a catch block
   // in an async function, then it has a user-defined reject handler.
   if (GET_PRIVATE(promise, promiseHandledHintSymbol)) return true;
 
+  // If this Promise is subsumed by another Promise (a Promise resolved
+  // with another Promise, or an intermediate, hidden, throwaway Promise
+  // within async/await), then recurse on the outer Promise.
+  // In this case, the dependency is one possible way that the Promise
+  // could be resolved, so it does not subsume the other following cases.
+  var outerPromise = GET_PRIVATE(promise, promiseAwaitHandlerSymbol);
+  if (outerPromise &&
+      PromiseHasUserDefinedRejectHandlerRecursive(outerPromise, visited)) {
+    return true;
+  }
+
   var queue = GET_PRIVATE(promise, promiseRejectReactionsSymbol);
   var deferreds = GET_PRIVATE(promise, promiseDeferredReactionsSymbol);
 
   if (IS_UNDEFINED(queue)) return false;
 
   if (!IS_ARRAY(queue)) {
-    return PromiseHasUserDefinedRejectHandlerCheck(queue, deferreds);
+    return PromiseHasUserDefinedRejectHandlerCheck(queue, deferreds, visited);
   }
 
   for (var i = 0; i < queue.length; i += 2) {
-    if (PromiseHasUserDefinedRejectHandlerCheck(queue[i], queue[i + 1])) {
+    if (PromiseHasUserDefinedRejectHandlerCheck(queue[i],
+                                                queue[i + 1],
+                                                visited)) {
       return true;
     }
   }
   return false;
 }
 
 // Return whether the promise will be handled by a user-defined reject
 // handler somewhere down the promise chain. For this, we do a depth-first
 // search for a reject handler that's not the default PromiseIdRejectHandler.
+// This function also traverses dependencies of one Promise on another,
+// set up through async/await and Promises resolved with Promises. The graph
+// may contain cycles, so a set of visited Promises is maintained.
 function PromiseHasUserDefinedRejectHandler() {
-  return PromiseHasUserDefinedRejectHandlerRecursive(this);
+  return PromiseHasUserDefinedRejectHandlerRecursive(this, new GlobalSet());
 };
 
 
 function PromiseSpecies() {
   return this;
 }
 
 // -------------------------------------------------------------------
 // Install exported functions.
 
@@ skipping 39 matching lines @@
   to.PromiseThen = PromiseThen;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })