Improve stack traces for async functions

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 promiseAsyncStackIDSymbol =
+    utils.ImportNow("promise_async_stack_id_symbol");
 var promiseHandledBySymbol =
     utils.ImportNow("promise_handled_by_symbol");
 var promiseForwardingHandlerSymbol =
     utils.ImportNow("promise_forwarding_handler_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 SpeciesConstructor;
 var speciesSymbol = utils.ImportNow("species_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
+var ObjectHasOwnProperty;

[gsathya, 2016/09/23 06:06:20]

Is this used anywhere?

[Dan Ehrenberg, 2016/09/23 07:05:56]

Yes, inside of HAS_PRIVATE.

 
 utils.Import(function(from) {
+  ObjectHasOwnProperty = from.ObjectHasOwnProperty;
   SpeciesConstructor = from.SpeciesConstructor;
 });
 
 // -------------------------------------------------------------------
 
 // [[PromiseState]] values:
 const kPending = 0;
 const kFulfilled = +1;
 const kRejected = -1;
 
 var lastMicrotaskId = 0;
 
+function PromiseNextMicrotaskID() {
+  return ++lastMicrotaskId;
+}
+
 // ES#sec-createresolvingfunctions
 // CreateResolvingFunctions ( promise )
 function CreateResolvingFunctions(promise, debugEvent) {
   var alreadyResolved = false;
 
   // ES#sec-promise-resolve-functions
   // Promise Resolve Functions
   var resolve = value => {
     if (alreadyResolved === true) return;
     alreadyResolved = true;
@@ skipping 121 matching lines @@
         PromiseHandle(value, tasks[i], tasks[i + 1]);
       }
     } else {
       PromiseHandle(value, tasks, deferreds);
     }
     if (instrumenting) {
       %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
     }
   });
   if (instrumenting) {
-    id = ++lastMicrotaskId;
-    name = status === kFulfilled ? "Promise.resolve" : "Promise.reject";
-    %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
+    // In an async function, reuse the existing stack related to the outer
+    // Promise. Otherwise, e.g. in a direct call to then, save a new stack.
+    // Promises with multiple reactions with one or more of them being async
+    // functions will not get a good stack trace, as async functions require
+    // different stacks from direct Promise use, but we save and restore a
+    // stack once for all reactions. TODO(littledan): Improve this case.
+    if (!IS_UNDEFINED(deferreds) &&
+        HAS_PRIVATE(deferreds.promise, promiseHandledBySymbol) &&
+        HAS_PRIVATE(GET_PRIVATE(deferreds.promise, promiseHandledBySymbol),
+                    promiseAsyncStackIDSymbol)) {
+      id = GET_PRIVATE(GET_PRIVATE(deferreds.promise, promiseHandledBySymbol),
+                       promiseAsyncStackIDSymbol);
+      name = "async function";
+    } else {
+      id = PromiseNextMicrotaskID();
+      name = status === kFulfilled ? "Promise.resolve" : "Promise.reject";
+      %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
+    }
   }
 }
 
 function PromiseAttachCallbacks(promise, deferred, onResolve, onReject) {
   var maybeResolveCallbacks =
       GET_PRIVATE(promise, promiseFulfillReactionsSymbol);
   if (IS_UNDEFINED(maybeResolveCallbacks)) {
     SET_PRIVATE(promise, promiseFulfillReactionsSymbol, onResolve);
     SET_PRIVATE(promise, promiseRejectReactionsSymbol, onReject);
     SET_PRIVATE(promise, promiseDeferredReactionsSymbol, deferred);
   } else if (!IS_ARRAY(maybeResolveCallbacks)) {
     var resolveCallbacks = new InternalArray();
     var rejectCallbacks = new InternalArray();
     var existingDeferred = GET_PRIVATE(promise, promiseDeferredReactionsSymbol);
 
     resolveCallbacks.push(
         maybeResolveCallbacks, existingDeferred, onResolve, deferred);
     rejectCallbacks.push(GET_PRIVATE(promise, promiseRejectReactionsSymbol),
                          existingDeferred,
                          onReject,
                          deferred);
 
     SET_PRIVATE(promise, promiseFulfillReactionsSymbol, resolveCallbacks);
     SET_PRIVATE(promise, promiseRejectReactionsSymbol, rejectCallbacks);
+    SET_PRIVATE(promise, promiseDeferredReactionsSymbol, UNDEFINED);

[gsathya, 2016/09/23 16:06:25]

Extra symbol lookup + update here in non debug case, but I guess it's fine since
1) code is in a cleaner state, 2) should go away in rewrite

[Dan Ehrenberg, 2016/09/23 18:11:44]

If this actually made things slower, I'd argue 2 shouldn't apply, but I think 1
is a good reason. A third reason: this is in the multiple reactions case, which
is both much less common and slower.

   } else {
     maybeResolveCallbacks.push(onResolve, deferred);
     GET_PRIVATE(promise, promiseRejectReactionsSymbol).push(onReject, deferred);
   }
 }
 
 function PromiseIdResolveHandler(x) { return x; }
 function PromiseIdRejectHandler(r) { %_ReThrow(r); }
 SET_PRIVATE(PromiseIdRejectHandler, promiseForwardingHandlerSymbol, true);
 
@@ skipping 58 matching lines @@
 
     if (IS_CALLABLE(then)) {
       var callbacks = CreateResolvingFunctions(promise, false);
       var id, before_debug_event, after_debug_event;
       var instrumenting = DEBUG_IS_ACTIVE;
       if (instrumenting) {
         if (IsPromise(resolution)) {
           // Mark the dependency of the new promise on the resolution
           SET_PRIVATE(resolution, promiseHandledBySymbol, promise);
         }
-        id = ++lastMicrotaskId;
+        id = PromiseNextMicrotaskID();
         before_debug_event = {
           type: "willHandle",
           id: id,
           name: "PromiseResolveThenableJob"
         };
         after_debug_event = {
           type: "didHandle",
           id: id,
           name: "PromiseResolveThenableJob"
         };
@@ skipping 358 matching lines @@
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
   "resolvePromise", ResolvePromise,
   "rejectPromise", DoRejectPromise
 ]);
 
 utils.Export(function(to) {
   to.IsPromise = IsPromise;
   to.PromiseCreate = PromiseCreate;
   to.PromiseThen = PromiseThen;
+  to.PromiseNextMicrotaskID = PromiseNextMicrotaskID;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })