util: inspect (user defined) prototype properties

This is only active if the `showHidden` option is truthy.
The implementation is a trade-off between accuracy and performance.
This will miss properties such as properties added to built-in data
types.
The goal is mainly to visualize prototype getters and setters such as:
class Foo {
ownProperty = true
get bar() {
return 'Hello world!'
}
}
const a = new Foo()
The `bar` property is a non-enumerable property on the prototype while
`ownProperty` will be set directly on the created instance.
The output is similar to the one of Chromium when inspecting objects
closer. The output from Firefox is difficult to compare, since it's
always a structured interactive output and was therefore not taken
into account.
Backport-PR-URL: #31431
PR-URL: #30768Fixes: #30183
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>

Author: BridgeAR

doc/api/util.md

@@ -398,6 +398,10 @@ stream.write('With ES6');
 <!-- YAML
 added: v0.3.0
 changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/30768
+ description: User defined prototype properties are inspected in case
+ `showHidden` is `true`.
  - version: v12.0.0
  pr-url: https://github.com/nodejs/node/pull/27109
  description: The `compact` options default is changed to `3` and the
@@ -458,7 +462,8 @@ changes:
 *`options` {Object}
 *`showHidden` {boolean} If `true`, `object`'s non-enumerable symbols and
  properties are included in the formatted result. [`WeakMap`][] and
-[`WeakSet`][] entries are also included. **Default:**`false`.
+[`WeakSet`][] entries are also included as well as user defined prototype
+ properties (excluding method properties). **Default:**`false`.
 *`depth` {number} Specifies the number of times to recurse while formatting
 `object`. This is useful for inspecting large objects. To recurse up to
  the maximum call stack size pass `Infinity` or `null`.

lib/internal/util/inspect.js

@@ -450,14 +450,20 @@ function getEmptyFormatArray() {
 return[];
 }
 
