From 440ff338ddb97add9d3e9ddbc36386162c796f34 Mon Sep 17 00:00:00 2001
From: Robert Nagy <ronagy@icloud.com>
Date: Sat, 23 Dec 2023 10:58:53 +0100
Subject: [PATCH] lib: run microtasks before ticks

This resolve multiple timing issues related to promises
and nextTick. As well as resolving zaldo in promise only
code, i.e. our current best practice of using process.nextTick
will always apply and work.

Refs: https://github.com/nodejs/node/issues/51156
Refs: https://github.com/nodejs/node/issues/51156#issuecomment-1864656761
Refs: https://github.com/nodejs/node/pull/51114
Refs: https://github.com/nodejs/node/pull/51070
Refs: https://github.com/nodejs/node/issues/51156

PR-URL: https://github.com/nodejs/node/pull/51267
---
 doc/api/cli.md                      | 14 +++++++
 lib/internal/process/task_queues.js | 57 +++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+)

diff --git a/doc/api/cli.md b/doc/api/cli.md
index 072b3b8ead55b8..6140bc112a8cfc 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -863,6 +863,20 @@ Use this flag to generate a blob that can be injected into the Node.js
 binary to produce a [single executable application][]. See the documentation
 about [this configuration][`--experimental-sea-config`] for details.
 
+
+### `--experimental-task-ordering`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Enable experimental task ordering. Always drain micro task queue
+before running `process.nextTick` to avoid unintuitive behavior
+and unexpected logical deadlocks when mixing async callback and
+event API's with `Promise`, `async`/`await`` and `queueMicroTask`.
+
 ### `--experimental-shadow-realm`
 
 <!-- YAML
diff --git a/lib/internal/process/task_queues.js b/lib/internal/process/task_queues.js
index bcb5eef841dd00..29079c9f5c050b 100644
--- a/lib/internal/process/task_queues.js
+++ b/lib/internal/process/task_queues.js
@@ -41,6 +41,7 @@ const {
 
 const { AsyncResource } = require('async_hooks');
 
+let experimentalTaskOrdering;
 // *Must* match Environment::TickInfo::Fields in src/env.h.
 const kHasTickScheduled = 0;
 
@@ -65,6 +66,19 @@ function runNextTicks() {
 }
 
 function processTicksAndRejections() {
+  if (experimentalTaskOrdering === undefined) {
+    const { getOptionValue } = require('internal/options');
+    experimentalTaskOrdering = getOptionValue('--experimental-task-ordering');
+  }
+
+  if (experimentalTaskOrdering) {
+    processTicksAndRejectionsNew();
+  } else {
+    processTicksAndRejectionsOld();
+  }
+}
+
+function processTicksAndRejectionsOld() {
   let tock;
   do {
     while ((tock = queue.shift()) !== null) {
@@ -98,6 +112,49 @@ function processTicksAndRejections() {
   setHasRejectionToWarn(false);
 }
 
+
+function processTicksAndRejectionsNew() {
+  if (experimentalTaskOrdering === undefined) {
+    const { getOptionValue } = require('internal/options');
+    experimentalTaskOrdering = getOptionValue('--experimental-task-ordering');
+  }
+
+  let tock;
+  do {
+    runMicrotasks();
+    while ((tock = queue.shift()) !== null) {
+      const asyncId = tock[async_id_symbol];
+      emitBefore(asyncId, tock[trigger_async_id_symbol], tock);
+
+      try {
+        const callback = tock.callback;
+        if (tock.args === undefined) {
+          callback();
+        } else {
+          const args = tock.args;
+          switch (args.length) {
+            case 1: callback(args[0]); break;
+            case 2: callback(args[0], args[1]); break;
+            case 3: callback(args[0], args[1], args[2]); break;
+            case 4: callback(args[0], args[1], args[2], args[3]); break;
+            default: callback(...args);
+          }
+        }
+      } finally {
+        if (destroyHooksExist())
+          emitDestroy(asyncId);
+      }
+
+      emitAfter(asyncId);
+    }
+    if (!experimentalTaskOrdering) {
+      runMicrotasks();
+    }
+  } while (!queue.isEmpty() || processPromiseRejections());
+  setHasTickScheduled(false);
+  setHasRejectionToWarn(false);
+}
+
 // `nextTick()` will not enqueue any callback when the process is about to
 // exit since the callback would not have a chance to be executed.
 function nextTick(callback) {