Change which ExceptionEvents are triggered by Promises

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 26 matching lines @@
 
 // [[PromiseState]] values:
 const kPending = 0;
 const kFulfilled = +1;
 const kRejected = -1;
 
 var lastMicrotaskId = 0;
 
 // ES#sec-createresolvingfunctions
 // CreateResolvingFunctions ( promise )
-function CreateResolvingFunctions(promise) {
+function CreateResolvingFunctions(promise, suppressDebugEvent) {
   var alreadyResolved = false;
 
   // ES#sec-promise-resolve-functions
   // Promise Resolve Functions
   var resolve = value => {
     if (alreadyResolved === true) return;
     alreadyResolved = true;
     ResolvePromise(promise, value);
   };
 
   // ES#sec-promise-reject-functions
   // Promise Reject Functions
   var reject = reason => {
     if (alreadyResolved === true) return;
     alreadyResolved = true;
-    RejectPromise(promise, reason);
+    RejectPromise(promise, reason, suppressDebugEvent);
   };
 
   return {
     __proto__: null,
     resolve: resolve,
     reject: reject
   };
 }
 
 
@@ skipping 187 matching lines @@
                        promiseFulfillReactionsSymbol);
         SET_PRIVATE(promise, promiseHasHandlerSymbol, true);
         return;
       } else if (thenableState === kRejected) {
         var thenableValue = GET_PRIVATE(resolution, promiseResultSymbol);
         if (!HAS_DEFINED_PRIVATE(resolution, promiseHasHandlerSymbol)) {
           // Promise has already been rejected, but had no handler.
           // Revoke previously triggered reject event.
           %PromiseRevokeReject(resolution);
         }
-        RejectPromise(promise, thenableValue);
+        RejectPromise(promise, thenableValue, true);
         SET_PRIVATE(resolution, promiseHasHandlerSymbol, true);
         return;
       }
     }
 
     if (IS_CALLABLE(then)) {
       // PromiseResolveThenableJob
       var id;
       var name = "PromiseResolveThenableJob";
       var instrumenting = DEBUG_IS_ACTIVE;
       %EnqueueMicrotask(function() {
         if (instrumenting) {
           %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
         }
-        var callbacks = CreateResolvingFunctions(promise);
+        var callbacks = CreateResolvingFunctions(promise, true);
         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);
 }
 
 // ES#sec-rejectpromise
 // RejectPromise ( promise, reason )
-function RejectPromise(promise, reason) {
+function RejectPromise(promise, reason, suppressDebugEvent) {

[adamk, 2016/08/23 22:29:27]

It's confusing to me that %PromiseRejectEvent takes a boolean that's inverted
from this one. Can you change them to match? Either change this one to
"emitDebugEvent" or similar, or change the runtime function to make its argument
mean "suppress". If you do the latter, you could avoid passing the
DEBUG_IS_ACTIVE bit, since I assume it's easy to get ahold of that from C++
anyway.

[Dan Ehrenberg, 2016/08/23 23:28:38]

Good point. Switched it to debugEvent as a positive reason everywhere. That
change motivated an audit of the code base (since I'm not depending on a default
argument anymore) to see whether events should be triggered, and I found that we
probably shouldn't be triggering these events for the output of Promise.all and
Promise.race, so this patch fixes that.

   // Check promise status to confirm that this reject has an effect.
   // Call runtime for callbacks to the debugger or for unhandled reject.
   if (GET_PRIVATE(promise, promiseStateSymbol) === kPending) {
-    var debug_is_active = DEBUG_IS_ACTIVE;
-    if (debug_is_active ||
+    var debugEvent = DEBUG_IS_ACTIVE && !suppressDebugEvent
+    if (debugEvent ||
         !HAS_DEFINED_PRIVATE(promise, promiseHasHandlerSymbol)) {
-      %PromiseRejectEvent(promise, reason, debug_is_active);
+      %PromiseRejectEvent(promise, reason, debugEvent, false);
     }
   }
   FulfillPromise(promise, kRejected, reason, promiseRejectReactionsSymbol)
 }
 
 // ES#sec-newpromisecapability
 // NewPromiseCapability ( C )
-function NewPromiseCapability(C) {
+function NewPromiseCapability(C, suppressDebugEvent) {
   if (C === GlobalPromise) {
     // Optimized case, avoid extra closure.
     var promise = PromiseInit(new GlobalPromise(promiseRawSymbol));
-    var callbacks = CreateResolvingFunctions(promise);
+    var callbacks = CreateResolvingFunctions(promise, suppressDebugEvent);
     return {
       promise: promise,
       resolve: callbacks.resolve,
       reject: callbacks.reject
     };
   }
 
   var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
   result.promise = new C((resolve, reject) => {
     if (!IS_UNDEFINED(result.resolve) || !IS_UNDEFINED(result.reject))
@@ skipping 10 matching lines @@
 
 // ES#sec-promise.reject
 // Promise.reject ( x )
 function PromiseReject(r) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, PromiseResolve);
   }
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
     var promise = PromiseCreateAndSet(kRejected, r);
-    // The debug event for this would always be an uncaught promise reject,
-    // which is usually simply noise. Do not trigger that debug event.
-    %PromiseRejectEvent(promise, r, false);
+    // Trigger debug events if the debugger is on, as Promise.reject is
+    // equivalent to throwing an exception directly.
+    %PromiseRejectEvent(promise, r, DEBUG_IS_ACTIVE, true);
     return promise;
   } else {
     var promiseCapability = NewPromiseCapability(this);
     %_Call(promiseCapability.reject, UNDEFINED, r);
     return promiseCapability.promise;
   }
 }
 
 // Shortcut Promise.reject and Promise.resolve() implementations, used by
 // Async Functions implementation.
 function PromiseCreateRejected(r) {
-  return %_Call(PromiseReject, GlobalPromise, r);
+  var promise = PromiseCreateAndSet(kRejected, r);
+  // This is called from the desugaring of async/await; no reason to
+  // create a redundant reject event.
+  %PromiseRejectEvent(promise, r, false, false);

[adamk, 2016/08/23 22:29:27]

Passing two bools is not ideal, see suggestion in runtime-internal.cc.

[Dan Ehrenberg, 2016/08/23 23:28:38]

Fixed, now separated out a different function.

+  return promise;
 }
 
 function PromiseCreateResolved(value) {
   var promise = PromiseInit(new GlobalPromise(promiseRawSymbol));
   var resolveResult = ResolvePromise(promise, value);
   return promise;
 }
 
 function PromiseCastResolved(value) {
   if (IsPromise(value)) {
@@ skipping 37 matching lines @@
 // ES#sec-promise.prototype.then
 // Promise.prototype.then ( onFulfilled, onRejected )
 // Multi-unwrapped chaining with thenable coercion.
 function PromiseThen(onResolve, onReject) {
   var status = GET_PRIVATE(this, promiseStateSymbol);
   if (IS_UNDEFINED(status)) {
     throw %make_type_error(kNotAPromise, this);
   }
 
   var constructor = SpeciesConstructor(this, GlobalPromise);
-  var resultCapability = NewPromiseCapability(constructor);
+  var resultCapability = NewPromiseCapability(constructor, true);
   return PerformPromiseThen(this, onResolve, onReject, resultCapability);
 }
 
 // ES#sec-promise.prototype.catch
 // Promise.prototype.catch ( onRejected )
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Combinators.
@@ skipping 176 matching lines @@
 utils.Export(function(to) {
   to.PromiseCastResolved = PromiseCastResolved;
   to.PromiseThen = PromiseThen;
 
   to.GlobalPromise = GlobalPromise;
   to.NewPromiseCapability = NewPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
 });
 
 })