diff --git a/lib/internal/async_hooks.js b/lib/internal/async_hooks.js
index a9bf1a49ac01ad..676a2bd2c0be44 100644
--- a/lib/internal/async_hooks.js
+++ b/lib/internal/async_hooks.js
@@ -77,6 +77,8 @@ const { kInit, kBefore, kAfter, kDestroy, kTotals, kPromiseResolve,
         kCheck, kExecutionAsyncId, kAsyncIdCounter, kTriggerAsyncId,
         kDefaultTriggerAsyncId, kStackLength } = async_wrap.constants;
 
+const FunctionBind = Function.call.bind(Function.prototype.bind);
+
 // Used in AsyncHook and AsyncResource.
 const async_id_symbol = Symbol('asyncId');
 const trigger_async_id_symbol = Symbol('triggerAsyncId');
@@ -151,38 +153,37 @@ function emitInitNative(asyncId, type, triggerAsyncId, resource) {
   }
 }
 
-
-function emitHookFactory(symbol, name) {
-  // Called from native. The asyncId stack handling is taken care of there
-  // before this is called.
-  // eslint-disable-next-line func-style
-  const fn = function(asyncId) {
-    active_hooks.call_depth += 1;
-    // Use a single try/catch for all hook to avoid setting up one per
-    // iteration.
-    try {
-      for (var i = 0; i < active_hooks.array.length; i++) {
-        if (typeof active_hooks.array[i][symbol] === 'function') {
-          active_hooks.array[i][symbol](asyncId);
-        }
+// Called from native. The asyncId stack handling is taken care of there
+// before this is called.
+function emitHook(symbol, asyncId) {
+  active_hooks.call_depth += 1;
+  // Use a single try/catch for all hook to avoid setting up one per
+  // iteration.
+  try {
+    for (var i = 0; i < active_hooks.array.length; i++) {
+      if (typeof active_hooks.array[i][symbol] === 'function') {
+        active_hooks.array[i][symbol](asyncId);
       }
-    } catch (e) {
-      fatalError(e);
-    } finally {
-      active_hooks.call_depth -= 1;
     }
+  } catch (e) {
+    fatalError(e);
+  } finally {
+    active_hooks.call_depth -= 1;
+  }
 
-    // Hooks can only be restored if there have been no recursive hook calls.
-    // Also the active hooks do not need to be restored if enable()/disable()
-    // weren't called during hook execution, in which case
-    // active_hooks.tmp_array will be null.
-    if (active_hooks.call_depth === 0 && active_hooks.tmp_array !== null) {
-      restoreActiveHooks();
-    }
-  };
+  // Hooks can only be restored if there have been no recursive hook calls.
+  // Also the active hooks do not need to be restored if enable()/disable()
+  // weren't called during hook execution, in which case
+  // active_hooks.tmp_array will be null.
+  if (active_hooks.call_depth === 0 && active_hooks.tmp_array !== null) {
+    restoreActiveHooks();
+  }
+}
+
+function emitHookFactory(symbol, name) {
+  const fn = FunctionBind(emitHook, undefined, symbol);
 
-  // Set the name property of the anonymous function as it looks good in the
-  // stack trace.
+  // Set the name property of the function as it looks good in the stack trace.
   Object.defineProperty(fn, 'name', {
     value: name
   });
@@ -264,10 +265,10 @@ function getOrSetAsyncId(object) {
 // the user to safeguard this call and make sure it's zero'd out when the
 // constructor is complete.
 function getDefaultTriggerAsyncId() {
-  let defaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId];
+  const defaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId];
   // If defaultTriggerAsyncId isn't set, use the executionAsyncId
   if (defaultTriggerAsyncId < 0)
-    defaultTriggerAsyncId = async_id_fields[kExecutionAsyncId];
+    return async_id_fields[kExecutionAsyncId];
   return defaultTriggerAsyncId;
 }
 
@@ -396,8 +397,8 @@ function pushAsyncIds(asyncId, triggerAsyncId) {
 
 // This is the equivalent of the native pop_async_ids() call.
 function popAsyncIds(asyncId) {
-  if (async_hook_fields[kStackLength] === 0) return false;
   const stackLength = async_hook_fields[kStackLength];
+  if (stackLength === 0) return false;
 
   if (async_hook_fields[kCheck] > 0 &&
       async_id_fields[kExecutionAsyncId] !== asyncId) {