From f992e364cb436d95961df268b9b559419364be03 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 30 Mar 2021 22:38:01 -0700
Subject: [PATCH] fixup! fixup! event: simplify domain conditions

---
 lib/events.js                                 | 68 +++++++++----------
 .../events_unhandled_error_common_trace.out   |  4 +-
 .../events_unhandled_error_nexttick.out       |  4 +-
 .../events_unhandled_error_sameline.out       |  4 +-
 .../events_unhandled_error_subclass.out       |  4 +-
 5 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/lib/events.js b/lib/events.js
index 91f1667fac37e1..65886bb359ad39 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -335,49 +335,49 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
   } else if (!doError)
     return false;
 
-  const domain = this.domain;
-
   // If there is no 'error' event listener then throw.
   if (doError) {
     let er;
     if (args.length > 0)
       er = args[0];
-    if (domain) {
+    if (!this.domain) {
+      if (er instanceof Error) {
+        try {
+          const capture = {};
+          ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
+          ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
+            value: enhanceStackTrace.bind(this, er, capture),
+            configurable: true
+          });
+        } catch {}
+
+        // Note: The comments on the `throw` lines are intentional, they show
+        // up in Node's output if this results in an unhandled exception.
+        throw er; // Unhandled 'error' event
+      } else {
+        let stringifiedEr;
+        const { inspect } = require('internal/util/inspect');
+        try {
+          stringifiedEr = inspect(er);
+        } catch {
+          stringifiedEr = er;
+        }
+
+        // At least give some kind of context to the user
+        const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
+        err.context = er;
+        throw err; // Unhandled 'error' event
+      }
+    } else {
       if (!er) {
         er = new ERR_UNHANDLED_ERROR();
       }
       if (typeof er === 'object') {
         er.domainEmitter = this;
-        er.domain = domain;
+        er.domain = this.domain;
         er.domainThrown = false;
       }
-      domain.emit('error', er);
-    } else if (er instanceof Error) {
-      try {
-        const capture = {};
-        ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
-        ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
-          value: enhanceStackTrace.bind(this, er, capture),
-          configurable: true
-        });
-      } catch {}
-
-      // Note: The comments on the `throw` lines are intentional, they show
-      // up in Node's output if this results in an unhandled exception.
-      throw er; // Unhandled 'error' event
-    } else {
-      let stringifiedEr;
-      const { inspect } = require('internal/util/inspect');
-      try {
-        stringifiedEr = inspect(er);
-      } catch {
-        stringifiedEr = er;
-      }
-
-      // At least give some kind of context to the user
-      const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
-      err.context = er;
-      throw err; // Unhandled 'error' event
+      this.domain.emit('error', er);
     }
 
     return false;
@@ -389,8 +389,8 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     return false;
 
   let needDomainExit = false;
-  if (domain && this !== process) {
-    domain.enter();
+  if (this.domain && this !== process) {
+    this.domain.enter();
     needDomainExit = true;
   }
 
@@ -421,7 +421,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
   }
 
   if (needDomainExit)
-    domain.exit();
+    this.domain.exit();
 
   return true;
 };
diff --git a/test/message/events_unhandled_error_common_trace.out b/test/message/events_unhandled_error_common_trace.out
index 19e89869ba74fa..566b1f710adf90 100644
--- a/test/message/events_unhandled_error_common_trace.out
+++ b/test/message/events_unhandled_error_common_trace.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error: foo:bar
     at bar (*events_unhandled_error_common_trace.js:*:*)
diff --git a/test/message/events_unhandled_error_nexttick.out b/test/message/events_unhandled_error_nexttick.out
index 3e0d4697504e49..956ffc8a975b1f 100644
--- a/test/message/events_unhandled_error_nexttick.out
+++ b/test/message/events_unhandled_error_nexttick.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error
     at Object.<anonymous> (*events_unhandled_error_nexttick.js:*:*)
diff --git a/test/message/events_unhandled_error_sameline.out b/test/message/events_unhandled_error_sameline.out
index c027275033941d..b55e77bd67019d 100644
--- a/test/message/events_unhandled_error_sameline.out
+++ b/test/message/events_unhandled_error_sameline.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error
     at Object.<anonymous> (*events_unhandled_error_sameline.js:*:*)
diff --git a/test/message/events_unhandled_error_subclass.out b/test/message/events_unhandled_error_subclass.out
index 5b8131970d50d5..a71c0bb9baaae1 100644
--- a/test/message/events_unhandled_error_subclass.out
+++ b/test/message/events_unhandled_error_subclass.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error
     at Object.<anonymous> (*events_unhandled_error_subclass.js:*:*)