Report promise reject with no handler (behind a flag).

src/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.
 
 "use strict";
 
 // This file relies on the fact that the following declaration has been made
 // in runtime.js:
 // var $Object = global.Object
 // var $WeakMap = global.WeakMap
@@ skipping 12 matching lines @@
 // mirror-debugger.js currently uses builtins.promiseStatus. It would be nice
 // if we could move these property names into the closure below.
 // TODO(jkummerow/rossberg/yangguo): Find a better solution.
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
 var promiseStatus = GLOBAL_PRIVATE("Promise#status");
 var promiseValue = GLOBAL_PRIVATE("Promise#value");
 var promiseOnResolve = GLOBAL_PRIVATE("Promise#onResolve");
 var promiseOnReject = GLOBAL_PRIVATE("Promise#onReject");
 var promiseRaw = GLOBAL_PRIVATE("Promise#raw");
-var promiseDebug = GLOBAL_PRIVATE("Promise#debug");
+var promiseHasReject = GLOBAL_PRIVATE("Promise#hasReject");
 var lastMicrotaskId = 0;
 
 (function() {
 
   var $Promise = function Promise(resolver) {
     if (resolver === promiseRaw) return;
     if (!%_IsConstructCall()) throw MakeTypeError('not_a_promise', [this]);
     if (!IS_SPEC_FUNCTION(resolver))
       throw MakeTypeError('resolver_not_a_function', [resolver]);
     var promise = PromiseInit(this);
@@ skipping 108 matching lines @@
   PromiseCreate = function PromiseCreate() {
     return new $Promise(PromiseNopResolver)
   }
 
   PromiseResolve = function PromiseResolve(promise, x) {
     PromiseDone(promise, +1, x, promiseOnResolve)
   }
 
   PromiseReject = function PromiseReject(promise, r) {
     // Check promise status to confirm that this reject has an effect.
-    // Check promiseDebug property to avoid duplicate event.
-    if (DEBUG_IS_ACTIVE &&
-        GET_PRIVATE(promise, promiseStatus) == 0 &&
-        !HAS_DEFINED_PRIVATE(promise, promiseDebug)) {
-      %DebugPromiseRejectEvent(promise, r);
+    if (GET_PRIVATE(promise, promiseStatus) == 0) {
+      %PromiseRejectEvent(promise, r);
     }
     PromiseDone(promise, -1, r, promiseOnReject)
   }
 
   // Convenience.
 
   function PromiseDeferred() {
     if (this === $Promise) {
       // Optimized case, avoid extra closure.
       var promise = PromiseInit(new $Promise(promiseRaw));
@@ skipping 29 matching lines @@
       return new this(function(resolve, reject) { reject(r) });
     }
   }
 
   // Simple chaining.
 
   PromiseChain = function PromiseChain(onResolve, onReject) {  // a.k.a.
                                                                // flatMap
     onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
     onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
+    if (onReject != PromiseIdRejectHandler) {
+      // Mark this promise as having reject handler.
+      SET_PRIVATE(this, promiseHasReject, true);
+    }
     var deferred = %_CallFunction(this.constructor, PromiseDeferred);
     switch (GET_PRIVATE(this, promiseStatus)) {
       case UNDEFINED:
         throw MakeTypeError('not_a_promise', [this]);
       case 0:  // Pending
         GET_PRIVATE(this, promiseOnResolve).push(onResolve, deferred);
         GET_PRIVATE(this, promiseOnReject).push(onReject, deferred);
         break;
       case +1:  // Resolved
         PromiseEnqueue(GET_PRIVATE(this, promiseValue),
@@ skipping 93 matching lines @@
     } catch (e) {
       deferred.reject(e)
     }
     return deferred.promise;
   }
 
 
   // Utility for debugger
 
   function PromiseHasRejectHandlerRecursive(promise) {
+    if (GET_PRIVATE(promise, promiseHasReject)) return true;
     var queue = GET_PRIVATE(promise, promiseOnReject);
     if (IS_UNDEFINED(queue)) return false;
-    // Do a depth first search for a reject handler that's not
-    // the default PromiseIdRejectHandler.
+    // Do a depth first search for a promise that has been marked as having
+    // a reject handler.
     for (var i = 0; i < queue.length; i += 2) {
-      if (queue[i] != PromiseIdRejectHandler) return true;
       if (PromiseHasRejectHandlerRecursive(queue[i + 1].promise)) return true;
     }
     return false;
   }
 
   PromiseHasRejectHandler = function PromiseHasRejectHandler() {
-    // Mark promise as already having triggered a reject event.
-    SET_PRIVATE(this, promiseDebug, true);
     return PromiseHasRejectHandlerRecursive(this);
   };
 
   // -------------------------------------------------------------------
   // Install exported functions.
 
   %CheckIsBootstrapping();
   %AddNamedProperty(global, 'Promise', $Promise, DONT_ENUM);
   InstallFunctions($Promise, DONT_ENUM, [
     "defer", PromiseDeferred,
     "accept", PromiseResolved,
     "reject", PromiseRejected,
     "all", PromiseAll,
     "race", PromiseOne,
     "resolve", PromiseCast
   ]);
   InstallFunctions($Promise.prototype, DONT_ENUM, [
     "chain", PromiseChain,
     "then", PromiseThen,
     "catch", PromiseCatch
   ]);
 
 })();