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

src/js/promise.js

Index: src/js/promise.js
diff --git a/src/js/promise.js b/src/js/promise.js
index b4a25846cada38d99e5a3ddadd1cf25f39e2953b..31126b98c510d09c45b1946993ee0794034fbd43 100644
--- a/src/js/promise.js
+++ b/src/js/promise.js
@@ -12,6 +12,8 @@
 // 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");
@@ -298,7 +300,7 @@ function PromiseAll(iterable) {
     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) {
@@ -308,6 +310,7 @@ function PromiseAll(iterable) {
             }
           })(i),
           function(r) { deferred.reject(r); });
+      SET_PRIVATE(promise, promiseCombinedDeferredSymbol, deferred);
       ++i;
       ++count;
     }
@@ -326,9 +329,10 @@ 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)
@@ -343,8 +347,15 @@ 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;
     }
   }