Make PromiseRejectCallback fire after end-of-turn.

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
 
 // For bootstrapper.
 
 var IsPromise;
 var PromiseCreate;
 var PromiseResolve;
 var PromiseReject;
 var PromiseChain;
 var PromiseCatch;
 var PromiseThen;
-var PromiseHasRejectHandler;
+var PromiseScheduleUnhandledRejectMessage;
+var PromiseScheduleRevokeRejectMessage;
+var PromiseDispatchUnhandledRejectMessages;
 var PromiseHasUserDefinedRejectHandler;
 
 // 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 promiseHasHandler = %PromiseHasHandlerSymbol();
+var promiseHasHandler = GLOBAL_PRIVATE("Promise#hasHandler");
+// Enqueued promise message: true = revoke reject, false = unhandled reject
+var promiseMessage = GLOBAL_PRIVATE("Promise#message");
 var lastMicrotaskId = 0;
+var promiseMicrotasksCount = 0;
+var enqueuedPromiseMessages;
 
 
 (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 66 matching lines @@
         deferred.resolve(result);
     } catch (exception) {
       try { deferred.reject(exception); } catch (e) { }
     } finally {
       %DebugPopPromise();
     }
   }
 
   function PromiseEnqueue(value, tasks, status) {
     var id, name, instrumenting = DEBUG_IS_ACTIVE;
+    ++promiseMicrotasksCount;
     %EnqueueMicrotask(function() {
       if (instrumenting) {
         %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
       }
       for (var i = 0; i < tasks.length; i += 2) {
-        PromiseHandle(value, tasks[i], tasks[i + 1])
+        PromiseHandle(value, tasks[i], tasks[i + 1]);
       }
       if (instrumenting) {
         %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
       }
+      --promiseMicrotasksCount;
     });
     if (instrumenting) {
       id = ++lastMicrotaskId;
       name = status > 0 ? "Promise.resolve" : "Promise.reject";
       %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
     }
   }
 
   function PromiseIdResolveHandler(x) { return x }
   function PromiseIdRejectHandler(r) { throw r }
@@ skipping 14 matching lines @@
   }
 
   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.
     // Call runtime for callbacks to the debugger or for unhandled reject.
     if (GET_PRIVATE(promise, promiseStatus) == 0) {
-      var debug_is_active = DEBUG_IS_ACTIVE;
-      if (debug_is_active || !HAS_DEFINED_PRIVATE(promise, promiseHasHandler)) {
-        %PromiseRejectEvent(promise, r, debug_is_active);
+      if (DEBUG_IS_ACTIVE) {
+        %DebugPromiseRejectEvent(promise, r);
+      }
+      if (!HAS_DEFINED_PRIVATE(promise, promiseHasHandler)) {
+        PromiseScheduleUnhandledRejectMessage(promise, r, false);
       }
     }
     PromiseDone(promise, -1, r, promiseOnReject)
   }
 
   // Convenience.
 
   function PromiseDeferred() {
     if (this === $Promise) {
       // Optimized case, avoid extra closure.
@@ skipping 20 matching lines @@
     } else {
       return new this(function(resolve, reject) { resolve(x) });
     }
   }
 
   function PromiseRejected(r) {
     var promise;
     if (this === $Promise) {
       // Optimized case, avoid extra closure.
       promise = PromiseSet(new $Promise(promiseRaw), -1, 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);
+      PromiseScheduleUnhandledRejectMessage(promise, r, false);
     } else {
       promise = new this(function(resolve, reject) { reject(r) });
     }
     return promise;
   }
 
   // Simple chaining.
 
   PromiseChain = function PromiseChain(onResolve, onReject) {  // a.k.a.
                                                                // flatMap
     onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
     onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
     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),
                        [onResolve, deferred],
                        +1);
         break;
       case -1:  // Rejected
         if (!HAS_DEFINED_PRIVATE(this, promiseHasHandler)) {
           // Promise has already been rejected, but had no handler.
-          // Revoke previously triggered reject event.
-          %PromiseRevokeReject(this);
+          // Revoke previously triggered reject message.
+          PromiseScheduleRevokeRejectMessage(this);
         }
         PromiseEnqueue(GET_PRIVATE(this, promiseValue),
                        [onReject, deferred],
                        -1);
         break;
     }
     // Mark this promise as having handler.
     SET_PRIVATE(this, promiseHasHandler, true);
     if (DEBUG_IS_ACTIVE) {
       %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
@@ skipping 81 matching lines @@
       }
     } catch (e) {
       deferred.reject(e)
     }
     return deferred.promise;
   }
 
 
   // Utility for debugger
 
+  function PromiseScheduleUnhandledRejectMessage(promise, r, revoke) {
+    if (!enqueuedPromiseMessages) {
+      enqueuedPromiseMessages = new InternalArray;
+      %EnqueueMicrotask(PromiseDispatchUnhandledRejectMessages);
+    }
+    SET_PRIVATE(promise, promiseMessage, revoke);
+    enqueuedPromiseMessages.push(promise, r);
+  }
+
+  function PromiseScheduleRevokeRejectMessage(promise) {
+    if (HAS_DEFINED_PRIVATE(promise, promiseMessage)) {
+      DELETE_PRIVATE(promise, promiseMessage);
+    } else {
+      PromiseScheduleUnhandledRejectMessage(promise, UNDEFINED, true);
+    }
+  }
+
+  function PromiseDispatchUnhandledRejectMessages() {
+    if (promiseMicrotasksCount || %PendingMicrotaskCount()) {
+      %EnqueueMicrotask(PromiseDispatchUnhandledRejectMessages);
+      return;
+    }
+    var queue = enqueuedPromiseMessages;
+    enqueuedPromiseMessages = UNDEFINED;
+    for (var i = 0; i < queue.length; i += 2) {
+      var promise = queue[i];
+      if (HAS_DEFINED_PRIVATE(promise, promiseMessage)) {
+        var revoke = GET_PRIVATE(promise, promiseMessage);
+        DELETE_PRIVATE(promise, promiseMessage);
+        if (revoke) %PromiseRevokeRejectMessage(promise);
+        else %PromiseRejectMessage(promise, queue[i + 1]);
+      }
+    }
+  }
+
   function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
     var queue = GET_PRIVATE(promise, promiseOnReject);
     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)) {
         return true;
       }
     }
     return false;
@@ skipping 20 matching lines @@
     "race", PromiseOne,
     "resolve", PromiseCast
   ]);
   InstallFunctions($Promise.prototype, DONT_ENUM, [
     "chain", PromiseChain,
     "then", PromiseThen,
     "catch", PromiseCatch
   ]);
 
 })();