util: add prototype support for boxed primitives

This makes sure manipulated prototypes from boxed primitives will
be highlighted. It also makes sure that a potential `Symbol.toStringTag`
is taken into account.
PR-URL: #27351
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: John-David Dalton <john.david.dalton@gmail.com>
Reviewed-By: Anto Aravinth <anto.aravinth.cse@gmail.com>

Author: BridgeAR

lib/internal/util/inspect.js

@@ -385,8 +385,6 @@ function getPrefix(constructor, tag, fallback) {
 return`${constructor} `;
 }
 
-constgetBoxedValue=formatPrimitive.bind(null,stylizeNoColor);
-
 // Look up the keys of the object.
 functiongetKeys(value,showHidden){
 letkeys;
@@ -709,31 +707,9 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 braces[0]=`[${tag}] {`;
 formatter=formatNamespaceObject;
 }elseif(isBoxedPrimitive(value)){
-lettype;
-if(isNumberObject(value)){
-base=`[Number: ${getBoxedValue(NumberPrototype.valueOf(value))}]`;
-type='number';
-}elseif(isStringObject(value)){
-base=`[String: ${
-getBoxedValue(StringPrototype.valueOf(value),ctx)
-}]`;
-type='string';
-// For boxed Strings, we have to remove the 0-n indexed entries,
-// since they just noisy up the output and are redundant
-// Make boxed primitive Strings look like such
-keys=keys.slice(value.length);
-}elseif(isBooleanObject(value)){
-base=`[Boolean: ${getBoxedValue(BooleanPrototype.valueOf(value))}]`;
-type='boolean';
-}elseif(isBigIntObject(value)){
-base=`[BigInt: ${getBoxedValue(BigIntPrototype.valueOf(value))}]`;
-type='bigint';
-}else{
-base=`[Symbol: ${getBoxedValue(SymbolPrototype.valueOf(value))}]`;
-type='symbol';
-}
+base=getBoxedBase(value,ctx,keys,constructor,tag);
 if(keys.length===0){
-returnctx.stylize(base,type);
+returnbase;
 }
 }else{
 // The input prototype got manipulated. Special handle these. We have to
@@ -818,6 +794,46 @@ function getIteratorBraces(type, tag) {
 return[`[${tag}] {`,'}'];
 }
 
+functiongetBoxedBase(value,ctx,keys,constructor,tag){
+letfn;
+lettype;
+if(isNumberObject(value)){
+fn=NumberPrototype;
+type='Number';
+}elseif(isStringObject(value)){
+fn=StringPrototype;
+type='String';
+// For boxed Strings, we have to remove the 0-n indexed entries,
+// since they just noisy up the output and are redundant
+// Make boxed primitive Strings look like such
+keys.splice(0,value.length);
+}elseif(isBooleanObject(value)){
+fn=BooleanPrototype;
+type='Boolean';
+}elseif(isBigIntObject(value)){
+fn=BigIntPrototype;
+type='BigInt';
+}else{
+fn=SymbolPrototype;
+type='Symbol';
+}
+letbase=`[${type}`;
+if(type!==constructor){
+if(constructor===null){
+base+=' (null prototype)';
+}else{
+base+=` (${constructor})`;
+}
+}
+base+=`: ${formatPrimitive(stylizeNoColor,fn.valueOf(value),ctx)}]`;
+if(tag!==''&&tag!==constructor){
+base+=` [${tag}]`;
+}
+if(keys.length!==0||ctx.stylize===stylizeNoColor)
+returnbase;
+returnctx.stylize(base,type.toLowerCase());
+}
+
 functionformatError(err,constructor,tag,ctx){
 // TODO(BridgeAR): Always show the error code if present.
 letstack=err.stack||ErrorPrototype.toString(err);

test/parallel/test-util-inspect.js

@@ -856,9 +856,21 @@ assert.strictEqual(
 '[Symbol: Symbol(test)]'
 );
 assert.strictEqual(util.inspect(newBoolean(false)),'[Boolean: false]');
-assert.strictEqual(util.inspect(newBoolean(true)),'[Boolean: true]');
+assert.strictEqual(
+util.inspect(Object.setPrototypeOf(newBoolean(true),null)),
+'[Boolean (null prototype): true]'
+);
 assert.strictEqual(util.inspect(newNumber(0)),'[Number: 0]');
-assert.strictEqual(util.inspect(newNumber(-0)),'[Number: -0]');
+assert.strictEqual(
+util.inspect(
+Object.defineProperty(
+Object.setPrototypeOf(newNumber(-0),Array.prototype),
+Symbol.toStringTag,
+{value: 'Foobar'}
+)
+),
+'[Number (Array): -0] [Foobar]'
+);
 assert.strictEqual(util.inspect(newNumber(-1.1)),'[Number: -1.1]');
 assert.strictEqual(util.inspect(newNumber(13.37)),'[Number: 13.37]');