util: fix formatting of objects with built-in Symbol.toPrimitive

Fixes: #57818
PR-URL: #57832
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

Author: islandryu

doc/api/util.md

@@ -436,7 +436,7 @@ corresponding argument. Supported specifiers are:
 
 *`%s`: `String` will be used to convert all values except `BigInt`, `Object`
  and `-0`. `BigInt` values will be represented with an `n` and Objects that
- have no user defined `toString` function are inspected using `util.inspect()`
+ have neither a user defined `toString` function nor `Symbol.toPrimitive` function are inspected using `util.inspect()`
  with options `{ depth: 0, colors: false, compact: 3 }`.
 *`%d`: `Number` will be used to convert all values except `BigInt` and
 `Symbol`.

lib/internal/util/inspect.js

@@ -2166,27 +2166,32 @@ function hasBuiltInToString(value) {
 value=proxyTarget;
 }
 
-// Check if value has a custom Symbol.toPrimitive transformation.
-if(typeofvalue[SymbolToPrimitive]==='function'){
-returnfalse;
-}
+lethasOwnToString=ObjectPrototypeHasOwnProperty;
+lethasOwnToPrimitive=ObjectPrototypeHasOwnProperty;
 
-// Count objects that have no `toString` function as built-in.
+// Count objects without `toString` and `Symbol.toPrimitive` function as built-in.
 if(typeofvalue.toString!=='function'){
-returntrue;
-}
-
-// The object has a own `toString` property. Thus it's not not a built-in one.
-if(ObjectPrototypeHasOwnProperty(value,'toString')){
+if(typeofvalue[SymbolToPrimitive]!=='function'){
+returntrue;
+}elseif(ObjectPrototypeHasOwnProperty(value,SymbolToPrimitive)){
+returnfalse;
+}
+hasOwnToString=returnFalse;
+}elseif(ObjectPrototypeHasOwnProperty(value,'toString')){
+returnfalse;
+}elseif(typeofvalue[SymbolToPrimitive]!=='function'){
+hasOwnToPrimitive=returnFalse;
+}elseif(ObjectPrototypeHasOwnProperty(value,SymbolToPrimitive)){
 returnfalse;
 }
 
-// Find the object that has the `toString` property as own property in the
-// prototype chain.
+// Find the object that has the `toString` property or `Symbol.toPrimitive` property
+// as own property in the prototype chain.
 letpointer=value;
 do{
 pointer=ObjectGetPrototypeOf(pointer);
-}while(!ObjectPrototypeHasOwnProperty(pointer,'toString'));
+}while(!hasOwnToString(pointer,'toString')&&
+!hasOwnToPrimitive(pointer,SymbolToPrimitive));
 
 // Check closer if the object is a built-in.
 constdescriptor=ObjectGetOwnPropertyDescriptor(pointer,'constructor');
@@ -2195,6 +2200,10 @@ function hasBuiltInToString(value) {
 builtInObjects.has(descriptor.value.name);
 }
 
+functionreturnFalse(){
+returnfalse;
+}
+
 constfirstErrorLine=(error)=>StringPrototypeSplit(error.message,'\n',1)[0];
 letCIRCULAR_ERROR_MESSAGE;
 functiontryStringify(arg){

test/parallel/test-util-format.js

@@ -290,6 +290,68 @@ assert.strictEqual(util.format('%s', -Infinity), '-Infinity');
 assert.strictEqual(util.format('%s',objectWithToPrimitive+''),'default context');
 }
 
+// built-in toPrimitive is the same behavior as inspect
+{
+constdate=newDate('2023-10-01T00:00:00Z');
+assert.strictEqual(util.format('%s',date),util.inspect(date));
+
+constsymbol=Symbol('foo');
+assert.strictEqual(util.format('%s',symbol),util.inspect(symbol));
+}
+
+// Prototype chain handling for toString
+{
+functionhasToStringButNoToPrimitive(){}
+
+hasToStringButNoToPrimitive.prototype.toString=function(){
+return'hasToStringButNoToPrimitive';
+};
+
+letobj=newhasToStringButNoToPrimitive();
+assert.strictEqual(util.format('%s',obj.toString()),'hasToStringButNoToPrimitive');
+
+functioninheritsFromHasToStringButNoToPrimitive(){}
+Object.setPrototypeOf(inheritsFromHasToStringButNoToPrimitive.prototype,
+hasToStringButNoToPrimitive.prototype);
+obj=newinheritsFromHasToStringButNoToPrimitive();
+assert.strictEqual(util.format('%s',obj.toString()),'hasToStringButNoToPrimitive');
+}
+
+// Prototype chain handling for Symbol.toPrimitive
+{
+functionhasToPrimitiveButNoToString(){}
+
+hasToPrimitiveButNoToString.prototype[Symbol.toPrimitive]=function(){
+return'hasToPrimitiveButNoToString';
+};
+
+letobj=newhasToPrimitiveButNoToString();
+assert.strictEqual(util.format('%s',obj[Symbol.toPrimitive]()),'hasToPrimitiveButNoToString');
+functioninheritsFromHasToPrimitiveButNoToString(){}
+Object.setPrototypeOf(inheritsFromHasToPrimitiveButNoToString.prototype,
+hasToPrimitiveButNoToString.prototype);
+obj=newinheritsFromHasToPrimitiveButNoToString();
+assert.strictEqual(util.format('%s',obj[Symbol.toPrimitive]()),'hasToPrimitiveButNoToString');
+}
+
+// Prototype chain handling for both toString and Symbol.toPrimitive
+{
+functionhasBothToStringAndToPrimitive(){}
+hasBothToStringAndToPrimitive.prototype.toString=function(){
+return'toString';
+};
+hasBothToStringAndToPrimitive.prototype[Symbol.toPrimitive]=function(){
+return'toPrimitive';
+};
+letobj=newhasBothToStringAndToPrimitive();
+assert.strictEqual(util.format('%s',obj.toString()),'toString');
+functioninheritsFromHasBothToStringAndToPrimitive(){}
+Object.setPrototypeOf(inheritsFromHasBothToStringAndToPrimitive.prototype,
+hasBothToStringAndToPrimitive.prototype);
+obj=newinheritsFromHasBothToStringAndToPrimitive();
+assert.strictEqual(util.format('%s',obj.toString()),'toString');
+}
+
 // JSON format specifier
 assert.strictEqual(util.format('%j'),'%j');
 assert.strictEqual(util.format('%j',42),'42');