errors: extract type detection & use in ERR_INVALID_RETURN_VALUE

lib/internal/errors.js

@@ -858,6 +858,31 @@ const genericNodeError = hideStackFrames(function genericNodeError(message, erro
   return err;
 });
 
+/**
+ * Determine the specific type of a value for type-mismatch errors.
+ * @param {*} value
+ * @returns {string}
+ */
+function determineSpecificType(value) {
+  if (value == null) {
+    return '' + value;
+  }
+  if (typeof value === 'function' && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === 'object') {
+    if (value.constructor?.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${lazyInternalUtilInspect().inspect(value, { depth: -1 })}`;
+  }
+  let inspected = lazyInternalUtilInspect()
+    .inspect(value, { colors: false });
+  if (inspected.length > 28) { inspected = `${StringPrototypeSlice(inspected, 0, 25)}...`; }
+
+  return `type ${typeof value} (${inspected})`;
+}
+
 module.exports = {
   AbortError,
   aggregateTwoErrors,
@@ -866,6 +891,7 @@ module.exports = {
   connResetException,
   dnsException,
   // This is exported only to facilitate testing.
+  determineSpecificType,
   E,
   errnoException,
   exceptionWithHostPort,
@@ -1237,25 +1263,8 @@ E('ERR_INVALID_ARG_TYPE',
       }
     }
 
-    if (actual == null) {
-      msg += `. Received ${actual}`;
-    } else if (typeof actual === 'function' && actual.name) {
-      msg += `. Received function ${actual.name}`;
-    } else if (typeof actual === 'object') {
-      if (actual.constructor?.name) {
-        msg += `. Received an instance of ${actual.constructor.name}`;
-      } else {
-        const inspected = lazyInternalUtilInspect()
-          .inspect(actual, { depth: -1 });
-        msg += `. Received ${inspected}`;
-      }
-    } else {
-      let inspected = lazyInternalUtilInspect()
-        .inspect(actual, { colors: false });
-      if (inspected.length > 25)
-        inspected = `${StringPrototypeSlice(inspected, 0, 25)}...`;
-      msg += `. Received type ${typeof actual} (${inspected})`;
-    }
+    msg += `. Received ${determineSpecificType(actual)}`;
+
     return msg;
   }, TypeError);
 E('ERR_INVALID_ARG_VALUE', (name, value, reason = 'is invalid') => {
@@ -1335,12 +1344,8 @@ E('ERR_INVALID_RETURN_PROPERTY_VALUE', (input, name, prop, value) => {
          ` "${name}" function but got ${type}.`;
 }, TypeError);
 E('ERR_INVALID_RETURN_VALUE', (input, name, value) => {
-  let type;
-  if (value?.constructor?.name) {
-    type = `instance of ${value.constructor.name}`;
-  } else {
-    type = `type ${typeof value}`;
-  }
+  const type = determineSpecificType(value);
+
   return `Expected ${input} to be returned from the "${name}"` +
          ` function but got ${type}.`;
 }, TypeError, RangeError);

test/common/index.js

@@ -737,14 +737,15 @@ function invalidArgTypeHelper(input) {
     return ` Received function ${input.name}`;
   }
   if (typeof input === 'object') {
-    if (input.constructor && input.constructor.name) {
+    if (input.constructor?.name) {
       return ` Received an instance of ${input.constructor.name}`;
     }
     return ` Received ${inspect(input, { depth: -1 })}`;
   }
+
   let inspected = inspect(input, { colors: false });
-  if (inspected.length > 25)
-    inspected = `${inspected.slice(0, 25)}...`;
+  if (inspected.length > 28) { inspected = `${inspected.slice(inspected, 0, 25)}...`; }
+
   return ` Received type ${typeof input} (${inspected})`;
 }
 

test/errors/test-error-value-type-detection.mjs

@@ -0,0 +1,150 @@
+// Flags: --expose-internals
+
+import '../common/index.mjs';
+import { strictEqual } from 'node:assert';
+import errorsModule from 'internal/errors';
+
+
+const { determineSpecificType } = errorsModule;
+
+strictEqual(
+  determineSpecificType(1n),
+  'type bigint (1n)',
+);
+
+strictEqual(
+  determineSpecificType(false),
+  'type boolean (false)',
+);
+
+strictEqual(
+  determineSpecificType(2),
+  'type number (2)',
+);
+
+strictEqual(
+  determineSpecificType(NaN),
+  'type number (NaN)',
+);
+
+strictEqual(
+  determineSpecificType(Infinity),
+  'type number (Infinity)',
+);
+
+strictEqual(
+  determineSpecificType(Object.create(null)),
+  '[Object: null prototype] {}',
+);
+
+strictEqual(
+  determineSpecificType(''),
+  "type string ('')",
+);
+
+strictEqual(
+  determineSpecificType(Symbol('foo')),
+  'type symbol (Symbol(foo))',
+);
+
+strictEqual(
+  determineSpecificType(function foo() {}),
+  'function foo',
+);
+
+strictEqual(
+  determineSpecificType(null),
+  'null',
+);
+
+strictEqual(
+  determineSpecificType(undefined),
+  'undefined',
+);
+
+strictEqual(
+  determineSpecificType([]),
+  'an instance of Array',
+);
+
+strictEqual(
+  determineSpecificType(new Array()),
+  'an instance of Array',
+);
+strictEqual(
+  determineSpecificType(new BigInt64Array()),
+  'an instance of BigInt64Array',
+);
+strictEqual(
+  determineSpecificType(new BigUint64Array()),
+  'an instance of BigUint64Array',
+);
+strictEqual(
+  determineSpecificType(new Int8Array()),
+  'an instance of Int8Array',
+);
+strictEqual(
+  determineSpecificType(new Int16Array()),
+  'an instance of Int16Array',
+);
+strictEqual(
+  determineSpecificType(new Int32Array()),
+  'an instance of Int32Array',
+);
+strictEqual(
+  determineSpecificType(new Float32Array()),
+  'an instance of Float32Array',
+);
+strictEqual(
+  determineSpecificType(new Float64Array()),
+  'an instance of Float64Array',
+);
+strictEqual(
+  determineSpecificType(new Uint8Array()),
+  'an instance of Uint8Array',
+);
+strictEqual(
+  determineSpecificType(new Uint8ClampedArray()),
+  'an instance of Uint8ClampedArray',
+);
+strictEqual(
+  determineSpecificType(new Uint16Array()),
+  'an instance of Uint16Array',
+);
+strictEqual(
+  determineSpecificType(new Uint32Array()),
+  'an instance of Uint32Array',
+);
+
+strictEqual(
+  determineSpecificType(new Date()),
+  'an instance of Date',
+);
+
+strictEqual(
+  determineSpecificType(new Map()),
+  'an instance of Map',
+);
+strictEqual(
+  determineSpecificType(new WeakMap()),
+  'an instance of WeakMap',
+);
+
+strictEqual(
+  determineSpecificType({}),
+  'an instance of Object',
+);
+
+strictEqual(
+  determineSpecificType(Promise.resolve('foo')),
+  'an instance of Promise',
+);
+
+strictEqual(
+  determineSpecificType(new Set()),
+  'an instance of Set',
+);
+strictEqual(
+  determineSpecificType(new WeakSet()),
+  'an instance of WeakSet',
+);

test/parallel/test-assert-async.js

@@ -103,8 +103,9 @@ const invalidThenableFunc = () => {
   promises.push(assert.rejects(promise, {
     name: 'TypeError',
     code: 'ERR_INVALID_RETURN_VALUE',
+    // FIXME(JakobJingleheimer): This should match on key words, like /Promise/ and /undefined/.
     message: 'Expected instance of Promise to be returned ' +
-             'from the "promiseFn" function but got type undefined.'
+             'from the "promiseFn" function but got undefined.'
   }));
 
   promise = assert.rejects(Promise.resolve(), common.mustNotCall());
@@ -162,7 +163,7 @@ promises.push(assert.rejects(
   let promise = assert.doesNotReject(() => new Map(), common.mustNotCall());
   promises.push(assert.rejects(promise, {
     message: 'Expected instance of Promise to be returned ' +
-             'from the "promiseFn" function but got instance of Map.',
+             'from the "promiseFn" function but got an instance of Map.',
     code: 'ERR_INVALID_RETURN_VALUE',
     name: 'TypeError'
   }));