lib,src: throw on unhanded promise rejections

Refs: nodejs#5292
Refs: nodejs/promises#26
Refs: nodejs#6355
PR-URL: nodejs#6375

Author: Fishrock123

deps/npm/node_modules/request/node_modules/form-data/Readme.md

@@ -304,13 +304,13 @@
 
   function setupProcessFatal() {
 
-    process._fatalException = function(er) {
+    process._fatalException = function(er, fromPromise) {
       var caught;
 
       if (process.domain && process.domain._errorHandler)
         caught = process.domain._errorHandler(er) || caught;
 
-      if (!caught)
+      if (!caught && !fromPromise)
         caught = process.emit('uncaughtException', er);
 
       // If someone handled it, then great.  otherwise, die in C++ land

lib/internal/bootstrap_node.js

@@ -2,88 +2,52 @@
 
 const promiseRejectEvent = process._promiseRejectEvent;
 const hasBeenNotifiedProperty = new WeakMap();
-const promiseToGuidProperty = new WeakMap();
 const pendingUnhandledRejections = [];
-let lastPromiseId = 1;
 
 exports.setup = setupPromises;
 
-function getAsynchronousRejectionWarningObject(uid) {
-  return new Error('Promise rejection was handled ' +
-                   `asynchronously (rejection id: ${uid})`);
-}
-
 function setupPromises(scheduleMicrotasks) {
+  const promiseInternals = {};
+
   process._setupPromises(function(event, promise, reason) {
     if (event === promiseRejectEvent.unhandled)
       unhandledRejection(promise, reason);
     else if (event === promiseRejectEvent.handled)
       rejectionHandled(promise);
     else
       require('assert').fail(null, null, 'unexpected PromiseRejectEvent');
-  });
+  }, function getPromiseReason(data) {
+    return data[data.indexOf('[[PromiseValue]]') + 1];
+  }, promiseInternals);
 
   function unhandledRejection(promise, reason) {
     hasBeenNotifiedProperty.set(promise, false);
-    promiseToGuidProperty.set(promise, lastPromiseId++);
     addPendingUnhandledRejection(promise, reason);
   }
 
   function rejectionHandled(promise) {
     const hasBeenNotified = hasBeenNotifiedProperty.get(promise);
     if (hasBeenNotified !== undefined) {
       hasBeenNotifiedProperty.delete(promise);
-      const uid = promiseToGuidProperty.get(promise);
-      promiseToGuidProperty.delete(promise);
       if (hasBeenNotified === true) {
-        let warning = null;
-        if (!process.listenerCount('rejectionHandled')) {
-          // Generate the warning object early to get a good stack trace.
-          warning = getAsynchronousRejectionWarningObject(uid);
-        }
+        promiseInternals.untrackPromise(promise);
         process.nextTick(function() {
-          if (!process.emit('rejectionHandled', promise)) {
-            if (warning === null)
-              warning = getAsynchronousRejectionWarningObject(uid);
-            warning.name = 'PromiseRejectionHandledWarning';
-            warning.id = uid;
-            process.emitWarning(warning);
-          }
+          process.emit('rejectionHandled', promise);
         });
       }
 
     }
   }
 
-  function emitWarning(uid, reason) {
-    const warning = new Error('Unhandled promise rejection ' +
-                              `(rejection id: ${uid}): ${reason}`);
-    warning.name = 'UnhandledPromiseRejectionWarning';
-    warning.id = uid;
-    if (reason instanceof Error) {
-      warning.stack = reason.stack;
-    }
-    process.emitWarning(warning);
-    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');
-    }
-  }
-  var deprecationWarned = false;
   function emitPendingUnhandledRejections() {
     let hadListeners = false;
     while (pendingUnhandledRejections.length > 0) {
       const promise = pendingUnhandledRejections.shift();
       const reason = pendingUnhandledRejections.shift();
       if (hasBeenNotifiedProperty.get(promise) === false) {
         hasBeenNotifiedProperty.set(promise, true);
-        const uid = promiseToGuidProperty.get(promise);
         if (!process.emit('unhandledRejection', reason, promise)) {
-          emitWarning(uid, reason);
+          promiseInternals.trackPromise(promise);
         } else {
           hadListeners = true;
         }

lib/internal/process/promises.js

@@ -196,6 +196,7 @@
         'src/stream_wrap.cc',
         'src/tcp_wrap.cc',
         'src/timer_wrap.cc',
+        'src/track-promise.cc',
         'src/tracing/agent.cc',
         'src/tracing/node_trace_buffer.cc',
         'src/tracing/node_trace_writer.cc',
@@ -230,6 +231,7 @@
         'src/node_revert.h',
         'src/node_i18n.h',
         'src/pipe_wrap.h',
+        'src/track-promise.h',
         'src/tty_wrap.h',
         'src/tcp_wrap.h',
         'src/udp_wrap.h',

node.gyp

@@ -248,6 +248,7 @@ namespace node {
   V(zero_return_string, "ZERO_RETURN")                                        \
 
 #define ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)                           \
+  V(array_from, v8::Function)                                                 \
   V(as_external, v8::External)                                                \
   V(async_hooks_destroy_function, v8::Function)                               \
   V(async_hooks_init_function, v8::Function)                                  \
@@ -264,7 +265,10 @@ namespace node {
   V(module_load_list_array, v8::Array)                                        \
   V(pipe_constructor_template, v8::FunctionTemplate)                          \
   V(process_object, v8::Object)                                               \
-  V(promise_reject_function, v8::Function)                                    \
+  V(promise_unhandled_rejection_function, v8::Function)                       \
+  V(promise_unhandled_rejection, v8::Function)                                \
+  V(promise_unhandled_reject_map, v8::NativeWeakMap)                          \
+  V(promise_unhandled_reject_keys, v8::Set)                                   \
   V(push_values_to_array_function, v8::Function)                              \
   V(script_context_constructor_template, v8::FunctionTemplate)                \
   V(script_data_constructor_function, v8::Function)                           \