adapt changes from nodejs#34862

lib/internal/process/promises.js

@@ -5,6 +5,7 @@ const {
   ArrayPrototypeShift,
   Error,
   ObjectPrototypeHasOwnProperty,
+  SafeMap,
   SafeWeakMap,
 } = primordials;
 
@@ -149,9 +150,10 @@ class PromiseRejectionHandledWarning extends Error {
 const maybeUnhandledPromises = new SafeWeakMap();
 
 /**
- * @type {Promise[]}
+ * Using a Mp causes the promise to be referenced at least for one tick.
+ * @type {Map<Promise, PromiseInfo>}
  */
-const pendingUnhandledRejections = [];
+let pendingUnhandledRejections = new SafeMap();
 
 /**
  * @type {Array<{promise: Promise, warning: Error}>}
@@ -279,21 +281,23 @@ const emitUnhandledRejection = (promise, promiseInfo) => {
  * @param {Error} reason
  */
 function unhandledRejection(promise, reason) {
-  maybeUnhandledPromises.set(promise, {
+  pendingUnhandledRejections.set(promise, {
     reason,
     uid: ++lastPromiseId,
     warned: false,
     domain: process.domain,
   });
-  // This causes the promise to be referenced at least for one tick.
-  ArrayPrototypePush(pendingUnhandledRejections, promise);
   setHasRejectionToWarn(true);
 }
 
 /**
  * @param {Promise} promise
  */
 function handledRejection(promise) {
+  if (pendingUnhandledRejections.has(promise)) {
+    pendingUnhandledRejections.delete(promise);
+    return;
+  }
   const promiseInfo = maybeUnhandledPromises.get(promise);
   if (promiseInfo !== undefined) {
     maybeUnhandledPromises.delete(promise);
@@ -465,16 +469,17 @@ function processPromiseRejections() {
     }
   }
 
-  let len = pendingUnhandledRejections.length;
   let needPop = true;
   let promiseAsyncId;
 
-  while (len--) {
-    const promise = ArrayPrototypeShift(pendingUnhandledRejections);
-    const promiseInfo = maybeUnhandledPromises.get(promise);
-    if (promiseInfo === undefined) {
-      continue;
-    }
+  const pending = pendingUnhandledRejections;
+  pendingUnhandledRejections = new SafeMap();
+
+  for (const { 0: promise, 1: promiseInfo } of pending.entries()) {
+    pending.delete(promise);
+
+    maybeUnhandledPromises.set(promise, promiseInfo);
+
     promiseInfo.warned = true;
 
     // We need to check if async_hooks are enabled
@@ -499,7 +504,7 @@ function processPromiseRejections() {
     maybeScheduledTicksOrMicrotasks = true;
   }
   return maybeScheduledTicksOrMicrotasks ||
-         pendingUnhandledRejections.length !== 0;
+         pendingUnhandledRejections.size !== 0;
 }
 
 function listenForRejections() {

test/parallel/test-promise-unhandled-issue-43655.js

@@ -0,0 +1,26 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+function delay(time) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}
+
+async function test() {
+  for (let i = 0; i < 1000000; i++) {
+    await new Promise((resolve, reject) => {
+      reject('value');
+    })
+      .then(() => { }, () => { });
+  }
+
+  const time0 = Date.now();
+  await delay(0);
+
+  assert.ok(Date.now() - time0 < 10);
+}
+
+test();