From 6ed198537b567bddff67309f001739a8033dd1be Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Wed, 25 Apr 2018 12:18:32 +0200
Subject: [PATCH 1/6] deps: fix V8_PROMISE_INTERNAL_FIELD_COUNT in
 features.gypi

It should have received a variable. Instead, it was set to a string
that was coerced to a integer later on. This fixes it by correctly
passing through the variable value.
---
 deps/v8/gypfiles/features.gypi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps/v8/gypfiles/features.gypi b/deps/v8/gypfiles/features.gypi
index 69ff763be04ab5..2388ba2729cf3e 100644
--- a/deps/v8/gypfiles/features.gypi
+++ b/deps/v8/gypfiles/features.gypi
@@ -105,7 +105,7 @@
         'defines': ['ENABLE_DISASSEMBLER',],
       }],
       ['v8_promise_internal_field_count!=0', {
-        'defines': ['V8_PROMISE_INTERNAL_FIELD_COUNT','v8_promise_internal_field_count'],
+        'defines': ['V8_PROMISE_INTERNAL_FIELD_COUNT=<(v8_promise_internal_field_count)'],
       }],
       ['v8_enable_gdbjit==1', {
         'defines': ['ENABLE_GDB_JIT_INTERFACE',],

From 1eef8cf35ba78d098a47668e4b9c5983b66c43df Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Mon, 16 Apr 2018 23:35:44 +0200
Subject: [PATCH 2/6] src: exit on gc unhandled rejection

---
 configure                                     |  3 +-
 doc/api/cli.md                                | 25 ++++++
 doc/api/deprecations.md                       |  8 +-
 doc/api/errors.md                             |  6 ++
 doc/api/process.md                            | 51 +++++++----
 lib/internal/bootstrap/node.js                | 22 +++--
 lib/internal/errors.js                        |  2 +
 lib/internal/process/promises.js              | 86 +++++++++++++------
 src/bootstrapper.cc                           | 46 +++++++++-
 src/node.cc                                   | 21 ++++-
 src/node_internals.h                          |  4 +
 test/benchmark/testcfg.py                     |  6 ++
 .../message/promise_always_throw_unhandled.js | 17 ++++
 .../promise_always_throw_unhandled.out        | 15 ++++
 test/message/promise_fast_reject.js           | 18 ++++
 test/message/promise_fast_reject.out          | 24 ++++++
 test/message/promise_unhandled_caught.js      | 20 +++++
 test/message/promise_unhandled_caught.out     | 14 +++
 test/message/promise_unhandled_reject.js      | 53 ++++++++++++
 test/message/promise_unhandled_reject.out     | 61 +++++++++++++
 .../unhandled_promise_trace_warnings.out      |  8 --
 .../test-async-wrap-pop-id-during-load.js     |  4 +-
 test/parallel/test-next-tick-errors.js        |  4 +-
 .../test-process-fatal-exception-tick.js      |  9 +-
 test/parallel/test-promise-unhandled-error.js | 47 ++++++++++
 .../test-promise-unhandled-silent-no-hook.js  | 22 +++++
 .../parallel/test-promise-unhandled-silent.js | 25 ++++++
 .../test-promise-unhandled-warn-to-error.js   | 28 ++++++
 ...est-promises-unhandled-proxy-rejections.js | 38 ++++----
 ...st-promises-unhandled-symbol-rejections.js |  6 --
 ...promises-warning-on-unhandled-rejection.js | 10 +--
 .../test-timers-immediate-queue-throw.js      |  5 +-
 .../test-timers-unref-throw-then-ref.js       |  6 +-
 33 files changed, 604 insertions(+), 110 deletions(-)
 create mode 100644 test/benchmark/testcfg.py
 create mode 100644 test/message/promise_always_throw_unhandled.js
 create mode 100644 test/message/promise_always_throw_unhandled.out
 create mode 100644 test/message/promise_fast_reject.js
 create mode 100644 test/message/promise_fast_reject.out
 create mode 100644 test/message/promise_unhandled_caught.js
 create mode 100644 test/message/promise_unhandled_caught.out
 create mode 100644 test/message/promise_unhandled_reject.js
 create mode 100644 test/message/promise_unhandled_reject.out
 create mode 100644 test/parallel/test-promise-unhandled-error.js
 create mode 100644 test/parallel/test-promise-unhandled-silent-no-hook.js
 create mode 100644 test/parallel/test-promise-unhandled-silent.js
 create mode 100644 test/parallel/test-promise-unhandled-warn-to-error.js

diff --git a/configure b/configure
index c04118e9832b0c..7d13d3c982fc00 100755
--- a/configure
+++ b/configure
@@ -1140,7 +1140,8 @@ def configure_v8(o):
   o['variables']['v8_no_strict_aliasing'] = 1  # Work around compiler bugs.
   o['variables']['v8_optimized_debug'] = 0  # Compile with -O0 in debug builds.
   o['variables']['v8_random_seed'] = 0  # Use a random seed for hash tables.
-  o['variables']['v8_promise_internal_field_count'] = 1 # Add internal field to promises for async hooks.
+  # Add internal field to promises for async hooks and unhandled rejections.
+  o['variables']['v8_promise_internal_field_count'] = 2
   o['variables']['v8_use_snapshot'] = 'false' if options.without_snapshot else 'true'
   o['variables']['v8_trace_maps'] = 1 if options.trace_maps else 0
   o['variables']['node_use_v8_platform'] = b(not options.without_v8_platform)
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 637c1cd9050557..c02413e972663d 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -625,6 +625,29 @@ Path to the file used to store the persistent REPL history. The default path is
 `~/.node_repl_history`, which is overridden by this variable. Setting the value
 to an empty string (`''` or `' '`) disables persistent REPL history.
 
+### `NODE_UNHANDLED_REJECTION=state`
+<!-- YAML
+added: REPLACEME
+-->
+
+Setting this environment variable allows fine grained control over the behavior
+of unhandled rejections. This may be set to either one of `SILENT`, `WARN`,
+`ERROR_ON_GC` or `ERROR` while the default behavior without using the
+environment variable is the same as `WARN`. `WARN` reflects the
+[`unhandledRejection hook`][].
+
+Setting the environment variable to `SILENT` prevents unhandled rejection
+warnings from being logged, even if no [`unhandledRejection hook`][] is set.
+
+If set to `ERROR_ON_GC` unhandled rejections that are garbage collected are
+turned into exceptions.
+
+If set to `ERROR` any unhandled rejection is going turn the rejection into an
+exception.
+
+Any rejection that is turned into an exception can be caught by the
+[`uncaughtException hook`][].
+
 ### `OPENSSL_CONF=file`
 <!-- YAML
 added: v6.11.0
@@ -689,6 +712,8 @@ greater than `4` (its current default value). For more information, see the
 [`Buffer`]: buffer.html#buffer_class_buffer
 [`SlowBuffer`]: buffer.html#buffer_class_slowbuffer
 [`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
+[`uncaughtExceotion hook`]: process.html#process_event_uncaughtexception
+[`unhandledRejection hook`]: process.html#process_event_unhandledrejection
 [Chrome DevTools Protocol]: https://chromedevtools.github.io/devtools-protocol/
 [REPL]: repl.html
 [debugger]: debugger.html
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 10ffa49f4d5207..33fc23a7489698 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -205,11 +205,11 @@ See [`Intl.Segmenter`](https://github.com/tc39/proposal-intl-segmenter).
 <a id="DEP0018"></a>
 ### DEP0018: Unhandled promise rejections
 
-Type: Runtime
+Type: End-of-Life
 
-Unhandled promise rejections are deprecated. In the future, promise rejections
-that are not handled will terminate the Node.js process with a non-zero exit
-code.
+Any rejected promise that is unhandled and garbage collected is going to exit
+the process similar to uncaught exceptions. Please make sure to always handle
+all possible rejections.
 
 <a id="DEP0019"></a>
 ### DEP0019: require('.') resolved outside directory
diff --git a/doc/api/errors.md b/doc/api/errors.md
index 34d85d0ceb7934..0efeeeba9f272f 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1158,6 +1158,12 @@ Invalid characters were detected in headers.
 A cursor on a given stream cannot be moved to a specified row without a
 specified column.
 
+<a id="ERR_INVALID_ENV_VALUE"></a>
+### ERR_INVALID_ENV_VALUE
+
+A environment variable value is unknown. Please consultate the documentation and
+make sure to pass in valid values.
+
 <a id="ERR_INVALID_FD"></a>
 ### ERR_INVALID_FD
 
diff --git a/doc/api/process.md b/doc/api/process.md
index 34f7eb6505a1f0..a78ef0118b06e4 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -147,8 +147,19 @@ most convenient for scripts).
 ### Event: 'uncaughtException'
 <!-- YAML
 added: v0.1.18
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/20097
+    description: Garbage collected unhandled rejections will now also trigger an
+                 uncaughtException. The `errorOrigin` argument was added to
+                 distinguish those.
 -->
 
+* `err` {Error} The uncaught exception.
+* `errorOrigin` {string} Indicates if the exception originates from an
+  unhandled rejection or from synchronous errors. Can either be `'FROM_PROMISE'`
+  or `'FROM_ERROR'`.
+
 The `'uncaughtException'` event is emitted when an uncaught JavaScript
 exception bubbles all the way back to the event loop. By default, Node.js
 handles such exceptions by printing the stack trace to `stderr` and exiting
@@ -159,12 +170,13 @@ behavior. You may also change the [`process.exitCode`][] in
 provided exit code, otherwise in the presence of such handler the process will
 exit with 0.
 
-The listener function is called with the `Error` object passed as the only
-argument.
-
 ```js
-process.on('uncaughtException', (err) => {
-  fs.writeSync(1, `Caught exception: ${err}\n`);
+process.on('uncaughtException', (err, errorOrigin) => {
+  fs.writeSync(
+    1,
+    `Caught exception: ${err}\n` +
+    `Exception originated from unhandled rejection: ${errorOrigin}`
+  );
 });
 
 setTimeout(() => {
@@ -216,6 +228,10 @@ changes:
                  a process warning.
 -->
 
+* `reason` {Error|any} The object with which the promise was rejected
+  (typically an [`Error`][] object).
+* `promise` {Promise} The rejected promise.
+
 The `'unhandledRejection'` event is emitted whenever a `Promise` is rejected and
 no error handler is attached to the promise within a turn of the event loop.
 When programming with Promises, exceptions are encapsulated as "rejected
@@ -224,21 +240,15 @@ are propagated through a `Promise` chain. The `'unhandledRejection'` event is
 useful for detecting and keeping track of promises that were rejected whose
 rejections have not yet been handled.
 
-The listener function is called with the following arguments:
-
-* `reason` {Error|any} The object with which the promise was rejected
-  (typically an [`Error`][] object).
-* `p` the `Promise` that was rejected.
-
 ```js
-process.on('unhandledRejection', (reason, p) => {
-  console.log('Unhandled Rejection at:', p, 'reason:', reason);
-  // application specific logging, throwing an error, or other logic here
+process.on('unhandledRejection', (reason, promise) => {
+  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
+  // Application specific logging, throwing an error, or other logic here
 });
 
 somePromise.then((res) => {
-  return reportToUser(JSON.pasre(res)); // note the typo (`pasre`)
-}); // no `.catch()` or `.then()`
+  return reportToUser(JSON.pasre(res)); // Note the typo (`pasre`)
+}); // No `.catch()` or `.then()`
 ```
 
 The following will also trigger the `'unhandledRejection'` event to be
@@ -251,7 +261,7 @@ function SomeResource() {
 }
 
 const resource = new SomeResource();
-// no .catch or .then on resource.loaded for at least a turn
+// No .catch or .then on resource.loaded for at least a turn
 ```
 
 In this example case, it is possible to track the rejection as a developer error
@@ -259,7 +269,11 @@ as would typically be the case for other `'unhandledRejection'` events. To
 address such failures, a non-operational
 [`.catch(() => { })`][`promise.catch()`] handler may be attached to
 `resource.loaded`, which would prevent the `'unhandledRejection'` event from
-being emitted. Alternatively, the [`'rejectionHandled'`][] event may be used.
+being emitted.
+
+In case a rejected promise is garbage collected without ever having a
+[`.catch(() => { })`][`promise.catch()`] handler attached, it will trigger an
+`uncaughtException` just as any other uncaught JavaScript exception.
 
 ### Event: 'warning'
 <!-- YAML
@@ -2089,7 +2103,6 @@ cases:
 [`'exit'`]: #process_event_exit
 [`'finish'`]: stream.html#stream_event_finish
 [`'message'`]: child_process.html#child_process_event_message
-[`'rejectionHandled'`]: #process_event_rejectionhandled
 [`'uncaughtException'`]: #process_event_uncaughtexception
 [`ChildProcess.disconnect()`]: child_process.html#child_process_subprocess_disconnect
 [`subprocess.kill()`]: child_process.html#child_process_subprocess_kill_signal
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 069c8bc9975fa1..6591f989421022 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -518,16 +518,28 @@
       emitAfter
     } = NativeModule.require('internal/async_hooks');
 
-    process._fatalException = function(er) {
+    process._fatalException = function(er, fromPromise) {
+      if (fromPromise) {
+        let env = process.env.NODE_UNHANDLED_REJECTION;
+        if (env) {
+          env = env.toUpperCase();
+          if (env === 'WARN' || env === 'SILENT')
+            return true;
+        } else {
+          // Do not crash by default.
+          return true;
+        }
+      }
       // It's possible that defaultTriggerAsyncId was set for a constructor
       // call that threw and was never cleared. So clear it now.
       clearDefaultTriggerAsyncId();
 
+      const from = fromPromise ? 'FROM_PROMISE' : 'FROM_ERROR';
       if (exceptionHandlerState.captureFn !== null) {
         exceptionHandlerState.captureFn(er);
-      } else if (!process.emit('uncaughtException', er)) {
-        // If someone handled it, then great.  otherwise, die in C++ land
-        // since that means that we'll exit the process, emit the 'exit' event.
+      } else if (!process.emit('uncaughtException', er, from)) {
+        // If someone handled it, then great. Otherwise, exit the process in C++
+        // land and emit the 'exit' event here.
         try {
           if (!process._exiting) {
             process._exiting = true;
@@ -541,7 +553,7 @@
           const { kExpandStackSymbol } = NativeModule.require('internal/util');
           if (typeof er[kExpandStackSymbol] === 'function')
             er[kExpandStackSymbol]();
-        } catch (er) {}
+        } catch {}
         return false;
       }
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index cc1e84639eb0eb..7d8d6d090c5fc1 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -665,6 +665,8 @@ E('ERR_INVALID_CHAR',
   }, TypeError);
 E('ERR_INVALID_CURSOR_POS',
   'Cannot set cursor row without setting its column', TypeError);
+E('ERR_INVALID_ENV_VALUE',
+  'The value "%s" for environment variable %s is invalid.', TypeError);
 E('ERR_INVALID_FD',
   '"fd" must be a positive integer: %s', RangeError);
 E('ERR_INVALID_FD_TYPE', 'Unsupported fd type: %s', TypeError);
diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index f54f34b9ae92f4..f8256db72f15f5 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -1,15 +1,44 @@
 'use strict';
 
+const { ERR_INVALID_ENV_VALUE } = require('internal/errors').codes;
+
 const { safeToString } = process.binding('util');
 
 const maybeUnhandledPromises = new WeakMap();
 const pendingUnhandledRejections = [];
 const asyncHandledRejections = [];
+const kFromPromise = true;
 let lastPromiseId = 0;
 
+const kSilent = 0;
+const kWarn = 1;
+const kErrorOnGC = 2;
+const kError = 3;
+
 exports.setup = setupPromises;
 
+function unhandledState() {
+  let env = process.env.NODE_UNHANDLED_REJECTION;
+  if (env) {
+    env = env.toUpperCase();
+    if (env === 'ERROR') {
+      return kError;
+    }
+    if (env === 'SILENT') {
+      return kSilent;
+    }
+    if (env === 'ERROR_ON_GC') {
+      return kErrorOnGC;
+    }
+    if (env !== 'WARN') {
+      throw new ERR_INVALID_ENV_VALUE(env, 'NODE_UNHANDLED_REJECTION');
+    }
+  }
+  return kWarn;
+}
+
 function setupPromises(_setupPromises) {
+  unhandledState();
   _setupPromises(unhandledRejection, handledRejection);
   return emitPromiseRejectionWarnings;
 }
@@ -20,6 +49,7 @@ function unhandledRejection(promise, reason) {
     uid: ++lastPromiseId,
     warned: false
   });
+  // This causes the promise to be referenced at least for one tick.
   pendingUnhandledRejections.push(promise);
   return true;
 }
@@ -51,9 +81,7 @@ function emitWarning(uid, reason) {
     } else {
       process.emitWarning(safeToString(reason), unhandledRejectionErrName);
     }
-  } catch (e) {
-    // ignored
-  }
+  } catch {}
 
   // eslint-disable-next-line no-restricted-syntax
   const warning = new Error(
@@ -67,30 +95,17 @@ function emitWarning(uid, reason) {
     if (reason instanceof Error) {
       warning.stack = reason.stack;
     }
-  } catch (err) {
-    // ignored
-  }
+  } catch {}
   process.emitWarning(warning);
-  emitDeprecationWarning();
-}
-
-let deprecationWarned = false;
-function emitDeprecationWarning() {
-  if (!deprecationWarned) {
-    deprecationWarned = true;
-    process.emitWarning(
-      'Unhandled promise rejections are deprecated. In the future, ' +
-      'promise rejections that are not handled will terminate the ' +
-      'Node.js process with a non-zero exit code.',
-      'DeprecationWarning', 'DEP0018');
-  }
 }
 
 function emitPromiseRejectionWarnings() {
   while (asyncHandledRejections.length > 0) {
-    const { promise, warning } = asyncHandledRejections.shift();
-    if (!process.emit('rejectionHandled', promise)) {
-      process.emitWarning(warning);
+    if (unhandledState() !== kError) {
+      const { promise, warning } = asyncHandledRejections.shift();
+      if (!process.emit('rejectionHandled', promise)) {
+        process.emitWarning(warning);
+      }
     }
   }
 
@@ -102,8 +117,31 @@ function emitPromiseRejectionWarnings() {
     if (promiseInfo !== undefined) {
       promiseInfo.warned = true;
       const { reason, uid } = promiseInfo;
-      if (!process.emit('unhandledRejection', reason, promise)) {
-        emitWarning(uid, reason);
+      const state = unhandledState();
+      if (state === kError) {
+        let err;
+        try {
+          if (reason instanceof Error) {
+            err = reason;
+          } else {
+            // eslint-disable-next-line no-restricted-syntax
+            err = new Error(
+              'Unhandled promise rejection. This error originated either by ' +
+              'throwing inside of an async function without a catch block, ' +
+              'or by rejecting a promise which was not handled with .catch().' +
+              ` The promise rejected with the reason "${safeToString(reason)}".`
+            );
+            err.name = 'UnhandledPromiseRejection';
+          }
+        } catch {}
+        // Throw an error if the user did not handle the exception.
+        if (!process._fatalException(err, kFromPromise)) {
+          throw err;
+        }
+      } else if (!process.emit('unhandledRejection', reason, promise)) {
+        if (state === kWarn || state === kErrorOnGC) {
+          emitWarning(uid, reason);
+        }
       } else {
         hadListeners = true;
       }
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index 720f89c011801e..8dfa99f36e60c0 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -11,15 +11,27 @@ using v8::Array;
 using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
+using v8::Exception;
+using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
+using v8::Message;
 using v8::Object;
 using v8::Promise;
 using v8::PromiseRejectEvent;
 using v8::PromiseRejectMessage;
 using v8::String;
 using v8::Value;
+using v8::WeakCallbackInfo;
+using v8::WeakCallbackType;
+
+enum ExceptionOrigin {
+  kFromPromise = true
+};
+
+// The internal field 0 is used by PromiseHook() in async-wrap.cc.
+static constexpr int kUnhandledPromiseField = 1;
 
 void SetupProcessObject(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -58,6 +70,23 @@ void SetupNextTick(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(ret);
 }
 
+void WeakCallback(
+    const v8::WeakCallbackInfo<Persistent<Promise> >& data) {
+  Environment* env = Environment::GetCurrent(data.GetIsolate());
+  Persistent<Promise>* p = data.GetParameter();
+  p->ClearWeak();
+
+  env->SetImmediate([](Environment* env, void* data) {
+    HandleScope handle_scope(env->isolate());
+    Persistent<Promise>* p = static_cast<Persistent<Promise>*>(data);
+    Local<Promise> promise = p->Get(env->isolate());
+    Local<Value> err = promise->Result();
+    Local<Message> message = Exception::CreateMessage(env->isolate(), err);
+    InternalFatalException(env->isolate(), err, message, kFromPromise);
+    delete p;
+  }, p);
+}
+
 void PromiseRejectCallback(PromiseRejectMessage message) {
   static std::atomic<uint64_t> unhandledRejections{0};
   static std::atomic<uint64_t> rejectionsHandledAfter{0};
@@ -72,13 +101,27 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
 
   if (event == v8::kPromiseRejectWithNoHandler) {
     callback = env->promise_reject_unhandled_function();
-    value = message.GetValue();
 
+    // Call fatalException in case the unhandled promise is garbage collected
+    // without being handled later on.
+    Persistent<Promise>* p = new Persistent<Promise>(env->isolate(), promise);
+    p->SetWeak(p, WeakCallback, WeakCallbackType::kFinalizer);
+    CHECK_EQ(promise->GetAlignedPointerFromInternalField(
+      kUnhandledPromiseField), nullptr);
+    promise->SetAlignedPointerInInternalField(kUnhandledPromiseField, p);
+
+    value = message.GetValue();
     if (value.IsEmpty())
       value = Undefined(isolate);
 
     unhandledRejections++;
   } else if (event == v8::kPromiseHandlerAddedAfterReject) {
+    Persistent<Promise>* p = static_cast<Persistent<Promise>*>(
+        promise->GetAlignedPointerFromInternalField(
+            kUnhandledPromiseField));
+    delete p;
+    promise->SetAlignedPointerInInternalField(
+      kUnhandledPromiseField, nullptr);
     callback = env->promise_reject_handled_function();
     value = Undefined(isolate);
 
@@ -98,7 +141,6 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
                                          Undefined(isolate),
                                          arraysize(args),
                                          args);
-
   if (!ret.IsEmpty() && ret.ToLocalChecked()->IsTrue())
     env->tick_info()->promise_rejections_toggle_on();
 }
diff --git a/src/node.cc b/src/node.cc
index 3597571cdffd4c..20ff4e8ac86b84 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -175,6 +175,10 @@ static node_module* modlist_addon;
 // TODO(addaleax): This should not be global.
 static bool abort_on_uncaught_exception = false;
 
+enum ExceptionOrigin {
+  kFromError = false
+};
+
 // Bit flag used to track security reverts (see node_revert.h)
 unsigned int reverted = 0;
 
@@ -1466,7 +1470,7 @@ static void OnFatalError(const char* location, const char* message) {
 
 NO_RETURN void FatalError(const char* location, const char* message) {
   OnFatalError(location, message);
-  // to suppress compiler warning
+  // To suppress compiler warning.
   ABORT();
 }
 
@@ -1479,10 +1483,16 @@ FatalTryCatch::~FatalTryCatch() {
   }
 }
 
-
 void FatalException(Isolate* isolate,
                     Local<Value> error,
                     Local<Message> message) {
+  InternalFatalException(isolate, error, message, kFromError);
+}
+
+void InternalFatalException(Isolate* isolate,
+                            Local<Value> error,
+                            Local<Message> message,
+                            bool from_promise) {
   HandleScope scope(isolate);
 
   Environment* env = Environment::GetCurrent(isolate);
@@ -1493,7 +1503,7 @@ void FatalException(Isolate* isolate,
 
   if (!fatal_exception_function->IsFunction()) {
     // Failed before the process._fatalException function was added!
-    // this is probably pretty bad.  Nothing to do but report and exit.
+    // this is probably pretty bad. Nothing to do but report and exit.
     ReportException(env, error, message);
     exit(6);
   } else {
@@ -1502,10 +1512,13 @@ void FatalException(Isolate* isolate,
     // Do not call FatalException when _fatalException handler throws
     fatal_try_catch.SetVerbose(false);
 
+    Local<Value> argv[2] = { error,
+                             Boolean::New(env->isolate(), from_promise) };
+
     // This will return true if the JS layer handled it, false otherwise
     Local<Value> caught =
         fatal_exception_function.As<Function>()
-            ->Call(process_object, 1, &error);
+            ->Call(process_object, arraysize(argv), argv);
 
     if (fatal_try_catch.HasTerminated())
       return;
diff --git a/src/node_internals.h b/src/node_internals.h
index edfc00e53f13a7..298fe9022b040d 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -224,6 +224,10 @@ void FatalException(v8::Isolate* isolate,
                     v8::Local<v8::Value> error,
                     v8::Local<v8::Message> message);
 
+void InternalFatalException(v8::Isolate* isolate,
+                            v8::Local<v8::Value> error,
+                            v8::Local<v8::Message> message,
+                            bool from_promise);
 
 void SignalExit(int signo);
 #ifdef __POSIX__
diff --git a/test/benchmark/testcfg.py b/test/benchmark/testcfg.py
new file mode 100644
index 00000000000000..2c2929f610b851
--- /dev/null
+++ b/test/benchmark/testcfg.py
@@ -0,0 +1,6 @@
+import sys, os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+import testpy
+
+def GetConfiguration(context, root):
+  return testpy.SimpleTestConfiguration(context, root, 'benchmark')
diff --git a/test/message/promise_always_throw_unhandled.js b/test/message/promise_always_throw_unhandled.js
new file mode 100644
index 00000000000000..44921afbd7763e
--- /dev/null
+++ b/test/message/promise_always_throw_unhandled.js
@@ -0,0 +1,17 @@
+'use strict';
+
+require('../common');
+
+// Check that the process will exit on the first unhandled rejection in case the
+// environment variable is set to `'ERROR'`.
+
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR';
+
+const ref1 = new Promise(() => {
+  throw new Error('One');
+});
+
+const ref2 = Promise.reject(new Error('Two'));
+
+// Keep the event loop alive to actually detect the unhandled rejection.
+setTimeout(() => console.log(ref1, ref2), 1000);
diff --git a/test/message/promise_always_throw_unhandled.out b/test/message/promise_always_throw_unhandled.out
new file mode 100644
index 00000000000000..94385a1d63e6ce
--- /dev/null
+++ b/test/message/promise_always_throw_unhandled.out
@@ -0,0 +1,15 @@
+*promises.js:*
+          throw err;
+          ^
+
+Error: One
+    at Promise (*promise_always_throw_unhandled.js:*:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_always_throw_unhandled.js:*:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
diff --git a/test/message/promise_fast_reject.js b/test/message/promise_fast_reject.js
new file mode 100644
index 00000000000000..c901b735a74ebc
--- /dev/null
+++ b/test/message/promise_fast_reject.js
@@ -0,0 +1,18 @@
+'use strict';
+
+// Currently we keep a reference of unhandled rejections in JS and that prevents
+// the GC to collect these before the process exits naturally.
+
+const common = require('../common');
+// TODO: Remove when making this the default.
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR_ON_GC';
+
+new Promise(function(res, rej) {
+  throw new Error('One');
+});
+
+Promise.reject(new Error('Two'));
+
+process.on('uncaughtException', common.mustNotCall());
+
+process.on('exit', (code) => process._rawDebug(`Exit code ${code}`));
diff --git a/test/message/promise_fast_reject.out b/test/message/promise_fast_reject.out
new file mode 100644
index 00000000000000..9f566f70839f71
--- /dev/null
+++ b/test/message/promise_fast_reject.out
@@ -0,0 +1,24 @@
+(node:*) UnhandledPromiseRejectionWarning: Error: One
+    at *promise_fast_reject.js:*
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_fast_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+(node:*) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
+(node:*) UnhandledPromiseRejectionWarning: Error: Two
+    at *promise_fast_reject.js:*
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+(node:*) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 2)
+Exit code 0
diff --git a/test/message/promise_unhandled_caught.js b/test/message/promise_unhandled_caught.js
new file mode 100644
index 00000000000000..ff1637a75cacdc
--- /dev/null
+++ b/test/message/promise_unhandled_caught.js
@@ -0,0 +1,20 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+// TODO: Remove when making this the default.
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR_ON_GC';
+
+new Promise(function(res, rej) {
+  throw new Error('Fail');
+});
+
+setTimeout(() => {
+  global.gc();
+}, 1);
+
+process.on('uncaughtException', common.mustCall((err, fromPromise) => {
+  console.log(`Caught ${err.message}; From promise: ${fromPromise}`);
+}));
+
+process.on('exit', (code) => process._rawDebug(`Exit code ${code}`));
diff --git a/test/message/promise_unhandled_caught.out b/test/message/promise_unhandled_caught.out
new file mode 100644
index 00000000000000..5f3f6130bb603c
--- /dev/null
+++ b/test/message/promise_unhandled_caught.out
@@ -0,0 +1,14 @@
+Caught Fail; From promise: FROM_PROMISE
+(node:*) UnhandledPromiseRejectionWarning: Error: Fail
+    at *promise_unhandled_caught.js:*
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_caught.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+(node:*) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
+Exit code 0
diff --git a/test/message/promise_unhandled_reject.js b/test/message/promise_unhandled_reject.js
new file mode 100644
index 00000000000000..f8147ff9f79593
--- /dev/null
+++ b/test/message/promise_unhandled_reject.js
@@ -0,0 +1,53 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+// TODO: Remove when making this the default.
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR_ON_GC';
+
+// Verify that unhandled rejections cause `process.exit` to be called with exit
+// code 1 if they get garbage collected. Any promise that is handled later on
+// should not cause this.
+
+let p1 = new Promise((res, rej) => {
+  throw new Error('One');
+});
+
+// eslint-disable-next-line no-unused-vars
+let p2 = new Promise((res, rej) => {
+  throw new Error('Two');
+});
+
+const p3 = Promise.reject(new Error('Three'));
+
+global.gc();
+
+process.nextTick(() => {
+  console.log('First GC did not collect it.');
+  global.gc();
+  // Should not trigger an error.
+  p1.catch(() => {});
+  p1 = null;
+  setImmediate(() => {
+    console.log('Second GC did not collect it.');
+    setTimeout(() => {
+      // Should still trigger a warning.
+      p3.catch(() => {});
+    }, 1000);
+    global.gc();
+    setImmediate(() => {
+      console.log('Third GC did not collect it.');
+      // Free the reference and exit on GC
+      p2 = null;
+      // Trigger a fatal exception on setImmediate
+      global.gc();
+      setImmediate(() => {
+        console.log('Should not be reached');
+      });
+    });
+  });
+});
+
+process.on('unhandledRejection', common.mustCall(console.log, 2));
+
+process.on('exit', (code) => process._rawDebug(`Exit code ${code}`));
diff --git a/test/message/promise_unhandled_reject.out b/test/message/promise_unhandled_reject.out
new file mode 100644
index 00000000000000..5773fc142114f0
--- /dev/null
+++ b/test/message/promise_unhandled_reject.out
@@ -0,0 +1,61 @@
+First GC did not collect it.
+Error: Two
+    at Promise (*promise_unhandled_reject.js:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+  <rejected> Error: Two
+    at Promise (*promise_unhandled_reject.js:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+Error: Three
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+  <rejected> Error: Three
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+Second GC did not collect it.
+Third GC did not collect it.
+Exit code 1
+undefined:0
+
+
+
+Error: Two
+    at Promise (*promise_unhandled_reject.js:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
diff --git a/test/message/unhandled_promise_trace_warnings.out b/test/message/unhandled_promise_trace_warnings.out
index bb51f663823856..f134467ddc6a59 100644
--- a/test/message/unhandled_promise_trace_warnings.out
+++ b/test/message/unhandled_promise_trace_warnings.out
@@ -24,14 +24,6 @@
     at *
     at *
     at *
-(node:*) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.
-    at *
-    at *
-    at *
-    at *
-    at *
-    at *
-    at *
 (node:*) PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 1)
     at handledRejection (internal/process/promises.js:*)
     at Promise.then *
diff --git a/test/parallel/test-async-wrap-pop-id-during-load.js b/test/parallel/test-async-wrap-pop-id-during-load.js
index 31d2113eabc163..3e23596dfce596 100644
--- a/test/parallel/test-async-wrap-pop-id-during-load.js
+++ b/test/parallel/test-async-wrap-pop-id-during-load.js
@@ -18,8 +18,8 @@ const ret = spawnSync(
   process.execPath,
   ['--stack_size=75', __filename, 'async']
 );
-assert.strictEqual(ret.status, 0,
-                   `EXIT CODE: ${ret.status}, STDERR:\n${ret.stderr}`);
 const stderr = ret.stderr.toString('utf8', 0, 2048);
+assert.strictEqual(ret.status, 0,
+                   `EXIT CODE: ${ret.status}, STDERR:\n${stderr}`);
 assert.ok(!/async.*hook/i.test(stderr));
 assert.ok(stderr.includes('UnhandledPromiseRejectionWarning: Error'), stderr);
diff --git a/test/parallel/test-next-tick-errors.js b/test/parallel/test-next-tick-errors.js
index acb7c497278429..26fc6de235a6ef 100644
--- a/test/parallel/test-next-tick-errors.js
+++ b/test/parallel/test-next-tick-errors.js
@@ -61,7 +61,9 @@ testNextTickWith('str');
 testNextTickWith({});
 testNextTickWith([]);
 
-process.on('uncaughtException', function() {
+process.on('uncaughtException', function(err, errorOrigin) {
+  assert.strictEqual(errorOrigin, 'FROM_ERROR');
+
   if (!exceptionHandled) {
     exceptionHandled = true;
     order.push('B');
diff --git a/test/parallel/test-process-fatal-exception-tick.js b/test/parallel/test-process-fatal-exception-tick.js
index f22273e01c9db8..fbdef154fd80d8 100644
--- a/test/parallel/test-process-fatal-exception-tick.js
+++ b/test/parallel/test-process-fatal-exception-tick.js
@@ -12,9 +12,12 @@ if (!common.isMainThread)
 
 let stage = 0;
 
-process.once('uncaughtException', common.expectsError({
-  type: Error,
-  message: 'caughtException'
+process.once('uncaughtException', common.mustCall((err, errorOrigin) => {
+  assert.strictEqual(errorOrigin, 'FROM_ERROR');
+  common.expectsError({
+    type: Error,
+    message: 'caughtException'
+  })(err);
 }));
 
 setImmediate(() => {
diff --git a/test/parallel/test-promise-unhandled-error.js b/test/parallel/test-promise-unhandled-error.js
new file mode 100644
index 00000000000000..fe4ced47753728
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-error.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+const Countdown = require('../common/countdown');
+const assert = require('assert');
+
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR';
+
+// Verify that unhandled rejections always trigger uncaught exceptions instead
+// of triggering unhandled rejections.
+
+const err1 = new Error('One');
+const err2 = new Error(
+  'Unhandled promise rejection. This error originated either by throwing ' +
+  'inside of an async function without a catch block, or by rejecting a ' +
+  'promise which was not handled with .catch(). The promise rejected with the' +
+  ' reason "null".'
+);
+err2.name = 'UnhandledPromiseRejection';
+
+const errors = [err1, err2];
+const identical = [true, false];
+
+const ref = new Promise((res, rej) => {
+  throw err1;
+});
+// Explicitly reject `null`.
+Promise.reject(null);
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('unhandledRejection', common.mustNotCall('unhandledRejection'));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+
+const timer = setTimeout(() => console.log(ref), 1000);
+
+const counter = new Countdown(2, () => {
+  clearTimeout(timer);
+});
+
+process.on('uncaughtException', common.mustCall((err, origin) => {
+  counter.dec();
+  assert.strictEqual(origin, 'FROM_PROMISE', err);
+  const knownError = errors.shift();
+  assert.deepStrictEqual(err, knownError);
+  // Check if the errors are reference equal.
+  assert(identical.shift() ? err === knownError : err !== knownError);
+}, 2));
diff --git a/test/parallel/test-promise-unhandled-silent-no-hook.js b/test/parallel/test-promise-unhandled-silent-no-hook.js
new file mode 100644
index 00000000000000..79eabd2c17a1d4
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-silent-no-hook.js
@@ -0,0 +1,22 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+
+process.env.NODE_UNHANDLED_REJECTION = 'SILENT';
+
+// Verify that ignoring unhandled rejection works fine and that no warning is
+// logged even though there is no unhandledRejection hook attached.
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+Promise.reject('test');
+
+global.gc();
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+
+setTimeout(common.mustCall(), 2);
diff --git a/test/parallel/test-promise-unhandled-silent.js b/test/parallel/test-promise-unhandled-silent.js
new file mode 100644
index 00000000000000..2448cff3c9de7b
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-silent.js
@@ -0,0 +1,25 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+
+process.env.NODE_UNHANDLED_REJECTION = 'SILENT';
+
+// Verify that ignoring unhandled rejection works fine and that no warning is
+// logged.
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+Promise.reject('test');
+
+global.gc();
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+
+process.on('unhandledRejection', common.mustCall(2));
+
+setTimeout(common.mustCall(), 2);
diff --git a/test/parallel/test-promise-unhandled-warn-to-error.js b/test/parallel/test-promise-unhandled-warn-to-error.js
new file mode 100644
index 00000000000000..7113f84c76886f
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-warn-to-error.js
@@ -0,0 +1,28 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+
+process.env.NODE_UNHANDLED_REJECTION = 'SILENT';
+
+// Verify that setting the environment variable in a handler will this change
+// the behavior properly.
+
+Promise.reject('test');
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+global.gc();
+
+process.on('unhandledRejection', () => {
+  process.env.NODE_UNHANDLED_REJECTION = 'ERROR';
+});
+process.on('uncaughtException', common.mustCall((err) => {
+  common.expectsError({
+    message: 'One'
+  })(err);
+}));
+
+setTimeout(common.mustCall(), 2);
diff --git a/test/parallel/test-promises-unhandled-proxy-rejections.js b/test/parallel/test-promises-unhandled-proxy-rejections.js
index 83062e9520165b..5be59b154c3bf8 100644
--- a/test/parallel/test-promises-unhandled-proxy-rejections.js
+++ b/test/parallel/test-promises-unhandled-proxy-rejections.js
@@ -3,39 +3,35 @@ const common = require('../common');
 
 common.disableCrashOnUnhandledRejection();
 
-const expectedDeprecationWarning = ['Unhandled promise rejections are ' +
-                                   'deprecated. In the future, promise ' +
-                                   'rejections that are not handled will ' +
-                                   'terminate the Node.js process with a ' +
-                                   'non-zero exit code.', 'DEP0018'];
 const expectedPromiseWarning = ['Unhandled promise rejection. ' +
   'This error originated either by throwing ' +
   'inside of an async function without a catch ' +
   'block, or by rejecting a promise which was ' +
   'not handled with .catch(). (rejection id: 1)', common.noWarnCode];
 
-function throwErr() {
-  throw new Error('Error from proxy');
+function throwErr(name) {
+  return function() {
+    throw new Error(`Error from ${name}`);
+  };
 }
 
 const thorny = new Proxy({}, {
-  getPrototypeOf: throwErr,
-  setPrototypeOf: throwErr,
-  isExtensible: throwErr,
-  preventExtensions: throwErr,
-  getOwnPropertyDescriptor: throwErr,
-  defineProperty: throwErr,
-  has: throwErr,
-  get: throwErr,
-  set: throwErr,
-  deleteProperty: throwErr,
-  ownKeys: throwErr,
-  apply: throwErr,
-  construct: throwErr
+  getPrototypeOf: throwErr('getPrototypeOf'),
+  setPrototypeOf: throwErr('setPrototypeOf'),
+  isExtensible: throwErr('isExtensible'),
+  preventExtensions: throwErr('preventExtensions'),
+  getOwnPropertyDescriptor: throwErr('getOwnPropertyDescriptor'),
+  defineProperty: throwErr('defineProperty'),
+  has: throwErr('has'),
+  get: throwErr('get'),
+  set: throwErr('set'),
+  deleteProperty: throwErr('deleteProperty'),
+  ownKeys: throwErr('ownKeys'),
+  apply: throwErr('apply'),
+  construct: throwErr('construct')
 });
 
 common.expectWarning({
-  DeprecationWarning: expectedDeprecationWarning,
   UnhandledPromiseRejectionWarning: expectedPromiseWarning,
 });
 
diff --git a/test/parallel/test-promises-unhandled-symbol-rejections.js b/test/parallel/test-promises-unhandled-symbol-rejections.js
index 2102de81918bd7..c8fc81833b2b5b 100644
--- a/test/parallel/test-promises-unhandled-symbol-rejections.js
+++ b/test/parallel/test-promises-unhandled-symbol-rejections.js
@@ -4,11 +4,6 @@ const common = require('../common');
 common.disableCrashOnUnhandledRejection();
 
 const expectedValueWarning = ['Symbol()', common.noWarnCode];
-const expectedDeprecationWarning = ['Unhandled promise rejections are ' +
-                                   'deprecated. In the future, promise ' +
-                                   'rejections that are not handled will ' +
-                                   'terminate the Node.js process with a ' +
-                                   'non-zero exit code.', 'DEP0018'];
 const expectedPromiseWarning = ['Unhandled promise rejection. ' +
   'This error originated either by throwing ' +
   'inside of an async function without a catch ' +
@@ -16,7 +11,6 @@ const expectedPromiseWarning = ['Unhandled promise rejection. ' +
   'not handled with .catch(). (rejection id: 1)', common.noWarnCode];
 
 common.expectWarning({
-  DeprecationWarning: expectedDeprecationWarning,
   UnhandledPromiseRejectionWarning: [
     expectedPromiseWarning,
     expectedValueWarning
diff --git a/test/parallel/test-promises-warning-on-unhandled-rejection.js b/test/parallel/test-promises-warning-on-unhandled-rejection.js
index ba420157e72bbd..f16afc8678f122 100644
--- a/test/parallel/test-promises-warning-on-unhandled-rejection.js
+++ b/test/parallel/test-promises-warning-on-unhandled-rejection.js
@@ -27,14 +27,10 @@ process.on('warning', common.mustCall((warning) => {
       );
       break;
     case 2:
-      // One time deprecation warning, first unhandled rejection
-      assert.strictEqual(warning.name, 'DeprecationWarning');
-      break;
-    case 3:
       // Number rejection error displayed. Note it's been stringified
       assert.strictEqual(warning.message, '42');
       break;
-    case 4:
+    case 3:
       // Unhandled rejection warning (won't be handled next tick)
       assert.strictEqual(warning.name, 'UnhandledPromiseRejectionWarning');
       assert(
@@ -43,13 +39,13 @@ process.on('warning', common.mustCall((warning) => {
         'but did not. Had "' + warning.message + '" instead.'
       );
       break;
-    case 5:
+    case 4:
       // Rejection handled asynchronously.
       assert.strictEqual(warning.name, 'PromiseRejectionHandledWarning');
       assert(/Promise rejection was handled asynchronously/
         .test(warning.message));
   }
-}, 6));
+}, 5));
 
 const p = Promise.reject('This was rejected'); // Reject with a string
 setImmediate(common.mustCall(() => p.catch(() => { })));
diff --git a/test/parallel/test-timers-immediate-queue-throw.js b/test/parallel/test-timers-immediate-queue-throw.js
index 9929b27ab2fea3..c6e4859cf714b8 100644
--- a/test/parallel/test-timers-immediate-queue-throw.js
+++ b/test/parallel/test-timers-immediate-queue-throw.js
@@ -23,7 +23,10 @@ const errObj = {
   message: 'setImmediate Err'
 };
 
-process.once('uncaughtException', common.expectsError(errObj));
+process.once('uncaughtException', common.mustCall((err, errorOrigin) => {
+  assert.strictEqual(errorOrigin, 'FROM_ERROR');
+  common.expectsError(errObj)(err);
+}));
 process.once('uncaughtException', () => assert.strictEqual(stage, 0));
 
 const d1 = domain.create();
diff --git a/test/parallel/test-timers-unref-throw-then-ref.js b/test/parallel/test-timers-unref-throw-then-ref.js
index d3ae27e83551c7..1dd5fdd0ad2786 100644
--- a/test/parallel/test-timers-unref-throw-then-ref.js
+++ b/test/parallel/test-timers-unref-throw-then-ref.js
@@ -2,8 +2,10 @@
 const common = require('../common');
 const assert = require('assert');
 
-process.once('uncaughtException', common.expectsError({
-  message: 'Timeout Error'
+process.once('uncaughtException', common.mustCall((err) => {
+  common.expectsError({
+    message: 'Timeout Error'
+  })(err);
 }));
 
 let called = false;

From 46b0c97bca7a25f491552b77116aecb8e0dfc83a Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Sun, 10 Jun 2018 20:12:33 +0100
Subject: [PATCH 3/6] process: stop rejection loop early

This adds a fast path to the unhandledRejections and handledRejections
to actually stop trying to emit something if no hook is attached.
---
 lib/internal/process/promises.js | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index f8256db72f15f5..cdf605872fdf68 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -5,8 +5,8 @@ const { ERR_INVALID_ENV_VALUE } = require('internal/errors').codes;
 const { safeToString } = process.binding('util');
 
 const maybeUnhandledPromises = new WeakMap();
-const pendingUnhandledRejections = [];
-const asyncHandledRejections = [];
+let pendingUnhandledRejections = [];
+let asyncHandledRejections = [];
 const kFromPromise = true;
 let lastPromiseId = 0;
 
@@ -105,6 +105,10 @@ function emitPromiseRejectionWarnings() {
       const { promise, warning } = asyncHandledRejections.shift();
       if (!process.emit('rejectionHandled', promise)) {
         process.emitWarning(warning);
+      } else {
+        // Stop the loop early.
+        asyncHandledRejections = [];
+        break;
       }
     }
   }
@@ -141,6 +145,13 @@ function emitPromiseRejectionWarnings() {
       } else if (!process.emit('unhandledRejection', reason, promise)) {
         if (state === kWarn || state === kErrorOnGC) {
           emitWarning(uid, reason);
+        // Stop the loop as soon as possible. Since the handler might have been
+        // attached in the beginning and then removed again and a new unhandled
+        // rejection might have been added at that former state, only stop if no
+        // new rejections were added.
+        } else if (len === pendingUnhandledRejections.length) {
+          pendingUnhandledRejections = [];
+          break;
         }
       } else {
         hadListeners = true;

From 5218bb2f17e9b57995d3d3e3fc17567d052ce15b Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Sun, 10 Jun 2018 20:13:52 +0100
Subject: [PATCH 4/6] process: do not run extra microtasks

It is not necessary to run the microtasks when an unhandledRejection
hook is attached.
---
 lib/internal/process/promises.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index cdf605872fdf68..03af3e6659d046 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -113,7 +113,6 @@ function emitPromiseRejectionWarnings() {
     }
   }
 
-  let hadListeners = false;
   let len = pendingUnhandledRejections.length;
   while (len--) {
     const promise = pendingUnhandledRejections.shift();
@@ -153,10 +152,8 @@ function emitPromiseRejectionWarnings() {
           pendingUnhandledRejections = [];
           break;
         }
-      } else {
-        hadListeners = true;
       }
     }
   }
-  return hadListeners || pendingUnhandledRejections.length !== 0;
+  return pendingUnhandledRejections.length !== 0;
 }

From 2dfe16a756c77c9b432d1b92f4315ee36b57ae78 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Mon, 11 Jun 2018 03:55:00 +0200
Subject: [PATCH 5/6] fixup: further doc improvements and add todo

fixup: undo deprecation change
---
 doc/api/cli.md                                |  55 +++++-
 doc/api/deprecations.md                       |  14 +-
 doc/api/errors.md                             |   4 +-
 doc/api/process.md                            |   2 +-
 lib/internal/bootstrap/node.js                |  23 +--
 lib/internal/process/promises.js              | 178 +++++++++++-------
 src/bootstrapper.cc                           |   6 +-
 src/node.cc                                   |  24 +--
 test/benchmark/testcfg.py                     |   6 -
 .../promise_always_throw_unhandled.out        |   4 -
 test/message/promise_unhandled_reject.js      |   6 +-
 .../unhandled_promise_trace_warnings.out      |   8 +
 test/parallel/test-promise-unhandled-error.js |  13 +-
 .../test-promise-unhandled-rejection-env.js   |  55 ++++++
 .../test-promise-unhandled-silent-no-hook.js  |   2 +
 ...est-promises-unhandled-proxy-rejections.js |   6 +
 ...st-promises-unhandled-symbol-rejections.js |   6 +
 ...promises-warning-on-unhandled-rejection.js |  10 +-
 ...st-vm-parse-abort-on-uncaught-exception.js |   4 -
 test/pseudo-tty/test-tty-stdout-end.js        |  10 +-
 20 files changed, 297 insertions(+), 139 deletions(-)
 delete mode 100644 test/benchmark/testcfg.py
 create mode 100644 test/parallel/test-promise-unhandled-rejection-env.js

diff --git a/doc/api/cli.md b/doc/api/cli.md
index c02413e972663d..53ed119e721d41 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -277,6 +277,33 @@ Write process warnings to the given file instead of printing to stderr. The
 file will be created if it does not exist, and will be appended to if it does.
 If an error occurs while attempting to write the warning to the file, the
 warning will be written to stderr instead.
+
+### `--unhandled-rejections=mode`
+<!-- YAML
+added: REPLACEME
+-->
+
+See below ..
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 ### `--throw-deprecation`
 <!-- YAML
@@ -632,21 +659,28 @@ added: REPLACEME
 
 Setting this environment variable allows fine grained control over the behavior
 of unhandled rejections. This may be set to either one of `SILENT`, `WARN`,
-`ERROR_ON_GC` or `ERROR` while the default behavior without using the
+`ERROR_ON_GC`, `ERROR` or `STRICT` while the default behavior without using the
 environment variable is the same as `WARN`. `WARN` reflects the
-[`unhandledRejection hook`][].
+[`unhandledRejection hook`][]. The [`unhandledRejection hook`][] functionality
+is not influenced by any of these options.
 
 Setting the environment variable to `SILENT` prevents unhandled rejection
-warnings from being logged, even if no [`unhandledRejection hook`][] is set.
+warnings from being logged, even if no [`unhandledRejection hook`][] is
+attached.
+
+If set to `ERROR_ON_GC` unhandled rejections that are [garbage collected][] are
+raised as uncaught exceptions.
 
-If set to `ERROR_ON_GC` unhandled rejections that are garbage collected are
-turned into exceptions.
+If set to `ERROR` all rejections that are not handled after a single
+`nextTick()` has passed are raised as uncaught exception.
 
-If set to `ERROR` any unhandled rejection is going turn the rejection into an
-exception.
+If set to `STRICT` all rejections that are not handled synchronous are raised as
+uncaught exception.
 
-Any rejection that is turned into an exception can be caught by the
-[`uncaughtException hook`][].
+Any rejection that is raised as exception can be caught by the
+[`uncaughtException hook`][]. Handling promises can be done lazily by adding a
+catch handler to the promise chain after the promise was already potentially
+rejected.
 
 ### `OPENSSL_CONF=file`
 <!-- YAML
@@ -712,11 +746,12 @@ greater than `4` (its current default value). For more information, see the
 [`Buffer`]: buffer.html#buffer_class_buffer
 [`SlowBuffer`]: buffer.html#buffer_class_slowbuffer
 [`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
-[`uncaughtExceotion hook`]: process.html#process_event_uncaughtexception
+[`uncaughtException hook`]: process.html#process_event_uncaughtexception
 [`unhandledRejection hook`]: process.html#process_event_unhandledrejection
 [Chrome DevTools Protocol]: https://chromedevtools.github.io/devtools-protocol/
 [REPL]: repl.html
 [debugger]: debugger.html
 [emit_warning]: process.html#process_process_emitwarning_warning_type_code_ctor
 [experimental ECMAScript Module]: esm.html#esm_loader_hooks
+[garbage collected]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management#Garbage_collection
 [libuv threadpool documentation]: http://docs.libuv.org/en/latest/threadpool.html
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 33fc23a7489698..1b739c3dcb4262 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -205,11 +205,11 @@ See [`Intl.Segmenter`](https://github.com/tc39/proposal-intl-segmenter).
 <a id="DEP0018"></a>
 ### DEP0018: Unhandled promise rejections
 
-Type: End-of-Life
+Type: Runtime
 
-Any rejected promise that is unhandled and garbage collected is going to exit
-the process similar to uncaught exceptions. Please make sure to always handle
-all possible rejections.
+Unhandled promise rejections are deprecated. In the future, promise rejections
+that are not handled will terminate the Node.js process with a non-zero exit
+code.
 
 <a id="DEP0019"></a>
 ### DEP0019: require('.') resolved outside directory
@@ -1057,16 +1057,16 @@ future release.
 [`Buffer.isBuffer()`]: buffer.html#buffer_class_method_buffer_isbuffer_obj
 [`Cipher`]: crypto.html#crypto_class_cipher
 [`Decipher`]: crypto.html#crypto_class_decipher
-[`assert`]: assert.html
-[`clearInterval()`]: timers.html#timers_clearinterval_timeout
-[`clearTimeout()`]: timers.html#timers_cleartimeout_timeout
 [`EventEmitter.listenerCount(emitter, eventName)`]: events.html#events_eventemitter_listenercount_emitter_eventname
 [`Server.connections`]: net.html#net_server_connections
 [`Server.getConnections()`]: net.html#net_server_getconnections_callback
 [`Server.listen({fd: <number>})`]: net.html#net_server_listen_handle_backlog_callback
 [`SlowBuffer`]: buffer.html#buffer_class_slowbuffer
+[`assert`]: assert.html
 [`asyncResource.runInAsyncScope()`]: async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args
 [`child_process`]: child_process.html
+[`clearInterval()`]: timers.html#timers_clearinterval_timeout
+[`clearTimeout()`]: timers.html#timers_cleartimeout_timeout
 [`console.error()`]: console.html#console_console_error_data_args
 [`console.log()`]: console.html#console_console_log_data_args
 [`crypto.createCipher()`]: crypto.html#crypto_crypto_createcipher_algorithm_password_options
diff --git a/doc/api/errors.md b/doc/api/errors.md
index 0efeeeba9f272f..e8dad8d264732f 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1161,8 +1161,8 @@ specified column.
 <a id="ERR_INVALID_ENV_VALUE"></a>
 ### ERR_INVALID_ENV_VALUE
 
-A environment variable value is unknown. Please consultate the documentation and
-make sure to pass in valid values.
+An environment variable value which is unrecognized. Please consult the
+documentation and make sure to pass in valid values.
 
 <a id="ERR_INVALID_FD"></a>
 ### ERR_INVALID_FD
diff --git a/doc/api/process.md b/doc/api/process.md
index a78ef0118b06e4..ed9a3a079a63b4 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -273,7 +273,7 @@ being emitted.
 
 In case a rejected promise is garbage collected without ever having a
 [`.catch(() => { })`][`promise.catch()`] handler attached, it will trigger an
-`uncaughtException` just as any other uncaught JavaScript exception.
+`uncaughtException` like all other uncaught JavaScript exceptions.
 
 ### Event: 'warning'
 <!-- YAML
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 6591f989421022..e27bf220d98751 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -518,17 +518,14 @@
       emitAfter
     } = NativeModule.require('internal/async_hooks');
 
-    process._fatalException = function(er, fromPromise) {
-      if (fromPromise) {
-        let env = process.env.NODE_UNHANDLED_REJECTION;
-        if (env) {
-          env = env.toUpperCase();
-          if (env === 'WARN' || env === 'SILENT')
-            return true;
-        } else {
-          // Do not crash by default.
-          return true;
-        }
+    const {
+      unhandledState,
+      states
+    } = NativeModule.require('internal/process/promises');
+
+    process._fatalException = function(er, fromPromise = false) {
+      if (fromPromise && unhandledState() <= states.WARN) {
+        return true;
       }
       // It's possible that defaultTriggerAsyncId was set for a constructor
       // call that threw and was never cleared. So clear it now.
@@ -538,8 +535,8 @@
       if (exceptionHandlerState.captureFn !== null) {
         exceptionHandlerState.captureFn(er);
       } else if (!process.emit('uncaughtException', er, from)) {
-        // If someone handled it, then great. Otherwise, exit the process in C++
-        // land and emit the 'exit' event here.
+        // If someone handled it, then great.  otherwise, die in C++ land
+        // since that means that we'll exit the process, emit the 'exit' event.
         try {
           if (!process._exiting) {
             process._exiting = true;
diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index 03af3e6659d046..617cafac25d5da 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -2,42 +2,48 @@
 
 const { ERR_INVALID_ENV_VALUE } = require('internal/errors').codes;
 
+// TODO: Do not add stack traces to the here created errors as they are
+// meaningless. That improves the performance in error cases.
+// TODO: Make the error names non-enumerable.
+
 const { safeToString } = process.binding('util');
 
 const maybeUnhandledPromises = new WeakMap();
+
 let pendingUnhandledRejections = [];
 let asyncHandledRejections = [];
-const kFromPromise = true;
 let lastPromiseId = 0;
 
-const kSilent = 0;
-const kWarn = 1;
-const kErrorOnGC = 2;
-const kError = 3;
-
-exports.setup = setupPromises;
+const kFromPromise = true;
+const kFromError = false;
+const states = {
+  SILENT: 0,
+  WARN: 1,
+  ERROR_ON_GC: 2,
+  ERROR: 3,
+};
 
 function unhandledState() {
   let env = process.env.NODE_UNHANDLED_REJECTION;
   if (env) {
     env = env.toUpperCase();
-    if (env === 'ERROR') {
-      return kError;
-    }
-    if (env === 'SILENT') {
-      return kSilent;
-    }
-    if (env === 'ERROR_ON_GC') {
-      return kErrorOnGC;
-    }
-    if (env !== 'WARN') {
-      throw new ERR_INVALID_ENV_VALUE(env, 'NODE_UNHANDLED_REJECTION');
+    if (states[env] !== undefined) {
+      return states[env];
     }
+    // Raise an exception to indicate the faulty environment variable value.
+    const err = new ERR_INVALID_ENV_VALUE(env, 'NODE_UNHANDLED_REJECTION');
+    fatalException(err, kFromError);
+    // Remove the faulty environment variable to make sure everything works fine
+    // afterwards if the error is handled by the user and the user decided to
+    // continue running the application.
+    delete process.env.NODE_UNHANDLED_REJECTION;
   }
-  return kWarn;
+  return states.WARN;
 }
 
 function setupPromises(_setupPromises) {
+  // Verify while startup that a possible environment variable has a valid
+  // value.
   unhandledState();
   _setupPromises(unhandledRejection, handledRejection);
   return emitPromiseRejectionWarnings;
@@ -82,7 +88,8 @@ function emitWarning(uid, reason) {
       process.emitWarning(safeToString(reason), unhandledRejectionErrName);
     }
   } catch {}
-
+  // TODO: Reword the error message. It partially duplicates the error name.
+  // TODO: Add a code properly to the error.
   // eslint-disable-next-line no-restricted-syntax
   const warning = new Error(
     'Unhandled promise rejection. This error originated either by ' +
@@ -97,19 +104,33 @@ function emitWarning(uid, reason) {
     }
   } catch {}
   process.emitWarning(warning);
+  // Only emit the deprecation notice in case the user did not opt into using
+  // the environment variable / flag.
+  if (!process.env.NODE_UNHANDLED_REJECTION) {
+    emitDeprecationWarning();
+  }
+}
+
+let deprecationWarned = false;
+function emitDeprecationWarning() {
+  if (!deprecationWarned) {
+    deprecationWarned = true;
+    process.emitWarning(
+      'Unhandled promise rejections are deprecated. In the future, ' +
+      'promise rejections that are not handled will terminate the ' +
+      'Node.js process with a non-zero exit code.',
+      'DeprecationWarning', 'DEP0018');
+  }
 }
 
 function emitPromiseRejectionWarnings() {
   while (asyncHandledRejections.length > 0) {
-    if (unhandledState() !== kError) {
-      const { promise, warning } = asyncHandledRejections.shift();
-      if (!process.emit('rejectionHandled', promise)) {
-        process.emitWarning(warning);
-      } else {
-        // Stop the loop early.
-        asyncHandledRejections = [];
-        break;
-      }
+    const { promise, warning } = asyncHandledRejections.shift();
+    if (!process.emit('rejectionHandled', promise)) {
+      process.emitWarning(warning);
+    } else {
+      // Stop the loop early.
+      asyncHandledRejections = [];
     }
   }
 
@@ -117,43 +138,72 @@ function emitPromiseRejectionWarnings() {
   while (len--) {
     const promise = pendingUnhandledRejections.shift();
     const promiseInfo = maybeUnhandledPromises.get(promise);
-    if (promiseInfo !== undefined) {
-      promiseInfo.warned = true;
-      const { reason, uid } = promiseInfo;
-      const state = unhandledState();
-      if (state === kError) {
-        let err;
-        try {
-          if (reason instanceof Error) {
-            err = reason;
-          } else {
-            // eslint-disable-next-line no-restricted-syntax
-            err = new Error(
-              'Unhandled promise rejection. This error originated either by ' +
-              'throwing inside of an async function without a catch block, ' +
-              'or by rejecting a promise which was not handled with .catch().' +
-              ` The promise rejected with the reason "${safeToString(reason)}".`
-            );
-            err.name = 'UnhandledPromiseRejection';
-          }
-        } catch {}
-        // Throw an error if the user did not handle the exception.
-        if (!process._fatalException(err, kFromPromise)) {
-          throw err;
-        }
-      } else if (!process.emit('unhandledRejection', reason, promise)) {
-        if (state === kWarn || state === kErrorOnGC) {
-          emitWarning(uid, reason);
-        // Stop the loop as soon as possible. Since the handler might have been
-        // attached in the beginning and then removed again and a new unhandled
-        // rejection might have been added at that former state, only stop if no
-        // new rejections were added.
-        } else if (len === pendingUnhandledRejections.length) {
-          pendingUnhandledRejections = [];
-          break;
-        }
+    if (promiseInfo === undefined) {
+      continue;
+    }
+    promiseInfo.warned = true;
+    const { reason, uid } = promiseInfo;
+    const state = unhandledState();
+    if (state === states.ERROR) {
+      fatalException(reason, kFromPromise);
+    }
+    if (!process.emit('unhandledRejection', reason, promise)) {
+      if (state === states.WARN || state === states.ERROR_ON_GC) {
+        emitWarning(uid, reason);
+      // Stop the loop as soon as possible. Since the handler might have been
+      // attached in the beginning and then removed again and a new unhandled
+      // rejection might have been added at that former state, only stop if no
+      // new rejections were added.
+      } else if (len === pendingUnhandledRejections.length &&
+          state < states.ERROR) {
+        pendingUnhandledRejections = [];
+        break;
       }
     }
   }
   return pendingUnhandledRejections.length !== 0;
 }
+
+function createError(name, message) {
+  // Reset the stack to prevent any overhead.
+  const tmp = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
+  // eslint-disable-next-line no-restricted-syntax
+  const err = new Error(message);
+  Error.stackTraceLimit = tmp;
+  Object.defineProperty(err, 'name', {
+    value: name,
+    writable: true,
+    configurable: true,
+  });
+  return err;
+}
+
+function fatalException(reason, fromPromise) {
+  let err;
+  if (reason instanceof Error) {
+    err = reason;
+  } else {
+    err = createError(
+      'UnhandledPromiseRejection',
+      'This error originated either by ' +
+        'throwing inside of an async function without a catch block, ' +
+        'or by rejecting a promise which was not handled with .catch().' +
+        ` The promise rejected with the reason "${safeToString(reason)}".`
+    );
+  }
+  // Throw an error if the user did not handle the exception.
+  if (!process._fatalException(err, fromPromise)) {
+    process._rawDebug(err.stack);
+    if (process.binding('config').shouldAbortOnUncaughtException) {
+      process.abort();
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  setup: setupPromises,
+  unhandledState,
+  states,
+};
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index 8dfa99f36e60c0..b2738aa80d57c1 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -9,9 +9,9 @@ namespace node {
 
 using v8::Array;
 using v8::Context;
+using v8::Exception;
 using v8::Function;
 using v8::FunctionCallbackInfo;
-using v8::Exception;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
@@ -26,9 +26,7 @@ using v8::Value;
 using v8::WeakCallbackInfo;
 using v8::WeakCallbackType;
 
-enum ExceptionOrigin {
-  kFromPromise = true
-};
+static constexpr bool kFromPromise = true;
 
 // The internal field 0 is used by PromiseHook() in async-wrap.cc.
 static constexpr int kUnhandledPromiseField = 1;
diff --git a/src/node.cc b/src/node.cc
index 20ff4e8ac86b84..d6b50291c90b00 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -175,9 +175,7 @@ static node_module* modlist_addon;
 // TODO(addaleax): This should not be global.
 static bool abort_on_uncaught_exception = false;
 
-enum ExceptionOrigin {
-  kFromError = false
-};
+static constexpr bool kFromError = false;
 
 // Bit flag used to track security reverts (see node_revert.h)
 unsigned int reverted = 0;
@@ -1530,15 +1528,19 @@ void InternalFatalException(Isolate* isolate,
     } else if (caught->IsFalse()) {
       ReportException(env, error, message);
 
-      // fatal_exception_function call before may have set a new exit code ->
-      // read it again, otherwise use default for uncaughtException 1
-      Local<String> exit_code = env->exit_code_string();
-      Local<Value> code;
-      if (!process_object->Get(env->context(), exit_code).ToLocal(&code) ||
-          !code->IsInt32()) {
-        exit(1);
+      if (abort_on_uncaught_exception) {
+        ABORT();
+      } else {
+        // Fatal_exception_function call before may have set a new exit code ->
+        // read it again, otherwise use default for uncaughtException 1
+        Local<String> exit_code = env->exit_code_string();
+        Local<Value> code;
+        if (!process_object->Get(env->context(), exit_code).ToLocal(&code) ||
+            !code->IsInt32()) {
+          exit(1);
+        }
+        exit(code.As<v8::Int32>()->Value());
       }
-      exit(code.As<v8::Int32>()->Value());
     }
   }
 }
diff --git a/test/benchmark/testcfg.py b/test/benchmark/testcfg.py
deleted file mode 100644
index 2c2929f610b851..00000000000000
--- a/test/benchmark/testcfg.py
+++ /dev/null
@@ -1,6 +0,0 @@
-import sys, os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-import testpy
-
-def GetConfiguration(context, root):
-  return testpy.SimpleTestConfiguration(context, root, 'benchmark')
diff --git a/test/message/promise_always_throw_unhandled.out b/test/message/promise_always_throw_unhandled.out
index 94385a1d63e6ce..2b51c02b8f76ba 100644
--- a/test/message/promise_always_throw_unhandled.out
+++ b/test/message/promise_always_throw_unhandled.out
@@ -1,7 +1,3 @@
-*promises.js:*
-          throw err;
-          ^
-
 Error: One
     at Promise (*promise_always_throw_unhandled.js:*:*)
     at new Promise (<anonymous>)
diff --git a/test/message/promise_unhandled_reject.js b/test/message/promise_unhandled_reject.js
index f8147ff9f79593..b6abe41aa18988 100644
--- a/test/message/promise_unhandled_reject.js
+++ b/test/message/promise_unhandled_reject.js
@@ -9,12 +9,12 @@ process.env.NODE_UNHANDLED_REJECTION = 'ERROR_ON_GC';
 // code 1 if they get garbage collected. Any promise that is handled later on
 // should not cause this.
 
-let p1 = new Promise((res, rej) => {
+let p1 = new Promise(() => {
   throw new Error('One');
 });
 
 // eslint-disable-next-line no-unused-vars
-let p2 = new Promise((res, rej) => {
+let p2 = new Promise(() => {
   throw new Error('Two');
 });
 
@@ -33,6 +33,8 @@ process.nextTick(() => {
     setTimeout(() => {
       // Should still trigger a warning.
       p3.catch(() => {});
+      // Keep a hard reference to p2.
+      console.log(p2);
     }, 1000);
     global.gc();
     setImmediate(() => {
diff --git a/test/message/unhandled_promise_trace_warnings.out b/test/message/unhandled_promise_trace_warnings.out
index f134467ddc6a59..bb51f663823856 100644
--- a/test/message/unhandled_promise_trace_warnings.out
+++ b/test/message/unhandled_promise_trace_warnings.out
@@ -24,6 +24,14 @@
     at *
     at *
     at *
+(node:*) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
 (node:*) PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 1)
     at handledRejection (internal/process/promises.js:*)
     at Promise.then *
diff --git a/test/parallel/test-promise-unhandled-error.js b/test/parallel/test-promise-unhandled-error.js
index fe4ced47753728..6c07c00ee6b34e 100644
--- a/test/parallel/test-promise-unhandled-error.js
+++ b/test/parallel/test-promise-unhandled-error.js
@@ -11,25 +11,30 @@ process.env.NODE_UNHANDLED_REJECTION = 'ERROR';
 
 const err1 = new Error('One');
 const err2 = new Error(
-  'Unhandled promise rejection. This error originated either by throwing ' +
+  'This error originated either by throwing ' +
   'inside of an async function without a catch block, or by rejecting a ' +
   'promise which was not handled with .catch(). The promise rejected with the' +
   ' reason "null".'
 );
-err2.name = 'UnhandledPromiseRejection';
+Object.defineProperty(err2, 'name', {
+  value: 'UnhandledPromiseRejection',
+  writable: true,
+  configurable: true
+});
 
 const errors = [err1, err2];
 const identical = [true, false];
 
-const ref = new Promise((res, rej) => {
+const ref = new Promise(() => {
   throw err1;
 });
 // Explicitly reject `null`.
 Promise.reject(null);
 
 process.on('warning', common.mustNotCall('warning'));
-process.on('unhandledRejection', common.mustNotCall('unhandledRejection'));
+process.on('unhandledRejection', common.mustCall(2));
 process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+process.on('exit', assert.strictEqual.bind(null, 0));
 
 const timer = setTimeout(() => console.log(ref), 1000);
 
diff --git a/test/parallel/test-promise-unhandled-rejection-env.js b/test/parallel/test-promise-unhandled-rejection-env.js
new file mode 100644
index 00000000000000..f49759e0bf2660
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-rejection-env.js
@@ -0,0 +1,55 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+const env = 'FOO';
+
+if (!common.isWindows) {
+  // Verify that a faulty environment variable throws on bootstrapping.
+  // Therefore we do not need any special handling for the child process.
+  const child = cp.spawnSync(
+    process.execPath,
+    [`${__filename}`],
+    { env: { NODE_UNHANDLED_REJECTION: env } }
+  );
+
+  assert.strictEqual(child.stdout.toString(), '');
+  assert(child.stderr.includes(
+    `"${env}" for environment variable NODE_UNHANDLED_REJECTION`));
+}
+
+// Verify that a faulty environment variable throws on unhandled rejections.
+// TODO: This should throw immediately instead of detecting the faulty value
+// delayed.
+process.env.NODE_UNHANDLED_REJECTION = env;
+
+process.on('uncaughtException', common.mustCall((err, origin) => {
+  common.expectsError({
+    type: TypeError,
+    code: 'ERR_INVALID_ENV_VALUE',
+    message: 'The value "FOO" for environment variable ' +
+             'NODE_UNHANDLED_REJECTION is invalid.'
+  })(err);
+  assert.strictEqual(origin, 'FROM_ERROR');
+}));
+
+process.on('unhandledRejection', common.mustCall(2));
+
+assert.strictEqual(process.env.NODE_UNHANDLED_REJECTION, env);
+setImmediate(() => {
+  assert.strictEqual(process.env.NODE_UNHANDLED_REJECTION, undefined);
+});
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+Promise.reject('foo');
+
+// Should not do anything as the default is set to warning.
+global.gc();
+
+setTimeout(common.mustCall(), 5);
diff --git a/test/parallel/test-promise-unhandled-silent-no-hook.js b/test/parallel/test-promise-unhandled-silent-no-hook.js
index 79eabd2c17a1d4..de3bf67ce9ca9e 100644
--- a/test/parallel/test-promise-unhandled-silent-no-hook.js
+++ b/test/parallel/test-promise-unhandled-silent-no-hook.js
@@ -2,6 +2,7 @@
 'use strict';
 
 const common = require('../common');
+const assert = require('assert');
 
 process.env.NODE_UNHANDLED_REJECTION = 'SILENT';
 
@@ -18,5 +19,6 @@ global.gc();
 
 process.on('warning', common.mustNotCall('warning'));
 process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+process.on('exit', assert.strictEqual.bind(null, 0));
 
 setTimeout(common.mustCall(), 2);
diff --git a/test/parallel/test-promises-unhandled-proxy-rejections.js b/test/parallel/test-promises-unhandled-proxy-rejections.js
index 5be59b154c3bf8..912a777032e9e1 100644
--- a/test/parallel/test-promises-unhandled-proxy-rejections.js
+++ b/test/parallel/test-promises-unhandled-proxy-rejections.js
@@ -3,6 +3,11 @@ const common = require('../common');
 
 common.disableCrashOnUnhandledRejection();
 
+const expectedDeprecationWarning = ['Unhandled promise rejections are ' +
+                                   'deprecated. In the future, promise ' +
+                                   'rejections that are not handled will ' +
+                                   'terminate the Node.js process with a ' +
+                                   'non-zero exit code.', 'DEP0018'];
 const expectedPromiseWarning = ['Unhandled promise rejection. ' +
   'This error originated either by throwing ' +
   'inside of an async function without a catch ' +
@@ -32,6 +37,7 @@ const thorny = new Proxy({}, {
 });
 
 common.expectWarning({
+  DeprecationWarning: expectedDeprecationWarning,
   UnhandledPromiseRejectionWarning: expectedPromiseWarning,
 });
 
diff --git a/test/parallel/test-promises-unhandled-symbol-rejections.js b/test/parallel/test-promises-unhandled-symbol-rejections.js
index c8fc81833b2b5b..2102de81918bd7 100644
--- a/test/parallel/test-promises-unhandled-symbol-rejections.js
+++ b/test/parallel/test-promises-unhandled-symbol-rejections.js
@@ -4,6 +4,11 @@ const common = require('../common');
 common.disableCrashOnUnhandledRejection();
 
 const expectedValueWarning = ['Symbol()', common.noWarnCode];
+const expectedDeprecationWarning = ['Unhandled promise rejections are ' +
+                                   'deprecated. In the future, promise ' +
+                                   'rejections that are not handled will ' +
+                                   'terminate the Node.js process with a ' +
+                                   'non-zero exit code.', 'DEP0018'];
 const expectedPromiseWarning = ['Unhandled promise rejection. ' +
   'This error originated either by throwing ' +
   'inside of an async function without a catch ' +
@@ -11,6 +16,7 @@ const expectedPromiseWarning = ['Unhandled promise rejection. ' +
   'not handled with .catch(). (rejection id: 1)', common.noWarnCode];
 
 common.expectWarning({
+  DeprecationWarning: expectedDeprecationWarning,
   UnhandledPromiseRejectionWarning: [
     expectedPromiseWarning,
     expectedValueWarning
diff --git a/test/parallel/test-promises-warning-on-unhandled-rejection.js b/test/parallel/test-promises-warning-on-unhandled-rejection.js
index f16afc8678f122..ba420157e72bbd 100644
--- a/test/parallel/test-promises-warning-on-unhandled-rejection.js
+++ b/test/parallel/test-promises-warning-on-unhandled-rejection.js
@@ -27,10 +27,14 @@ process.on('warning', common.mustCall((warning) => {
       );
       break;
     case 2:
+      // One time deprecation warning, first unhandled rejection
+      assert.strictEqual(warning.name, 'DeprecationWarning');
+      break;
+    case 3:
       // Number rejection error displayed. Note it's been stringified
       assert.strictEqual(warning.message, '42');
       break;
-    case 3:
+    case 4:
       // Unhandled rejection warning (won't be handled next tick)
       assert.strictEqual(warning.name, 'UnhandledPromiseRejectionWarning');
       assert(
@@ -39,13 +43,13 @@ process.on('warning', common.mustCall((warning) => {
         'but did not. Had "' + warning.message + '" instead.'
       );
       break;
-    case 4:
+    case 5:
       // Rejection handled asynchronously.
       assert.strictEqual(warning.name, 'PromiseRejectionHandledWarning');
       assert(/Promise rejection was handled asynchronously/
         .test(warning.message));
   }
-}, 5));
+}, 6));
 
 const p = Promise.reject('This was rejected'); // Reject with a string
 setImmediate(common.mustCall(() => p.catch(() => { })));
diff --git a/test/parallel/test-vm-parse-abort-on-uncaught-exception.js b/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
index 36f73ea676e5a5..b4a9949af378a8 100644
--- a/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
+++ b/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
@@ -1,4 +1,3 @@
-// Flags: --abort-on-uncaught-exception
 'use strict';
 require('../common');
 const vm = require('vm');
@@ -7,8 +6,5 @@ const vm = require('vm');
 
 try {
   new vm.Script({ toString() { throw new Error('foo'); } }, {});
-} catch (err) {}
-
-try {
   new vm.Script('[', {});
 } catch (err) {}
diff --git a/test/pseudo-tty/test-tty-stdout-end.js b/test/pseudo-tty/test-tty-stdout-end.js
index 2ec7ca9114db6f..9e72a8118a6803 100644
--- a/test/pseudo-tty/test-tty-stdout-end.js
+++ b/test/pseudo-tty/test-tty-stdout-end.js
@@ -1,10 +1,12 @@
 'use strict';
 const common = require('../common');
 
-process.on('uncaughtException', common.expectsError({
-  code: 'ERR_STDOUT_CLOSE',
-  type: Error,
-  message: 'process.stdout cannot be closed'
+process.on('uncaughtException', common.mustCall((err) => {
+  common.expectsError({
+    code: 'ERR_STDOUT_CLOSE',
+    type: Error,
+    message: 'process.stdout cannot be closed'
+  })(err);
 }));
 
 process.stdout.end();

From 637824fd8641b05c0ba3a211ac9c4b2049ab6967 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Wed, 5 Sep 2018 12:15:12 +0200
Subject: [PATCH 6/6] fixup: address targos comments

---
 doc/api/process.md | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index ed9a3a079a63b4..f47d327dee4e50 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -150,9 +150,7 @@ added: v0.1.18
 changes:
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/20097
-    description: Garbage collected unhandled rejections will now also trigger an
-                 uncaughtException. The `errorOrigin` argument was added to
-                 distinguish those.
+    description: Added the `errorOrigin` argument.
 -->
 
 * `err` {Error} The uncaught exception.
@@ -271,10 +269,6 @@ address such failures, a non-operational
 `resource.loaded`, which would prevent the `'unhandledRejection'` event from
 being emitted.
 
-In case a rejected promise is garbage collected without ever having a
-[`.catch(() => { })`][`promise.catch()`] handler attached, it will trigger an
-`uncaughtException` like all other uncaught JavaScript exceptions.
-
 ### Event: 'warning'
 <!-- YAML
 added: v6.0.0