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();
 
@@ skipping 218 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 (!IS_UNDEFINED(resolution) && DEBUG_IS_ACTIVE && IsPromise(resolution)) {

[gsathya, 2016/09/08 21:38:58]

nit: format, s/DEBUG_IS_ACTIVE/instrumenting, and can you make instrumenting the
first conditional on this?

[Dan Ehrenberg, 2016/09/12 22:49:25]

Done

+        // 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) {
@@ skipping 230 matching lines @@
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 
 // Utility for debugger
 
 function PromiseHasUserDefinedRejectHandlerCheck(handler, deferred) {
-  if (GET_PRIVATE(handler, promiseAwaitHandlerSymbol)) return false;
+  var outerPromise = GET_PRIVATE(handler, promiseAwaitHandlerSymbol);
+  if (outerPromise) {
+    return PromiseHasUserDefinedRejectHandlerRecursive(outerPromise);
+  }
   if (handler !== PromiseIdRejectHandler) {
     var combinedDeferred = GET_PRIVATE(handler, promiseCombinedDeferredSymbol);
     if (IS_UNDEFINED(combinedDeferred)) return true;
     if (PromiseHasUserDefinedRejectHandlerRecursive(combinedDeferred.promise)) {
       return true;
     }
   } else if (PromiseHasUserDefinedRejectHandlerRecursive(deferred.promise)) {
     return true;
   }
   return false;
 }
 
 function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
   var handledHintSymbol = GET_PRIVATE(promise, promiseHandledHintSymbol);
   if (handledHintSymbol) return true;
+  var outerPromise = GET_PRIVATE(promise, promiseAwaitHandlerSymbol);
+  if (outerPromise) {
+    return PromiseHasUserDefinedRejectHandlerRecursive(outerPromise);
+  }
   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);
   } else {
     for (var i = 0; i < queue.length; i += 2) {
       if (PromiseHasUserDefinedRejectHandlerCheck(queue[i], queue[i + 1])) {
         return true;
       }
@@ skipping 61 matching lines @@
   to.PromiseThen = PromiseThen;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })