From 1aaa6b72e775d71927701b56e3186ce007337c2b Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Sun, 7 Apr 2019 15:36:11 +0200
Subject: [PATCH 1/3] test: add known issue

Adding an `uncaughtException` listener in an REPL instance suppresses
errors in the whole application.
Closing the instance won't remove those listeners either.
---
 test/known_issues/known_issues.status         |  1 +
 .../test-repl-uncaught-exception-error.js     | 39 +++++++++++++++++++
 2 files changed, 40 insertions(+)
 create mode 100644 test/known_issues/test-repl-uncaught-exception-error.js

diff --git a/test/known_issues/known_issues.status b/test/known_issues/known_issues.status
index d7e0b546d43ff8..8da183080382f5 100644
--- a/test/known_issues/known_issues.status
+++ b/test/known_issues/known_issues.status
@@ -5,6 +5,7 @@ prefix known_issues
 # sample-test                        : SKIP
 
 [true] # This section applies to all platforms
+test-repl-uncaught-exception-error: SKIP
 
 [$system==win32]
 test-fs-copyfile-respect-permissions: SKIP
diff --git a/test/known_issues/test-repl-uncaught-exception-error.js b/test/known_issues/test-repl-uncaught-exception-error.js
new file mode 100644
index 00000000000000..d496e156640df5
--- /dev/null
+++ b/test/known_issues/test-repl-uncaught-exception-error.js
@@ -0,0 +1,39 @@
+'use strict';
+
+require('../common');
+const ArrayStream = require('../common/arraystream');
+const repl = require('repl');
+
+// Adding an `uncaughtException` listener in an REPL instance suppresses errors
+// in the whole application.
+// Closing the instance won't remove those listeners either.
+
+let accum = '';
+
+const output = new ArrayStream();
+output.write = (data) => accum += data.replace('\r', '');
+
+const r = repl.start({
+  prompt: '',
+  input: new ArrayStream(),
+  output,
+  terminal: false,
+  useColors: false,
+  global: false
+});
+
+r.write(
+  'setTimeout(() => {\n' +
+  '  process.on("uncaughtException", () => console.log("Foo"));\n' +
+  '}, 1);\n'
+);
+
+// Event listeners added to the global `process` won't be removed after
+// closing the REPL instance! Those should be removed again, especially since
+// the REPL's `global` option is set to `false`.
+r.close();
+
+setTimeout(() => {
+  // This should definitely not be silenced!
+  throw new Error('HU');
+}, 2);

From 88306b21d1c9d87cc233a621534017f34dc349e3 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Thu, 17 May 2018 16:25:36 +0200
Subject: [PATCH 2/3] repl: emit uncaughtException

The internal default repl will from now on trigger `uncaughtException`
handlers instead of ignoring them. The regular error output is
suppressed in that case.
---
 doc/api/errors.md                             | 11 ++-
 doc/api/repl.md                               | 34 ++++++++-
 lib/internal/errors.js                        |  1 +
 lib/repl.js                                   | 71 +++++++++++++++----
 .../parallel/test-repl-pretty-custom-stack.js |  3 -
 ...test-repl-uncaught-exception-standalone.js | 33 +++++++++
 test/parallel/test-repl-uncaught-exception.js | 60 ++++++++++++++++
 7 files changed, 194 insertions(+), 19 deletions(-)
 create mode 100644 test/parallel/test-repl-uncaught-exception-standalone.js
 create mode 100644 test/parallel/test-repl-uncaught-exception.js

diff --git a/doc/api/errors.md b/doc/api/errors.md
index 547d1ff8d23609..0f84af35b87e8a 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1308,8 +1308,14 @@ An invalid `options.protocol` was passed.
 <a id="ERR_INVALID_REPL_EVAL_CONFIG"></a>
 ### ERR_INVALID_REPL_EVAL_CONFIG
 
-Both `breakEvalOnSigint` and `eval` options were set in the REPL config, which
-is not supported.
+Both `breakEvalOnSigint` and `eval` options were set in the [`REPL`][] config,
+which is not supported.
+
+<a id="ERR_INVALID_REPL_INPUT"></a>
+### ERR_INVALID_REPL_INPUT
+
+The input can or may not be used in the [`REPL`][]. All prohibited inputs are
+documented in the [`REPL`][]'s documentation.
 
 <a id="ERR_INVALID_RETURN_PROPERTY"></a>
 ### ERR_INVALID_RETURN_PROPERTY
@@ -2293,6 +2299,7 @@ such as `process.stdout.on('data')`.
 [`Class: assert.AssertionError`]: assert.html#assert_class_assert_assertionerror
 [`ERR_INVALID_ARG_TYPE`]: #ERR_INVALID_ARG_TYPE
 [`EventEmitter`]: events.html#events_class_eventemitter
+[`REPL`]: repl.html
 [`Writable`]: stream.html#stream_class_stream_writable
 [`child_process`]: child_process.html
 [`cipher.getAuthTag()`]: crypto.html#crypto_cipher_getauthtag
diff --git a/doc/api/repl.md b/doc/api/repl.md
index cc7f3f96da15d7..10f281a2b673d7 100644
--- a/doc/api/repl.md
+++ b/doc/api/repl.md
@@ -138,16 +138,47 @@ global or scoped variable, the input `fs` will be evaluated on-demand as
 ```
 
 #### Global Uncaught Exceptions
+<!-- YAML
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/20803
+    description: The uncaughtException event is from now on triggered if the
+                 repl is used as standalone program.
+-->
 
 The REPL uses the [`domain`][] module to catch all uncaught exceptions for that
 REPL session.
 
 This use of the [`domain`][] module in the REPL has these side effects:
 
-* Uncaught exceptions do not emit the [`'uncaughtException'`][] event.
+* Uncaught exceptions only emit the [`'uncaughtException'`][] event if the
+  `repl` is used as standalone program. If the `repl` is included anywhere in
+  another application, adding this event synchronous will throw an
+  [`ERR_INVALID_REPL_INPUT`][] error!
 * Trying to use [`process.setUncaughtExceptionCaptureCallback()`][] throws
   an [`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`][] error.
 
+As standalone program:
+
+```js
+process.on('uncaughtException', () => console.log('Uncaught'));
+
+throw new Error('foobar');
+// Uncaught
+```
+
+When used in another application:
+
+```js
+process.on('uncaughtException', () => console.log('Uncaught'));
+// TypeError [ERR_INVALID_REPL_INPUT]: Unhandled exception listeners can not be
+// used in the REPL
+
+throw new Error('foobar');
+// Thrown:
+// Error: foobar
+```
+
 #### Assignment of the `_` (underscore) variable
 <!-- YAML
 changes:
@@ -661,6 +692,7 @@ For an example of running a REPL instance over [curl(1)][], see:
 [`'uncaughtException'`]: process.html#process_event_uncaughtexception
 [`--experimental-repl-await`]: cli.html#cli_experimental_repl_await
 [`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`]: errors.html#errors_err_domain_cannot_set_uncaught_exception_capture
+[`ERR_INVALID_REPL_INPUT`]: errors.html#errors_err_invalid_repl_input
 [`domain`]: domain.html
 [`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
 [`readline.InterfaceCompleter`]: readline.html#readline_use_of_the_completer_function
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index d2bf1999c0933b..0eb3b237795841 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -892,6 +892,7 @@ E('ERR_INVALID_PROTOCOL',
   TypeError);
 E('ERR_INVALID_REPL_EVAL_CONFIG',
   'Cannot specify both "breakEvalOnSigint" and "eval" for REPL', TypeError);
