buffer,error: improve bigint, big numbers and more

lib/internal/buffer.js

@@ -43,7 +43,20 @@ function checkBounds(buf, offset, byteLength) {
 
 function checkInt(value, min, max, buf, offset, byteLength) {
   if (value > max || value < min) {
-    throw new ERR_OUT_OF_RANGE('value', `>= ${min} and <= ${max}`, value);
+    // eslint-disable-next-line valid-typeof
+    const n = typeof min === 'bigint' ? 'n' : '';
+    let range;
+    if (byteLength > 3) {
+      if (min === 0 || min === 0n) {
+        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
+      } else {
+        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +
+                `${(byteLength + 1) * 8 - 1}${n}`;
+      }
+    } else {
+      range = `>= ${min}${n} and <= ${max}${n}`;
+    }
+    throw new ERR_OUT_OF_RANGE('value', range, value);
   }
   checkBounds(buf, offset, byteLength);
 }

lib/internal/errors.js

@@ -10,7 +10,7 @@
 // value statically and permanently identifies the error. While the error
 // message may change, the code should not.
 
-const { Object } = primordials;
+const { Object, Math } = primordials;
 
 const kCode = Symbol('code');
 const kInfo = Symbol('info');
@@ -999,7 +999,20 @@ E('ERR_OUT_OF_RANGE',
     assert(range, 'Missing "range" argument');
     let msg = replaceDefaultBoolean ? str :
       `The value of "${str}" is out of range.`;
-    msg += ` It must be ${range}. Received ${input}`;
+    let received;
+    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+      received = String(input).replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1,');
+    // eslint-disable-next-line valid-typeof
+    } else if (typeof input === 'bigint') {
+      received = String(input);
+      if (input > 2n ** 32n || input < -(2n ** 32n)) {
+        received = received.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1,');
+      }
+      received += 'n';
+    } else {
+      received = lazyInternalUtilInspect().inspect(input);
+    }
+    msg += ` It must be ${range}. Received ${received}`;
     return msg;
   }, RangeError);
 E('ERR_REQUIRE_ESM', 'Must use import to load ES Module: %s', Error);

test/parallel/test-buffer-bigint64.js

@@ -37,7 +37,11 @@ const buf = Buffer.allocUnsafe(8);
   assert.throws(function() {
     const val = 0x10000000000000000n;
     buf['writeBigUInt64' + endianness](val, 0);
-  }, RangeError);
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    message: 'The value of "value" is out of range. It must be ' +
+             '>= 0n and < 2n ** 64n. Received 18,446,744,073,709,551,616n'
+  });
 
   // Should throw a TypeError upon invalid input
   assert.throws(function() {

test/parallel/test-buffer-writeint.js

@@ -217,15 +217,19 @@ const errorOutOfBounds = common.expectsError({
     ['writeIntBE', 'writeIntLE'].forEach((fn) => {
       const min = -(2 ** (i * 8 - 1));
       const max = 2 ** (i * 8 - 1) - 1;
-
+      let range = `>= ${min} and <= ${max}`;
+      if (i > 4) {
+        range = `>= -(2 ** ${i * 8 - 1}) and < 2 ** ${i * 8 - 1}`;
+      }
       [min - 1, max + 1].forEach((val) => {
+        const received = i > 4 ? val.toLocaleString() : val;
         assert.throws(() => {
           data[fn](val, 0, i);
         }, {
           code: 'ERR_OUT_OF_RANGE',
           name: 'RangeError',
           message: 'The value of "value" is out of range. ' +
-                   `It must be >= ${min} and <= ${max}. Received ${val}`
+                   `It must be ${range}. Received ${received}`
         });
       });
 

test/parallel/test-buffer-writeuint.js

@@ -171,14 +171,16 @@ const assert = require('assert');
 
   // Test 1 to 6 bytes.
   for (let i = 1; i < 6; i++) {
+    const range = i < 5 ? `= ${val - 1}` : ` 2 ** ${i * 8}`;
+    const received = i > 4 ? val.toLocaleString() : val;
     ['writeUIntBE', 'writeUIntLE'].forEach((fn) => {
       assert.throws(() => {
         data[fn](val, 0, i);
       }, {
         code: 'ERR_OUT_OF_RANGE',
         name: 'RangeError',
         message: 'The value of "value" is out of range. ' +
-                 `It must be >= 0 and <= ${val - 1}. Received ${val}`
+                 `It must be >= 0 and <${range}. Received ${received}`
       });
 
       ['', '0', null, {}, [], () => {}, true, false].forEach((o) => {

test/parallel/test-crypto-pbkdf2.js

@@ -111,8 +111,8 @@ assert.throws(
     }, {
       code: 'ERR_OUT_OF_RANGE',
       name: 'RangeError',
-      message: 'The value of "keylen" is out of range. It ' +
-               `must be >= 0 && < 4294967296. Received ${input}`
+      message: 'The value of "keylen" is out of range. It must be ' +
+               `>= 0 && < 4294967296. Received ${input.toLocaleString()}`
     });
 });
 

test/parallel/test-event-emitter-max-listeners.js

@@ -22,6 +22,7 @@
 'use strict';
 const common = require('../common');
 const events = require('events');
+const { inspect } = require('util');
 const e = new events.EventEmitter();
 
 e.on('maxListeners', common.mustCall());
@@ -38,7 +39,7 @@ for (const obj of throwsObjs) {
       code: 'ERR_OUT_OF_RANGE',
       type: RangeError,
       message: 'The value of "n" is out of range. ' +
-               `It must be a non-negative number. Received ${obj}`
+               `It must be a non-negative number. Received ${inspect(obj)}`
     }
   );
 
@@ -48,7 +49,7 @@ for (const obj of throwsObjs) {
       code: 'ERR_OUT_OF_RANGE',
       type: RangeError,
       message: 'The value of "defaultMaxListeners" is out of range. ' +
-               `It must be a non-negative number. Received ${obj}`
+               `It must be a non-negative number. Received ${inspect(obj)}`
     }
   );
 }

test/parallel/test-file-write-stream3.js

@@ -199,8 +199,8 @@ const run_test_5 = common.mustCall(function() {
   };
   const err = {
     code: 'ERR_OUT_OF_RANGE',
-    message: 'The value of "start" is out of range. ' +
-             'It must be >= 0 and <= 2 ** 53 - 1. Received 9007199254740992',
+    message: 'The value of "start" is out of range. It must be ' +
+             '>= 0 and <= 2 ** 53 - 1. Received 9,007,199,254,740,992',
     type: RangeError
   };
   common.expectsError(fn, err);