src: fix process exit listeners not receiving unsettled tla codes

fix listeners registered via `process.on('exit', ...` not receiving
error code 13 when an unsettled top-level-await is encountered in
the code

Author: dario-piotrowicz

doc/api/process.md

@@ -1893,8 +1893,16 @@ A number which will be the process exit code, when the process either
 exits gracefully, or is exited via [`process.exit()`][] without specifying
 a code.
 
-Specifying a code to [`process.exit(code)`][`process.exit()`] will override any
-previous setting of `process.exitCode`.
+The value of `process.exitCode` can be updated by either setting the value
+directly (e.g. `process.exitCode = 9`), or by specifying a code to
+[`process.exit(code)`][`process.exit()`] (the latter takes
+precedence and will override any previous setting of `process.exitCode`).
+
+The value can also be set implicitly by Node.js when unrecoverable errors occur (e.g.
+such as the encountering of an unsettled top-level await). However explicit
+manipulations of the exit code always take precedence over implicit ones (meaning that
+for example updating `process.exitCode` to `9` guarantees that the program's exit code
+will be `9` regardless on other errors Node.js might encounter).
 
 ## `process.features.cached_builtins`
 

lib/internal/bootstrap/node.js

@@ -108,7 +108,15 @@ process.domain = null;
   ObjectDefineProperty(process, 'exitCode', {
     __proto__: null,
     get() {
-      return exitCode;
+      if (exitCode !== undefined) {
+        return exitCode;
+      }
+
+      if (fields[kHasExitCode] !== 0) {
+        return fields[kExitCode];
+      }
+
+      return undefined;
     },
     set(code) {
       if (code !== null && code !== undefined) {

src/api/hooks.cc

@@ -75,14 +75,14 @@ Maybe<ExitCode> EmitProcessExitInternal(Environment* env) {
   // the exit code wasn't already set, so let's check for unsettled tlas
   if (exit_code == ExitCode::kNoFailure) {
     auto unsettled_tla = env->CheckUnsettledTopLevelAwait();
-
-    exit_code = !unsettled_tla.FromJust()
-         ? ExitCode::kUnsettledTopLevelAwait
-         : ExitCode::kNoFailure;
+    if (!unsettled_tla.FromJust()) {
+      exit_code = ExitCode::kUnsettledTopLevelAwait;
+      env->set_exit_code(exit_code);
+    }
   }
 
-  Local<Integer> exit_code_int = Integer::New(
-      isolate, static_cast<int32_t>(exit_code));
+  Local<Integer> exit_code_int =
+      Integer::New(isolate, static_cast<int32_t>(exit_code));
 
   if (ProcessEmit(env, "exit", exit_code_int).IsEmpty()) {
     return Nothing<ExitCode>();

src/env-inl.h

@@ -341,6 +341,11 @@ inline ExitCode Environment::exit_code(const ExitCode default_code) const {
              : static_cast<ExitCode>(exit_info_[kExitCode]);
 }
 
+inline void Environment::set_exit_code(const ExitCode code) {
+  exit_info_[kExitCode] = static_cast<int>(code);
+  exit_info_[kHasExitCode] = 1;
+}
+
 inline AliasedInt32Array& Environment::exit_info() {
   return exit_info_;
 }

src/env.h

@@ -739,6 +739,8 @@ class Environment final : public MemoryRetainer {
   bool exiting() const;
   inline ExitCode exit_code(const ExitCode default_code) const;
 
+  inline void set_exit_code(const ExitCode code);
+
   // This stores whether the --abort-on-uncaught-exception flag was passed
   // to Node.
   inline bool abort_on_uncaught_exception() const;

test/es-module/test-esm-tla-unfinished.mjs

@@ -174,4 +174,31 @@ describe('ESM: unsettled and rejected promises', { concurrency: !process.env.TES
     assert.strictEqual(stdout, '');
     assert.strictEqual(code, 13);
   });
+
+  describe('with exit listener', () => {
+    it('the process exit event should provide the correct code', async () => {
+      const { code, stdout } = await spawnPromisified(execPath, [
+        fixtures.path('es-modules/tla/unresolved-with-listener.mjs'),
+      ]);
+
+      assert.strictEqual(stdout,
+                         'the exit listener received code: 13\n' +
+                         'process.exitCode inside the exist listener: 13\n'
+      );
+      assert.strictEqual(code, 13);
+    });
+
+    it('should exit for an unsettled TLA promise and respect explicit exit code in process exit event', async () => {
+      const { code, stdout } = await spawnPromisified(execPath, [
+        '--no-warnings',
+        fixtures.path('es-modules/tla/unresolved-withexitcode-and-listener.mjs'),
+      ]);
+
+      assert.strictEqual(stdout,
+                         'the exit listener received code: 42\n' +
+                         'process.exitCode inside the exist listener: 42\n'
+      );
+      assert.strictEqual(code, 42);
+    });
+  });
 });

test/fixtures/es-modules/tla/unresolved-with-listener.mjs

@@ -0,0 +1,6 @@
+process.on('exit', (exitCode) => {
+    console.log(`the exit listener received code: ${exitCode}`);
+    console.log(`process.exitCode inside the exist listener: ${process.exitCode}`);
+})
+
+await new Promise(() => {});

test/fixtures/es-modules/tla/unresolved-withexitcode-and-listener.mjs

@@ -0,0 +1,8 @@
+process.on('exit', (exitCode) => {
+    console.log(`the exit listener received code: ${exitCode}`);
+    console.log(`process.exitCode inside the exist listener: ${process.exitCode}`);
+});
+
+process.exitCode = 42;
+
+await new Promise(() => {});