lib: trigger uncaught exception handler for microtasks

doc/api/globals.md

@@ -119,8 +119,8 @@ added: v11.0.0
 * `callback` {Function} Function to be queued.
 
 The `queueMicrotask()` method queues a microtask to invoke `callback`. If
-`callback` throws an exception, the [`process` object][] `'error'` event will
-be emitted.
+`callback` throws an exception, the [`process` object][] `'uncaughtException'`
+event will be emitted.
 
 In general, `queueMicrotask` is the idiomatic choice over `process.nextTick()`.
 `process.nextTick()` will always run before the microtask queue, and so

lib/internal/bootstrap/node.js

@@ -24,7 +24,8 @@
                                 _umask, _initgroups, _setegid, _seteuid,
                                 _setgid, _setuid, _setgroups,
                                 _shouldAbortOnUncaughtToggle },
-                              { internalBinding, NativeModule }) {
+                              { internalBinding, NativeModule },
+                              triggerFatalException) {
   const exceptionHandlerState = { captureFn: null };
   const isMainThread = internalBinding('worker').threadId === 0;
 
@@ -538,8 +539,9 @@
       get: () => {
         process.emitWarning('queueMicrotask() is experimental.',
                             'ExperimentalWarning');
-        const { queueMicrotask } =
+        const { setupQueueMicrotask } =
           NativeModule.require('internal/queue_microtask');
+        const queueMicrotask = setupQueueMicrotask(triggerFatalException);
         Object.defineProperty(global, 'queueMicrotask', {
           value: queueMicrotask,
           writable: true,

lib/internal/queue_microtask.js

@@ -5,27 +5,35 @@ const { AsyncResource } = require('async_hooks');
 const { getDefaultTriggerAsyncId } = require('internal/async_hooks');
 const { enqueueMicrotask } = internalBinding('util');
 
-// declared separately for name, arrow function to prevent construction
-const queueMicrotask = (callback) => {
-  if (typeof callback !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
-  }
+const setupQueueMicrotask = (triggerFatalException) => {
+  const queueMicrotask = (callback) => {
+    if (typeof callback !== 'function') {
+      throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
+    }
 
-  const asyncResource = new AsyncResource('Microtask', {
-    triggerAsyncId: getDefaultTriggerAsyncId(),
-    requireManualDestroy: true,
-  });
+    const asyncResource = new AsyncResource('Microtask', {
+      triggerAsyncId: getDefaultTriggerAsyncId(),
+      requireManualDestroy: true,
+    });
 
-  enqueueMicrotask(() => {
-    asyncResource.runInAsyncScope(() => {
-      try {
-        callback();
-      } catch (e) {
-        process.emit('error', e);
-      }
+    enqueueMicrotask(() => {
+      asyncResource.runInAsyncScope(() => {
+        try {
+          callback();
+        } catch (error) {
+          // TODO(devsnek) remove this if
+          // https://bugs.chromium.org/p/v8/issues/detail?id=8326
+          // is resolved such that V8 triggers the fatal exception
+          // handler for microtasks
+          triggerFatalException(error);
+        } finally {
+          asyncResource.emitDestroy();
+        }
+      });
     });
-    asyncResource.emitDestroy();
-  });
+  };
+
+  return queueMicrotask;
 };
 
-module.exports = { queueMicrotask };
+module.exports = { setupQueueMicrotask };

src/node.cc

@@ -1423,6 +1423,18 @@ void FatalException(Isolate* isolate, const TryCatch& try_catch) {
 }
 
 
+static void FatalException(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  Environment* env = Environment::GetCurrent(isolate);
+  if (env != nullptr && env->abort_on_uncaught_exception()) {
+    Abort();
+  }
+  Local<Value> exception = args[0];
+  Local<Message> message = Exception::CreateMessage(isolate, exception);
+  FatalException(isolate, exception, message);
+}
+
+
 static void OnMessage(Local<Message> message, Local<Value> error) {
   // The current version of V8 sends messages for errors only
   // (thus `error` is always set).
@@ -2161,14 +2173,19 @@ void LoadEnvironment(Environment* env) {
     return;
   }
 
+  Local<Function> trigger_fatal_exception =
+      env->NewFunctionTemplate(FatalException)->GetFunction(env->context())
+          .ToLocalChecked();
+
   // Bootstrap Node.js
   Local<Object> bootstrapper = Object::New(env->isolate());
   SetupBootstrapObject(env, bootstrapper);
   Local<Value> bootstrapped_node;
   Local<Value> node_bootstrapper_args[] = {
     env->process_object(),
     bootstrapper,
-    bootstrapped_loaders
+    bootstrapped_loaders,
+    trigger_fatal_exception,
   };
   if (!ExecuteBootstrapper(env, node_bootstrapper.ToLocalChecked(),
                            arraysize(node_bootstrapper_args),

test/parallel/test-queue-microtask.js

@@ -42,7 +42,7 @@ queueMicrotask(common.mustCall(function() {
 }
 
 const eq = [];
-process.on('error', (e) => {
+process.on('uncaughtException', (e) => {
   eq.push(e);
 });