Debugger: correctly report uncaught rejections in Promise.all and Promise.race.

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 promiseCombinedDeferredSymbol =
+    utils.ImportNow("promise_combined_deferred_symbol");
 var promiseHasHandlerSymbol =
     utils.ImportNow("promise_has_handler_symbol");
 var promiseOnRejectSymbol = utils.ImportNow("promise_on_reject_symbol");
 var promiseOnResolveSymbol =
     utils.ImportNow("promise_on_resolve_symbol");
 var promiseRawSymbol = utils.ImportNow("promise_raw_symbol");
 var promiseStatusSymbol = utils.ImportNow("promise_status_symbol");
 var promiseValueSymbol = utils.ImportNow("promise_value_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 
@@ skipping 266 matching lines @@
   }
 }
 
 function PromiseAll(iterable) {
   var deferred = %_CallFunction(this, PromiseDeferred);
   var resolutions = [];
   try {
     var count = 0;
     var i = 0;
     for (var value of iterable) {
-      this.resolve(value).then(
+      var promise = this.resolve(value).then(
           // Nested scope to get closure over current i.
           // TODO(arv): Use an inner let binding once available.
           (function(i) {
             return function(x) {
               resolutions[i] = x;
               if (--count === 0) deferred.resolve(resolutions);
             }
           })(i),
           function(r) { deferred.reject(r); });
+      SET_PRIVATE(promise, promiseCombinedDeferredSymbol, deferred);
       ++i;
       ++count;
     }
 
     if (count === 0) {
       deferred.resolve(resolutions);
     }
 
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 function PromiseRace(iterable) {
   var deferred = %_CallFunction(this, PromiseDeferred);
   try {
     for (var value of iterable) {
-      this.resolve(value).then(
+      var promise = this.resolve(value).then(
           function(x) { deferred.resolve(x) },
           function(r) { deferred.reject(r) });
+      SET_PRIVATE(promise, promiseCombinedDeferredSymbol, deferred);
     }
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 
 // Utility for debugger
 
 function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
   var queue = GET_PRIVATE(promise, promiseOnRejectSymbol);
   if (IS_UNDEFINED(queue)) return false;
   for (var i = 0; i < queue.length; i += 2) {
-    if (queue[i] != PromiseIdRejectHandler) return true;
-    if (PromiseHasUserDefinedRejectHandlerRecursive(queue[i + 1].promise)) {
+    var handler = queue[i];
+    var promise = queue[i + 1].promise;
+    if (handler !== PromiseIdRejectHandler) {
+      var deferred = GET_PRIVATE(promise, promiseCombinedDeferredSymbol);
+      if (IS_UNDEFINED(deferred)) return true;
+      if (PromiseHasUserDefinedRejectHandlerRecursive(deferred.promise)) {

[rossberg, 2015/10/19 14:24:29]

Why the extra conditional and not a tail call?

return PromiseHasUserDefinedRejectHandlerRecursive(deferred.promise);

Similarly below.

[Yang, 2015/10/19 16:24:09]

A promise is considered to have a reject handler if one of its dependent
promises is.

So if it returns false here, we have to continue the loop, visiting other tree
branches (other dependent promises).

+        return true;
+      }
+    } else if (PromiseHasUserDefinedRejectHandlerRecursive(promise)) {
       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.
 function PromiseHasUserDefinedRejectHandler() {
@@ skipping 35 matching lines @@
 // This allows extras to create promises quickly without building extra
 // resolve/reject closures, and allows them to later resolve and reject any
 // promise without having to hold on to those closures forever.
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
   "resolvePromise", PromiseResolve,
   "rejectPromise", PromiseReject
 ]);
 
 })