src: refactor tickInfo access

- Wrap access to tickInfo fields in functions
- Rename `kHasScheduled` to `kHasTickScheduled` and
  `kHasPromiseRejections` to `kHasRejectionToWarn` for clarity - note
  the latter will be set to false if the rejection does not lead to
  a warning so the previous description is not accurate.
- Set `kHasRejectionToWarn` in JS land of relying on C++ to use
  an implict contract (return value of the promise rejection handler)
  to set it, as the decision is made entirely in JS land.
- Destructure promise reject event constants.

PR-URL: https://github.com/nodejs/node/pull/25200
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: James M Snell <jasnell@gmail.com>

2 files changed, 51 insertions, 19 deletions

diff --git a/lib/internal/process/next_tick.js b/lib/internal/process/next_tick.js
index 00bba25471..0bfe168975 100644
--- a/lib/internal/process/next_tick.js
+++ b/lib/internal/process/next_tick.js
@@ -11,6 +11,8 @@ const {
 } = internalBinding('task_queue');
 
 const {
+  setHasRejectionToWarn,
+  hasRejectionToWarn,
   promiseRejectHandler,
   emitPromiseRejectionWarnings
 } = require('internal/process/promises');
@@ -30,15 +32,21 @@ const { ERR_INVALID_CALLBACK } = require('internal/errors').codes;
 const FixedQueue = require('internal/fixed_queue');
 
 // *Must* match Environment::TickInfo::Fields in src/env.h.
-const kHasScheduled = 0;
-const kHasPromiseRejections = 1;
+const kHasTickScheduled = 0;
+
+function hasTickScheduled() {
+  return tickInfo[kHasTickScheduled] === 1;
+}
+function setHasTickScheduled(value) {
+  tickInfo[kHasTickScheduled] = value ? 1 : 0;
+}
 
 const queue = new FixedQueue();
 
 function runNextTicks() {
-  if (tickInfo[kHasScheduled] === 0 && tickInfo[kHasPromiseRejections] === 0)
+  if (!hasTickScheduled() && !hasRejectionToWarn())
     runMicrotasks();
-  if (tickInfo[kHasScheduled] === 0 && tickInfo[kHasPromiseRejections] === 0)
+  if (!hasTickScheduled() && !hasRejectionToWarn())
     return;
 
   internalTickCallback();
@@ -70,10 +78,10 @@ function internalTickCallback() {
 
       emitAfter(asyncId);
     }
-    tickInfo[kHasScheduled] = 0;
+    setHasTickScheduled(false);
     runMicrotasks();
   } while (!queue.isEmpty() || emitPromiseRejectionWarnings());
-  tickInfo[kHasPromiseRejections] = 0;
+  setHasRejectionToWarn(false);
 }
 
 class TickObject {
@@ -119,7 +127,7 @@ function nextTick(callback) {
   }
 
   if (queue.isEmpty())
-    tickInfo[kHasScheduled] = 1;
+    setHasTickScheduled(true);
   queue.push(new TickObject(callback, args, getDefaultTriggerAsyncId()));
 }
 
diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index df4e8188fe..047a9d43aa 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -2,24 +2,45 @@
 
 const { safeToString } = internalBinding('util');
 const {
-  promiseRejectEvents
+  tickInfo,
+  promiseRejectEvents: {
+    kPromiseRejectWithNoHandler,
+    kPromiseHandlerAddedAfterReject,
+    kPromiseResolveAfterResolved,
+    kPromiseRejectAfterResolved
+  }
 } = internalBinding('task_queue');
 
+// *Must* match Environment::TickInfo::Fields in src/env.h.
+const kHasRejectionToWarn = 1;
+
 const maybeUnhandledPromises = new WeakMap();
 const pendingUnhandledRejections = [];
 const asyncHandledRejections = [];
 let lastPromiseId = 0;
 
+function setHasRejectionToWarn(value) {
+  tickInfo[kHasRejectionToWarn] = value ? 1 : 0;
+}
+
+function hasRejectionToWarn() {
+  return tickInfo[kHasRejectionToWarn] === 1;
+}
+
 function promiseRejectHandler(type, promise, reason) {
   switch (type) {
-    case promiseRejectEvents.kPromiseRejectWithNoHandler:
-      return unhandledRejection(promise, reason);
-    case promiseRejectEvents.kPromiseHandlerAddedAfterReject:
-      return handledRejection(promise);
-    case promiseRejectEvents.kPromiseResolveAfterResolved:
-      return resolveError('resolve', promise, reason);
-    case promiseRejectEvents.kPromiseRejectAfterResolved:
-      return resolveError('reject', promise, reason);
+    case kPromiseRejectWithNoHandler:
+      unhandledRejection(promise, reason);
+      break;
+    case kPromiseHandlerAddedAfterReject:
+      handledRejection(promise);
+      break;
+    case kPromiseResolveAfterResolved:
+      resolveError('resolve', promise, reason);
+      break;
+    case kPromiseRejectAfterResolved:
+      resolveError('reject', promise, reason);
+      break;
   }
 }
 
@@ -38,7 +59,7 @@ function unhandledRejection(promise, reason) {
     warned: false
   });
   pendingUnhandledRejections.push(promise);
-  return true;
+  setHasRejectionToWarn(true);
 }
 
 function handledRejection(promise) {
@@ -54,10 +75,11 @@ function handledRejection(promise) {
       warning.name = 'PromiseRejectionHandledWarning';
       warning.id = uid;
       asyncHandledRejections.push({ promise, warning });
-      return true;
+      setHasRejectionToWarn(true);
+      return;
     }
   }
-  return false;
+  setHasRejectionToWarn(false);
 }
 
 const unhandledRejectionErrName = 'UnhandledPromiseRejectionWarning';
@@ -121,6 +143,8 @@ function emitPromiseRejectionWarnings() {
 }
 
 module.exports = {
+  hasRejectionToWarn,
+  setHasRejectionToWarn,
   promiseRejectHandler,
   emitPromiseRejectionWarnings
 };