+E('ERR_INVALID_REPL_INPUT', '%s', TypeError);
 E('ERR_INVALID_RETURN_PROPERTY', (input, name, prop, value) => {
   return `Expected a valid ${input} to be returned for the "${prop}" from the` +
          ` "${name}" function but got ${value}.`;
diff --git a/lib/repl.js b/lib/repl.js
index c22d450539d270..f6eec0551a5bb8 100644
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -72,6 +72,7 @@ const {
   ERR_CANNOT_WATCH_SIGINT,
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_REPL_EVAL_CONFIG,
+  ERR_INVALID_REPL_INPUT,
   ERR_SCRIPT_EXECUTION_INTERRUPTED
 } = require('internal/errors').codes;
 const { sendInspectorCommand } = require('internal/util/inspector');
@@ -102,6 +103,20 @@ const replMap = new WeakMap();
 const kBufferedCommandSymbol = Symbol('bufferedCommand');
 const kContextId = Symbol('contextId');
 
+let tmpListeners = [];
+let checkUncaught = false;
+let currentListeners = [];
+
+process.on('newListener', (event, listener) => {
+  if (event === 'uncaughtException' &&
+      checkUncaught &&
+      !currentListeners.includes(listener)) {
+    // Add listener to a temporary list of listeners which should be removed
+    // again.
+    tmpListeners.push(listener);
+  }
+});
+
 try {
   // Hack for require.resolve("./relative") to work properly.
   module.filename = path.resolve('repl');
@@ -268,7 +283,7 @@ function REPLServer(prompt,
       // statement rather than an object literal.  So, we first try
       // to wrap it in parentheses, so that it will be interpreted as
       // an expression.  Note that if the above condition changes,
-      // lib/internal/repl/recoverable.js needs to be changed to match.
+      // lib/internal/repl/utils.js needs to be changed to match.
       code = `(${code.trim()})\n`;
       wrappedCmd = true;
     }
@@ -428,7 +443,6 @@ function REPLServer(prompt,
   }
 
   self.eval = self._domain.bind(eval_);
-
   self._domain.on('error', function debugDomainError(e) {
     debug('domain error');
     let errStack = '';
@@ -465,22 +479,31 @@ function REPLServer(prompt,
       }
     }
 
-    if (errStack === '') {
-      errStack = `Thrown: ${self.writer(e)}\n`;
-    } else {
-      const ln = errStack.endsWith('\n') ? '' : '\n';
-      errStack = `Thrown:\n${errStack}${ln}`;
-    }
-
     if (!self.underscoreErrAssigned) {
       self.lastError = e;
     }
 
     const top = replMap.get(self);
-    top.outputStream.write(errStack);
-    top.clearBufferedCommand();
-    top.lines.level = [];
-    top.displayPrompt();
+    if (options[kStandaloneREPL] &&
+        process.listenerCount('uncaughtException') !== 0) {
+      process.nextTick(() => {
+        process.emit('uncaughtException', e);
+        top.clearBufferedCommand();
+        top.lines.level = [];
+        top.displayPrompt();
+      });
+    } else {
+      if (errStack === '') {
+        errStack = `Thrown: ${self.writer(e)}\n`;
+      } else {
+        const ln = errStack.endsWith('\n') ? '' : '\n';
+        errStack = `Thrown:\n${errStack}${ln}`;
+      }
+      top.outputStream.write(errStack);
+      top.clearBufferedCommand();
+      top.lines.level = [];
+      top.displayPrompt();
+    }
   });
 
   self.resetContext();
@@ -666,10 +689,32 @@ function REPLServer(prompt,
     const evalCmd = self[kBufferedCommandSymbol] + cmd + '\n';
 
     debug('eval %j', evalCmd);
+    if (!options[kStandaloneREPL]) {
+      checkUncaught = true;
+      currentListeners = process.listeners('uncaughtException');
+    }
     self.eval(evalCmd, self.context, 'repl', finish);
 
     function finish(e, ret) {
       debug('finish', e, ret);
+
+      if (tmpListeners.length !== 0) {
+        tmpListeners.forEach((tmp) => {
+          process.removeListener('uncaughtException', tmp);
+        });
+        tmpListeners = [];
+        const err = new ERR_INVALID_REPL_INPUT(
+          'Unhandled exception listeners can not be used in the REPL');
+        self._domain.emit('error', err);
+        if (ret === process) {
+          self.clearBufferedCommand();
+          self.displayPrompt();
+          return;
+        }
+      }
+      currentListeners = [];
+      checkUncaught = false;
+
       _memory.call(self, cmd);
 
       if (e && !self[kBufferedCommandSymbol] && cmd.trim().startsWith('npm ')) {
diff --git a/test/parallel/test-repl-pretty-custom-stack.js b/test/parallel/test-repl-pretty-custom-stack.js
index a37cf04263433d..bdd33240c3bc0a 100644
--- a/test/parallel/test-repl-pretty-custom-stack.js
+++ b/test/parallel/test-repl-pretty-custom-stack.js
@@ -5,7 +5,6 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const repl = require('repl');
 
-
 function run({ command, expected }) {
   let accum = '';
 
@@ -40,8 +39,6 @@ process.on('uncaughtException', (e) => {
   throw e;
 });
 
-process.on('exit', () => (Error.prepareStackTrace = origPrepareStackTrace));
-
 const tests = [
   {
     // test .load for a file that throws
diff --git a/test/parallel/test-repl-uncaught-exception-standalone.js b/test/parallel/test-repl-uncaught-exception-standalone.js
new file mode 100644
index 00000000000000..8da86e119f5290
--- /dev/null
+++ b/test/parallel/test-repl-uncaught-exception-standalone.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const child = cp.spawn(process.execPath, ['-i']);
+let output = '';
+
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', (data) => {
+  output += data;
+});
+
+child.on('exit', common.mustCall(() => {
+  const results = output.replace(/^> /mg, '').split('\n');
+  assert.deepStrictEqual(
+    results,
+    [
+      'Thrown:',
+      'ReferenceError: x is not defined',
+      'short',
+      'undefined',
+      'Foobar',
+      ''
+    ]
+  );
+}));
+
+child.stdin.write('x\n');
+child.stdin.write(
+  'process.on("uncaughtException", () => console.log("Foobar"));' +
+  'console.log("short")\n');
+child.stdin.write('x\n');
+child.stdin.end();
diff --git a/test/parallel/test-repl-uncaught-exception.js b/test/parallel/test-repl-uncaught-exception.js
new file mode 100644
index 00000000000000..3fcc89e03a8581
--- /dev/null
+++ b/test/parallel/test-repl-uncaught-exception.js
@@ -0,0 +1,60 @@
+'use strict';
+require('../common');
+const ArrayStream = require('../common/arraystream');
+const assert = require('assert');
+const repl = require('repl');
+
+let count = 0;
+
+function run({ command, expected }) {
+  let accum = '';
+
+  const output = new ArrayStream();
+  output.write = (data) => accum += data.replace('\r', '');
+
+  const r = repl.start({
+    prompt: '',
+    input: new ArrayStream(),
+    output,
+    terminal: false,
+    useColors: false
+  });
+
+  r.write(`${command}\n`);
+  if (typeof expected === 'string') {
+    assert.strictEqual(accum, expected);
+  } else {
+    assert(expected.test(accum), accum);
+  }
+  r.close();
+  count++;
+}
+
+const tests = [
+  {
+    command: 'x',
+    expected: 'Thrown:\n' +
+              'ReferenceError: x is not defined\n'
+  },
+  {
+    command: 'process.on("uncaughtException", () => console.log("Foobar"));\n',
+    expected: /^Thrown:\nTypeError \[ERR_INVALID_REPL_INPUT]: Unhandled exception/
+  },
+  {
+    command: 'x;\n',
+    expected: 'Thrown:\n' +
+              'ReferenceError: x is not defined\n'
+  },
+  {
+    command: 'process.on("uncaughtException", () => console.log("Foobar"));' +
+             'console.log("Baz");\n',
+    // eslint-disable-next-line node-core/no-unescaped-regexp-dot
+    expected: /^Baz(.|\n)*ERR_INVALID_REPL_INPUT/
+  }
+];
+
+process.on('exit', () => {
+  assert.strictEqual(count, tests.length);
+});
+
+tests.forEach(run);

From f99c8f3a6d2d3fab5489c78a85e15150502ce81a Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Mon, 8 Apr 2019 20:50:45 +0200
Subject: [PATCH 3/3] fixup! test: add known issue

---
 test/known_issues/known_issues.status         |  1 -
 .../test-repl-uncaught-exception-error.js     | 74 ++++++++++++-------
 2 files changed, 48 insertions(+), 27 deletions(-)

diff --git a/test/known_issues/known_issues.status b/test/known_issues/known_issues.status
index 8da183080382f5..d7e0b546d43ff8 100644
--- a/test/known_issues/known_issues.status
+++ b/test/known_issues/known_issues.status
@@ -5,7 +5,6 @@ prefix known_issues
 # sample-test                        : SKIP
 
 [true] # This section applies to all platforms
-test-repl-uncaught-exception-error: SKIP
 
 [$system==win32]
 test-fs-copyfile-respect-permissions: SKIP
diff --git a/test/known_issues/test-repl-uncaught-exception-error.js b/test/known_issues/test-repl-uncaught-exception-error.js
index d496e156640df5..3068270fb85a5a 100644
--- a/test/known_issues/test-repl-uncaught-exception-error.js
+++ b/test/known_issues/test-repl-uncaught-exception-error.js
@@ -1,39 +1,61 @@
 'use strict';
 
 require('../common');
-const ArrayStream = require('../common/arraystream');
-const repl = require('repl');
 
 // Adding an `uncaughtException` listener in an REPL instance suppresses errors
 // in the whole application.
 // Closing the instance won't remove those listeners either.
 
-let accum = '';
+if (process.argv[2] === 'child') {
 
-const output = new ArrayStream();
-output.write = (data) => accum += data.replace('\r', '');
+  const ArrayStream = require('../common/arraystream');
+  const repl = require('repl');
 
-const r = repl.start({
-  prompt: '',
-  input: new ArrayStream(),
-  output,
-  terminal: false,
-  useColors: false,
-  global: false
-});
+  let accum = '';
 
-r.write(
-  'setTimeout(() => {\n' +
-  '  process.on("uncaughtException", () => console.log("Foo"));\n' +
-  '}, 1);\n'
-);
+  const output = new ArrayStream();
+  output.write = (data) => accum += data.replace('\r', '');
+
+  const r = repl.start({
+    prompt: '',
+    input: new ArrayStream(),
+    output,
+    terminal: false,
+    useColors: false,
+    global: false
+  });
+
+  r.write(
+    'setTimeout(() => {\n' +
+    '  process.on("uncaughtException", () => console.log("Foo"));\n' +
+    '}, 1);\n'
+  );
+
+  // Event listeners added to the global `process` won't be removed after
+  // closing the REPL instance! Those should be removed again, especially since
+  // the REPL's `global` option is set to `false`.
+  r.close();
+
+  setTimeout(() => {
+    // This should definitely not be silenced!
+    throw new Error('HU');
+  }, 2);
 
-// Event listeners added to the global `process` won't be removed after
-// closing the REPL instance! Those should be removed again, especially since
-// the REPL's `global` option is set to `false`.
-r.close();
+  setTimeout(() => {
+    console.error('FAILED');
+    process.exit(1);
+  }, 10);
+
+  return;
+}
+
+const cp = require('child_process');
+const assert = require('assert');
+
+const res = cp.spawnSync(
+  process.execPath,
+  [__filename, 'child'],
+  { encoding: 'utf8' }
+);
 
-setTimeout(() => {
-  // This should definitely not be silenced!
-  throw new Error('HU');
-}, 2);
+assert.notStrictEqual(res.stderr, 'FAILED\n');