lib: refactor to use validateFunction

add validateFunction and refactor to use validateFunction

PR-URL: #37045
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Darshan Sen <raisinten@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: Lxxyx

lib/assert.js

@@ -68,6 +68,9 @@ const { isError } = require('internal/util');
 
 const errorCache = new SafeMap();
 const CallTracker = require('internal/assert/calltracker');
+const {
+  validateFunction,
+} = require('internal/validators');
 
 let isDeepEqual;
 let isDeepStrictEqual;
@@ -693,9 +696,7 @@ function expectedException(actual, expected, message, fn) {
 }
 
 function getActual(fn) {
-  if (typeof fn !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn);
-  }
+  validateFunction(fn, 'fn');
   try {
     fn();
   } catch (e) {

lib/async_hooks.js

@@ -16,10 +16,12 @@ const {
 const {
   ERR_ASYNC_CALLBACK,
   ERR_ASYNC_TYPE,
-  ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ASYNC_ID
 } = require('internal/errors').codes;
-const { validateString } = require('internal/validators');
+const {
+  validateFunction,
+  validateString,
+} = require('internal/validators');
 const internal_async_hooks = require('internal/async_hooks');
 
 // Get functions
@@ -221,8 +223,7 @@ class AsyncResource {
   }
 
   bind(fn) {
-    if (typeof fn !== 'function')
-      throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn);
+    validateFunction(fn, 'fn');
     const ret = FunctionPrototypeBind(this.runInAsyncScope, this, fn);
     ObjectDefineProperties(ret, {
       'length': {

lib/diagnostics_channel.js

@@ -15,6 +15,9 @@ const {
     ERR_INVALID_ARG_TYPE,
   }
 } = require('internal/errors');
+const {
+  validateFunction,
+} = require('internal/validators');
 
 const { triggerUncaughtException } = internalBinding('errors');
 
@@ -23,10 +26,7 @@ const { WeakReference } = internalBinding('util');
 // TODO(qard): should there be a C++ channel interface?
 class ActiveChannel {
   subscribe(subscription) {
-    if (typeof subscription !== 'function') {
-      throw new ERR_INVALID_ARG_TYPE('subscription', ['function'],
-                                     subscription);
-    }
+    validateFunction(subscription, 'subscription');
     ArrayPrototypePush(this._subscribers, subscription);
   }
 

lib/events.js

@@ -66,7 +66,8 @@ const {
 } = require('internal/util/inspect');
 
 const {
-  validateAbortSignal
+  validateAbortSignal,
+  validateFunction,
 } = require('internal/validators');
 
 const kCapture = Symbol('kCapture');
@@ -130,9 +131,7 @@ let defaultMaxListeners = 10;
 let isEventTarget;
 
 function checkListener(listener) {
-  if (typeof listener !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('listener', 'Function', listener);
-  }
+  validateFunction(listener, 'listener');
 }
 
 ObjectDefineProperty(EventEmitter, 'defaultMaxListeners', {

lib/fs.js

@@ -126,8 +126,9 @@ const {
   validateBoolean,
   validateBuffer,
   validateCallback,
+  validateFunction,
   validateInteger,
-  validateInt32
+  validateInt32,
 } = require('internal/validators');
 // 2 ** 32 - 1
 const kMaxUserId = 4294967295;
@@ -1628,9 +1629,7 @@ function watchFile(filename, options, listener) {
     ...options
   };
 
-  if (typeof listener !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('listener', 'Function', listener);
-  }
+  validateFunction(listener, 'listener');
 
   stat = statWatchers.get(filename);
 

lib/internal/dgram.js

@@ -8,9 +8,14 @@ const {
 const { codes } = require('internal/errors');
 const { UDP } = internalBinding('udp_wrap');
 const { guessHandleType } = internalBinding('util');
-const { isInt32 } = require('internal/validators');
+const {
+  isInt32,
+  validateFunction,
+} = require('internal/validators');
 const { UV_EINVAL } = internalBinding('uv');
-const { ERR_INVALID_ARG_TYPE, ERR_SOCKET_BAD_TYPE } = codes;
+const {
+  ERR_SOCKET_BAD_TYPE,
+} = codes;
 const kStateSymbol = Symbol('state symbol');
 let dns;  // Lazy load for startup performance.
 
@@ -31,8 +36,8 @@ function newHandle(type, lookup) {
     }
 
     lookup = dns.lookup;
-  } else if (typeof lookup !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('lookup', 'Function', lookup);
+  } else {
+    validateFunction(lookup, 'lookup');
   }
 
   if (type === 'udp4') {

lib/internal/fs/streams.js

@@ -17,7 +17,10 @@ const {
   ERR_METHOD_NOT_IMPLEMENTED,
 } = require('internal/errors').codes;
 const { deprecate } = require('internal/util');
-const { validateInteger } = require('internal/validators');
+const {
+  validateFunction,
+  validateInteger,
+} = require('internal/validators');
 const { errorOrDestroy } = require('internal/streams/destroy');
 const fs = require('fs');
 const { kRef, kUnref, FileHandle } = require('internal/fs/promises');
@@ -155,20 +158,9 @@ function ReadStream(path, options) {
 
   this[kFs] = options.fs || fs;
 
-  if (typeof this[kFs].open !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('options.fs.open', 'function',
-                                   this[kFs].open);
-  }
-
-  if (typeof this[kFs].read !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('options.fs.read', 'function',
-                                   this[kFs].read);
-  }
-
-  if (typeof this[kFs].close !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('options.fs.close', 'function',
-                                   this[kFs].close);
-  }
+  validateFunction(this[kFs].open, 'options.fs.open');
+  validateFunction(this[kFs].read, 'options.fs.read');
+  validateFunction(this[kFs].close, 'options.fs.close');
 
   options.autoDestroy = options.autoClose === undefined ?
     true : options.autoClose;
@@ -310,30 +302,23 @@ function WriteStream(path, options) {
   options.decodeStrings = true;
 
   this[kFs] = options.fs || fs;
-  if (typeof this[kFs].open !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('options.fs.open', 'function',
-                                   this[kFs].open);
-  }
+
+  validateFunction(this[kFs].open, 'options.fs.open');
 
   if (!this[kFs].write && !this[kFs].writev) {
     throw new ERR_INVALID_ARG_TYPE('options.fs.write', 'function',
                                    this[kFs].write);
   }
 
-  if (this[kFs].write && typeof this[kFs].write !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('options.fs.write', 'function',
-                                   this[kFs].write);
+  if (this[kFs].write) {
+    validateFunction(this[kFs].write, 'options.fs.write');
   }
 
-  if (this[kFs].writev && typeof this[kFs].writev !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('options.fs.writev', 'function',
-                                   this[kFs].writev);
+  if (this[kFs].writev) {
+    validateFunction(this[kFs].writev, 'options.fs.writev');
   }
 
-  if (typeof this[kFs].close !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('options.fs.close', 'function',
-                                   this[kFs].close);
-  }
+  validateFunction(this[kFs].close, 'options.fs.close');
 
   // It's enough to override either, in which case only one will be used.
   if (!this[kFs].write) {

lib/internal/process/task_queues.js

@@ -33,12 +33,12 @@ const {
   emitDestroy,
   symbols: { async_id_symbol, trigger_async_id_symbol }
 } = require('internal/async_hooks');
-const {
-  ERR_INVALID_ARG_TYPE
-} = require('internal/errors').codes;
 const FixedQueue = require('internal/fixed_queue');
 
-const { validateCallback } = require('internal/validators');
+const {
+  validateCallback,
+  validateFunction,
+} = require('internal/validators');
 
 // *Must* match Environment::TickInfo::Fields in src/env.h.
 const kHasTickScheduled = 0;
@@ -154,9 +154,7 @@ function runMicrotask() {
 }
 
 function queueMicrotask(callback) {
-  if (typeof callback !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
-  }
+  validateFunction(callback, 'callback');
 
   const asyncResource = createMicrotaskResource();
   asyncResource.callback = callback;

lib/internal/quic/util.js

@@ -116,6 +116,7 @@ const {
 const {
   validateBoolean,
   validateBuffer,
+  validateFunction,
   validateInteger,
   validateObject,
   validatePort,
@@ -175,8 +176,9 @@ function validateCloseCode(code) {
 }
 
 function validateLookup(lookup) {
-  if (lookup && typeof lookup !== 'function')
-    throw new ERR_INVALID_ARG_TYPE('options.lookup', 'function', lookup);
+  if (lookup) {
+    validateFunction(lookup, 'options.lookup');
+  }
 }
 
 function validatePreferredAddress(address) {

lib/internal/streams/end-of-stream.js

@@ -8,6 +8,9 @@ const {
   ERR_STREAM_PREMATURE_CLOSE
 } = require('internal/errors').codes;
 const { once } = require('internal/util');
+const {
+  validateFunction,
+} = require('internal/validators');
 
 function isRequest(stream) {
   return stream.setHeader && typeof stream.abort === 'function';
@@ -60,9 +63,7 @@ function eos(stream, options, callback) {
   } else if (typeof options !== 'object') {
     throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
   }
-  if (typeof callback !== 'function') {
-    throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
-  }
+  validateFunction(callback, 'callback');
 
   callback = once(callback);