errors: allow option validation with validators.js

`name` argument is now able to be and object with a `name` and `type`
keys. If `type` is `'option'` then `ERR_INVALID_OPT_TYPE` and
`ERR_INVALID_OPT_VALUE` errors will be used.

lib/internal/validators.js

@@ -11,6 +11,8 @@ const {
   codes: {
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_OPT_TYPE,
+    ERR_INVALID_OPT_VALUE,
     ERR_OUT_OF_RANGE,
     ERR_UNKNOWN_SIGNAL
   }
@@ -67,65 +69,84 @@ function parseFileMode(value, name, def) {
   throw new ERR_INVALID_ARG_VALUE(name, value, modeDesc);
 }
 
+const handleValueName = (name) => {
+  let TypeErr = ERR_INVALID_ARG_TYPE;
+  let ValueErr = ERR_INVALID_ARG_VALUE;
+  if (typeof name === 'object') {
+    if (name.type === 'option') {
+      TypeErr = ERR_INVALID_OPT_TYPE;
+      ValueErr = ERR_INVALID_OPT_VALUE;
+    }
+    name = name.name;
+  }
+  return { valueName: name, TypeErr, ValueErr };
+};
+
 const validateInteger = hideStackFrames(
   (value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {
+    const { valueName, TypeErr } = handleValueName(name);
     if (typeof value !== 'number')
-      throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
+      throw new TypeErr(valueName, 'number', value);
     if (!NumberIsInteger(value))
-      throw new ERR_OUT_OF_RANGE(name, 'an integer', value);
+      throw new ERR_OUT_OF_RANGE(valueName, 'an integer', value);
     if (value < min || value > max)
-      throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+      throw new ERR_OUT_OF_RANGE(valueName, `>= ${min} && <= ${max}`, value);
   }
 );
 
 const validateInt32 = hideStackFrames(
   (value, name, min = -2147483648, max = 2147483647) => {
     // The defaults for min and max correspond to the limits of 32-bit integers.
+    const { valueName, TypeErr } = handleValueName(name);
     if (!isInt32(value)) {
       if (typeof value !== 'number') {
-        throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
+        throw new TypeErr(valueName, 'number', value);
       }
       if (!NumberIsInteger(value)) {
-        throw new ERR_OUT_OF_RANGE(name, 'an integer', value);
+        throw new ERR_OUT_OF_RANGE(valueName, 'an integer', value);
       }
-      throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+      throw new ERR_OUT_OF_RANGE(valueName, `>= ${min} && <= ${max}`, value);
     }
     if (value < min || value > max) {
-      throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+      throw new ERR_OUT_OF_RANGE(valueName, `>= ${min} && <= ${max}`, value);
     }
   }
 );
 
 const validateUint32 = hideStackFrames((value, name, positive) => {
+  const { valueName, TypeErr } = handleValueName(name);
   if (!isUint32(value)) {
     if (typeof value !== 'number') {
-      throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
+      throw new TypeErr(valueName, 'number', value);
     }
     if (!NumberIsInteger(value)) {
-      throw new ERR_OUT_OF_RANGE(name, 'an integer', value);
+      throw new ERR_OUT_OF_RANGE(valueName, 'an integer', value);
     }
     const min = positive ? 1 : 0;
     // 2 ** 32 === 4294967296
-    throw new ERR_OUT_OF_RANGE(name, `>= ${min} && < 4294967296`, value);
+    throw new ERR_OUT_OF_RANGE(valueName, `>= ${min} && < 4294967296`, value);
   }
   if (positive && value === 0) {
-    throw new ERR_OUT_OF_RANGE(name, '>= 1 && < 4294967296', value);
+    throw new ERR_OUT_OF_RANGE(valueName, '>= 1 && < 4294967296', value);
   }
 });
 
 function validateString(value, name) {
+  const { valueName, TypeErr } = handleValueName(name);
   if (typeof value !== 'string')
-    throw new ERR_INVALID_ARG_TYPE(name, 'string', value);
+    throw new TypeErr(valueName, 'string', value);
 }
 
 function validateNumber(value, name) {
+  const { valueName, TypeErr } = handleValueName(name);
   if (typeof value !== 'number')
-    throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
+    throw new TypeErr(valueName, 'number', value);
 }
 
 function validateSignalName(signal, name = 'signal') {
+  const { valueName, TypeErr } = handleValueName(name);
   if (typeof signal !== 'string')
-    throw new ERR_INVALID_ARG_TYPE(name, 'string', signal);
+    throw new TypeErr(valueName, 'string', signal);
 
   if (signals[signal] === undefined) {
     if (signals[signal.toUpperCase()] !== undefined) {
@@ -138,11 +159,9 @@ function validateSignalName(signal, name = 'signal') {
 }
 
 const validateBuffer = hideStackFrames((buffer, name = 'buffer') => {
-  if (!isArrayBufferView(buffer)) {
-    throw new ERR_INVALID_ARG_TYPE(name,
-                                   ['Buffer', 'TypedArray', 'DataView'],
-                                   buffer);
-  }
+  const { valueName, TypeErr } = handleValueName(name);
+  if (!isArrayBufferView(buffer))
+    throw new TypeErr(valueName, ['Buffer', 'TypedArray', 'DataView'], buffer);
 });
 
 function validateEncoding(data, encoding) {