process: optimize asyncHandledRejections by using FixedQueue · nodejs/node@37d49f3

'use strict';

const {

ArrayPrototypePush,

ArrayPrototypeShift,

Error,

ObjectPrototypeHasOwnProperty,

SafeMap,

SafeWeakMap,

} = primordials;

const FixedQueue = require('internal/fixed_queue');

const {

tickInfo,

promiseRejectEvents: {

let pendingUnhandledRejections = new SafeMap();

/**

* @type {Array<{promise: Promise, warning: Error}>}

* @type {import('internal/fixed_queue')<{promise: Promise, warning: Error}>}

*/

const asyncHandledRejections = [];

const asyncHandledRejections = new FixedQueue();

/**

* @type {number}

if (promiseInfo.warned) {

// Generate the warning object early to get a good stack trace.

const warning = new PromiseRejectionHandledWarning(promiseInfo.uid);

ArrayPrototypePush(asyncHandledRejections, { promise, warning });

asyncHandledRejections.push({ promise, warning });

setHasRejectionToWarn(true);

}

}

// a warning to be emitted which requires the microtask and next tick

// queues to be drained again.

function processPromiseRejections() {

let maybeScheduledTicksOrMicrotasks = asyncHandledRejections.length > 0;

let maybeScheduledTicksOrMicrotasks = !asyncHandledRejections.isEmpty();

while (asyncHandledRejections.length !== 0) {

const { promise, warning } = ArrayPrototypeShift(asyncHandledRejections);

while (!asyncHandledRejections.isEmpty()) {

const { promise, warning } = asyncHandledRejections.shift();

if (!process.emit('rejectionHandled', promise)) {

process.emitWarning(warning);

}