lib: remove Reflect.apply where appropriate

Using Reflect.apply where the callback context does not need
to change is unnecessary and less performant.

PR-URL: #27349
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>

benchmark/timers/timers-breadth-args.js

@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+});
+
+function main({ n }) {
+  var j = 0;
+  function cb1(arg1) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+  function cb2(arg1, arg2) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+  function cb3(arg1, arg2, arg3) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+  function cb4(arg1, arg2, arg3, arg4) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+
+  bench.start();
+  for (var i = 0; i < n; i++) {
+    if (i % 4 === 0)
+      setTimeout(cb4, 1, 3.14, 1024, true, false);
+    else if (i % 3 === 0)
+      setTimeout(cb3, 1, 512, true, null);
+    else if (i % 2 === 0)
+      setTimeout(cb2, 1, false, 5.1);
+    else
+      setTimeout(cb1, 1, 0);
+  }
+}

lib/fs.js

@@ -24,7 +24,7 @@
 
 'use strict';
 
-const { Math, Object, Reflect } = primordials;
+const { Math, Object } = primordials;
 
 const { fs: constants } = internalBinding('constants');
 const {
@@ -133,9 +133,7 @@ function makeCallback(cb) {
     throw new ERR_INVALID_CALLBACK(cb);
   }
 
-  return (...args) => {
-    return Reflect.apply(cb, undefined, args);
-  };
+  return (...args) => cb(...args);
 }
 
 // Special case of `makeCallback()` that is specific to async `*stat()` calls as

lib/internal/async_hooks.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { FunctionPrototype, Object, Reflect } = primordials;
+const { FunctionPrototype, Object } = primordials;
 
 const {
   ERR_ASYNC_TYPE,
@@ -278,14 +278,14 @@ function clearDefaultTriggerAsyncId() {
 
 function defaultTriggerAsyncIdScope(triggerAsyncId, block, ...args) {
   if (triggerAsyncId === undefined)
-    return Reflect.apply(block, null, args);
+    return block(...args);
   // CHECK(Number.isSafeInteger(triggerAsyncId))
   // CHECK(triggerAsyncId > 0)
   const oldDefaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId];
   async_id_fields[kDefaultTriggerAsyncId] = triggerAsyncId;
 
   try {
-    return Reflect.apply(block, null, args);
+    return block(...args);
   } finally {
     async_id_fields[kDefaultTriggerAsyncId] = oldDefaultTriggerAsyncId;
   }

lib/internal/process/task_queues.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { FunctionPrototype, Reflect } = primordials;
+const { FunctionPrototype } = primordials;
 
 const {
   // For easy access to the nextTick state in the C++ land,
@@ -81,7 +81,7 @@ function processTicksAndRejections() {
       if (tock.args === undefined)
         callback();
       else
-        Reflect.apply(callback, undefined, tock.args);
+        callback(...tock.args);
 
       emitAfter(asyncId);
     }

lib/internal/timers.js

@@ -72,7 +72,7 @@
 // timers within (or creation of a new list). However, these operations combined
 // have shown to be trivial in comparison to other timers architectures.
 
-const { Math, Object, Reflect } = primordials;
+const { Math, Object } = primordials;
 
 const {
   scheduleTimer,
@@ -438,7 +438,7 @@ function getTimerCallbacks(runNextTicks) {
         if (!argv)
           immediate._onImmediate();
         else
-          Reflect.apply(immediate._onImmediate, immediate, argv);
+          immediate._onImmediate(...argv);
       } finally {
         immediate._onImmediate = null;
 
@@ -530,7 +530,7 @@ function getTimerCallbacks(runNextTicks) {
         if (args === undefined)
           timer._onTimeout();
         else
-          Reflect.apply(timer._onTimeout, timer, args);
+          timer._onTimeout(...args);
       } finally {
         if (timer._repeat && timer._idleTimeout !== -1) {
           timer._idleTimeout = timer._repeat;