-functiongetConstructorName(obj,ctx,recurseTimes){
+functiongetConstructorName(obj,ctx,recurseTimes,protoProps){
 letfirstProto;
 consttmp=obj;
 while(obj){
 constdescriptor=ObjectGetOwnPropertyDescriptor(obj,'constructor');
 if(descriptor!==undefined&&
 typeofdescriptor.value==='function'&&
 descriptor.value.name!==''){
+if(protoProps!==undefined&&
+!builtInObjects.has(descriptor.value.name)){
+constisProto=firstProto!==undefined;
+addPrototypeProperties(
+ctx,tmp,obj,recurseTimes,isProto,protoProps);
+}
 returndescriptor.value.name;
 }
 
@@ -477,7 +483,8 @@ function getConstructorName(obj, ctx, recurseTimes) {
 return`${res} <Complex prototype>`;
 }
 
-constprotoConstr=getConstructorName(firstProto,ctx,recurseTimes+1);
+constprotoConstr=getConstructorName(
+firstProto,ctx,recurseTimes+1,protoProps);
 
 if(protoConstr===null){
 return`${res} <${inspect(firstProto,{
@@ -490,6 +497,68 @@ function getConstructorName(obj, ctx, recurseTimes) {
 return`${res} <${protoConstr}>`;
 }
 
+// This function has the side effect of adding prototype properties to the
+// `output` argument (which is an array). This is intended to highlight user
+// defined prototype properties.
+functionaddPrototypeProperties(ctx,main,obj,recurseTimes,isProto,output){
+letdepth=0;
+letkeys;
+letkeySet;
+do{
+if(!isProto){
+obj=ObjectGetPrototypeOf(obj);
+// Stop as soon as a null prototype is encountered.
+if(obj===null){
+return;
+}
+// Stop as soon as a built-in object type is detected.
+constdescriptor=ObjectGetOwnPropertyDescriptor(obj,'constructor');
+if(descriptor!==undefined&&
+typeofdescriptor.value==='function'&&
+builtInObjects.has(descriptor.value.name)){
+return;
+}
+}else{
+isProto=false;
+}
+
+if(depth===0){
+keySet=newSet();
+}else{
+keys.forEach((key)=>keySet.add(key));
+}
+// Get all own property names and symbols.
+keys=ObjectGetOwnPropertyNames(obj);
+constsymbols=ObjectGetOwnPropertySymbols(obj);
+if(symbols.length!==0){
+keys.push(...symbols);
+}
+for(constkeyofkeys){
+// Ignore the `constructor` property and keys that exist on layers above.
+if(key==='constructor'||
+ObjectPrototypeHasOwnProperty(main,key)||
+(depth!==0&&keySet.has(key))){
+continue;
+}
+constdesc=ObjectGetOwnPropertyDescriptor(obj,key);
+if(typeofdesc.value==='function'){
+continue;
+}
+constvalue=formatProperty(
+ctx,obj,recurseTimes,key,kObjectType,desc);
+if(ctx.colors){
+// Faint!
+output.push(`\u001b[2m${value}\u001b[22m`);
+}else{
+output.push(value);
+}
+}
+// Limit the inspection to up to three prototype layers. Using `recurseTimes`
+// is not a good choice here, because it's as if the properties are declared
+// on the current object from the users perspective.
+}while(++depth!==3);
+}
+
 functiongetPrefix(constructor,tag,fallback){
 if(constructor===null){
 if(tag!==''){
@@ -693,8 +762,17 @@ function formatValue(ctx, value, recurseTimes, typedArray) {
 
 functionformatRaw(ctx,value,recurseTimes,typedArray){
 letkeys;
+letprotoProps;
+if(ctx.showHidden&&(recurseTimes<=ctx.depth||ctx.depth===null)){
+protoProps=[];
+}
+
+constconstructor=getConstructorName(value,ctx,recurseTimes,protoProps);
+// Reset the variable to check for this later on.
+if(protoProps!==undefined&&protoProps.length===0){
+protoProps=undefined;
+}
 
-constconstructor=getConstructorName(value,ctx,recurseTimes);
 lettag=value[SymbolToStringTag];
 // Only list the tag in case it's non-enumerable / not an own property.
 // Otherwise we'd print this twice.
@@ -724,21 +802,21 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 // Only set the constructor for non ordinary ("Array [...]") arrays.
 constprefix=getPrefix(constructor,tag,'Array');
 braces=[`${prefix==='Array ' ? '' : prefix}[`,']'];
-if(value.length===0&&keys.length===0)
+if(value.length===0&&keys.length===0&&protoProps===undefined)
 return`${braces[0]}]`;
 extrasType=kArrayExtrasType;
 formatter=formatArray;
 }elseif(isSet(value)){
 keys=getKeys(value,ctx.showHidden);
 constprefix=getPrefix(constructor,tag,'Set');
-if(value.size===0&&keys.length===0)
+if(value.size===0&&keys.length===0&&protoProps===undefined)
 return`${prefix}{}`;
 braces=[`${prefix}{`,'}'];
 formatter=formatSet;
 }elseif(isMap(value)){
 keys=getKeys(value,ctx.showHidden);
 constprefix=getPrefix(constructor,tag,'Map');
-if(value.size===0&&keys.length===0)
+if(value.size===0&&keys.length===0&&protoProps===undefined)
 return`${prefix}{}`;
 braces=[`${prefix}{`,'}'];
 formatter=formatMap;
@@ -773,12 +851,12 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 }elseif(tag!==''){
 braces[0]=`${getPrefix(constructor,tag,'Object')}{`;
 }
-if(keys.length===0){
+if(keys.length===0&&protoProps===undefined){
 return`${braces[0]}}`;
 }
 }elseif(typeofvalue==='function'){
 base=getFunctionBase(value,constructor,tag);
-if(keys.length===0)
+if(keys.length===0&&protoProps===undefined)
 returnctx.stylize(base,'special');
 }elseif(isRegExp(value)){
 // Make RegExps say that they are RegExps
@@ -788,8 +866,10 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 constprefix=getPrefix(constructor,tag,'RegExp');
 if(prefix!=='RegExp ')
 base=`${prefix}${base}`;
-if(keys.length===0||(recurseTimes>ctx.depth&&ctx.depth!==null))
+if((keys.length===0&&protoProps===undefined)||
+(recurseTimes>ctx.depth&&ctx.depth!==null)){
 returnctx.stylize(base,'regexp');
+}
 }elseif(isDate(value)){
 // Make dates with properties first say the date
 base=NumberIsNaN(DatePrototypeGetTime(value)) ?
@@ -798,12 +878,12 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 constprefix=getPrefix(constructor,tag,'Date');
 if(prefix!=='Date ')
 base=`${prefix}${base}`;
-if(keys.length===0){
+if(keys.length===0&&protoProps===undefined){
 returnctx.stylize(base,'date');
 }
 }elseif(isError(value)){
 base=formatError(value,constructor,tag,ctx);
-if(keys.length===0)
+if(keys.length===0&&protoProps===undefined)
 returnbase;
 }elseif(isAnyArrayBuffer(value)){
 // Fast path for ArrayBuffer and SharedArrayBuffer.
@@ -814,7 +894,7 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 constprefix=getPrefix(constructor,tag,arrayType);
 if(typedArray===undefined){
 formatter=formatArrayBuffer;
-}elseif(keys.length===0){
+}elseif(keys.length===0&&protoProps===undefined){
 returnprefix+
 `{ byteLength: ${formatNumber(ctx.stylize,value.byteLength)} }`;
 }
@@ -838,7 +918,7 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 formatter=formatNamespaceObject;
 }elseif(isBoxedPrimitive(value)){
 base=getBoxedBase(value,ctx,keys,constructor,tag);
-if(keys.length===0){
+if(keys.length===0&&protoProps===undefined){
 returnbase;
 }
 }else{
@@ -858,7 +938,7 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 formatter=formatIterator;
 // Handle other regular objects again.
 }else{
-if(keys.length===0){
+if(keys.length===0&&protoProps===undefined){
 if(isExternal(value))
 returnctx.stylize('[External]','special');
 return`${getCtxStyle(value,constructor,tag)}{}`;
@@ -886,6 +966,9 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 output.push(
 formatProperty(ctx,value,recurseTimes,keys[i],extrasType));
 }
+if(protoProps!==undefined){
+output.push(...protoProps);
+}
 }catch(err){
 constconstructorName=getCtxStyle(value,constructor,tag).slice(0,-1);
 returnhandleMaxCallStackSize(ctx,err,constructorName,indentationLvl);
@@ -1349,6 +1432,7 @@ function formatTypedArray(ctx, value, recurseTimes) {
 }
 if(ctx.showHidden){
 // .buffer goes last, it's not a primitive like the others.
+// All besides `BYTES_PER_ELEMENT` are actually getters.
 ctx.indentationLvl+=2;
 for(constkeyof[
 'BYTES_PER_ELEMENT',
@@ -1497,10 +1581,10 @@ function formatPromise(ctx, value, recurseTimes) {
 returnoutput;
 }
 
-functionformatProperty(ctx,value,recurseTimes,key,type){
+functionformatProperty(ctx,value,recurseTimes,key,type,desc){
 letname,str;
 letextra=' ';
-constdesc=ObjectGetOwnPropertyDescriptor(value,key)||
+desc=desc||ObjectGetOwnPropertyDescriptor(value,key)||
 {value: value[key],enumerable: true};
 if(desc.value!==undefined){
 constdiff=(type!==kObjectType||ctx.compact!==true) ? 2 : 3;

test/parallel/test-util-inspect.js

@@ -391,8 +391,24 @@ assert.strictEqual(
 {
 classCustomArrayextendsArray{}
 CustomArray.prototype[5]='foo';
+CustomArray.prototype[49]='bar';
+CustomArray.prototype.foo=true;
 constarr=newCustomArray(50);
-assert.strictEqual(util.inspect(arr),'CustomArray [ <50 empty items> ]');
+arr[49]='I win';
+assert.strictEqual(
+util.inspect(arr),
+"CustomArray [ <49 empty items>, 'I win' ]"
+);
+assert.strictEqual(
+util.inspect(arr,{showHidden: true}),
+'CustomArray [\n'+
+' <49 empty items>,\n'+
+" 'I win',\n"+
+' [length]: 50,\n'+
+" '5': 'foo',\n"+
+' foo: true\n'+
+']'
+);
 }
 
 // Array with extra properties.
@@ -2585,3 +2601,65 @@ assert.strictEqual(
 throwerr;
 }
 }
+
+// Inspect prototype properties.
+{
+classFooextendsMap{
+prop=false;
+prop2=true;
+getabc(){
+returntrue;
+}
+getdef(){
+returnfalse;
+}
+setdef(v){}
+getxyz(){
+return'Should be ignored';
+}
+func(a){}
+[util.inspect.custom](){
+returnthis;
+}
+}
+
+classBarextendsFoo{
+abc=true;
+prop=true;
+getxyz(){
+return'YES!';
+}
+[util.inspect.custom](){
+returnthis;
+}
+}
+
+constbar=newBar();
+
+assert.strictEqual(
+inspect(bar),
+'Bar [Map] { prop: true, prop2: true, abc: true }'
+);
+assert.strictEqual(
+inspect(bar,{showHidden: true,getters: true,colors: false}),
+'Bar [Map] {\n'+
+' [size]: 0,\n'+
+' prop: true,\n'+
+' prop2: true,\n'+
+' abc: true,\n'+
+" [xyz]: [Getter: 'YES!'],\n"+
+' [def]: [Getter/Setter: false]\n'+
+'}'
+);
+assert.strictEqual(
+inspect(bar,{showHidden: true,getters: false,colors: true}),
+'Bar [Map] {\n'+
+' [size]: \x1B[33m0\x1B[39m,\n'+
+' prop: \x1B[33mtrue\x1B[39m,\n'+
+' prop2: \x1B[33mtrue\x1B[39m,\n'+
+' abc: \x1B[33mtrue\x1B[39m,\n'+
+' \x1B[2m[xyz]: \x1B[36m[Getter]\x1B[39m\x1B[22m,\n'+
+' \x1B[2m[def]: \x1B[36m[Getter/Setter]\x1B[39m\x1B[22m\n'+
+'}'
+);
+}

test/parallel/test-whatwg-encoding-custom-textdecoder.js

@@ -113,10 +113,19 @@ if (common.hasIntl) {
 }else{
 assert.strictEqual(
 util.inspect(dec,{showHidden: true}),
-"TextDecoder {\n encoding: 'utf-8',\n fatal: false,\n "+
-'ignoreBOM: true,\n [Symbol(flags)]: 4,\n [Symbol(handle)]: '+
-"StringDecoder {\n encoding: 'utf8',\n "+
-'[Symbol(kNativeDecoder)]: <Buffer 00 00 00 00 00 00 01>\n }\n}'
+'TextDecoder {\n'+
+" encoding: 'utf-8',\n"+
+' fatal: false,\n'+
+' ignoreBOM: true,\n'+
+' [Symbol(flags)]: 4,\n'+
+' [Symbol(handle)]: StringDecoder {\n'+
+" encoding: 'utf8',\n"+
+' [Symbol(kNativeDecoder)]: <Buffer 00 00 00 00 00 00 01>,\n'+
+' lastChar: [Getter],\n'+
+' lastNeed: [Getter],\n'+
+' lastTotal: [Getter]\n'+
+' }\n'+
+'}'
 );
 }
 }