util: refactor inspect code for constistency

This removes the special handling to inspect iterable objects with
a null prototype. It is now handled together with the regular
prototype.
Backport-PR-URL: #31431
PR-URL: #30225
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>

Author: BridgeAR

lib/internal/util/inspect.js

@@ -11,6 +11,7 @@ const {
  ErrorPrototypeToString,
  JSONStringify,
  Map,
+ MapPrototype,
  MapPrototypeEntries,
  MathFloor,
  MathMax,
@@ -22,10 +23,8 @@ const {
  NumberPrototypeValueOf,
  ObjectAssign,
  ObjectCreate,
- ObjectDefineProperties,
  ObjectDefineProperty,
  ObjectGetOwnPropertyDescriptor,
- ObjectGetOwnPropertyDescriptors,
  ObjectGetOwnPropertyNames,
  ObjectGetOwnPropertySymbols,
  ObjectGetPrototypeOf,
@@ -36,6 +35,7 @@ const {
  ObjectSeal,
  RegExpPrototypeToString,
  Set,
+ SetPrototype,
  SetPrototypeValues,
  StringPrototypeValueOf,
  SymbolPrototypeToString,
@@ -115,6 +115,11 @@ const assert = require('internal/assert');
 
 const{ NativeModule }=require('internal/bootstrap/loaders');
 
+constsetSizeGetter=uncurryThis(
+ObjectGetOwnPropertyDescriptor(SetPrototype,'size').get);
+constmapSizeGetter=uncurryThis(
+ObjectGetOwnPropertyDescriptor(MapPrototype,'size').get);
+
 lethexSlice;
 
 constbuiltInObjects=newSet(
@@ -648,51 +653,6 @@ function findTypedConstructor(value) {
 }
 }
 
-letlazyNullPrototypeCache;
-// Creates a subclass and name
-// the constructor as `${clazz} : null prototype`
-functionclazzWithNullPrototype(clazz,name){
-if(lazyNullPrototypeCache===undefined){
-lazyNullPrototypeCache=newMap();
-}else{
-constcachedClass=lazyNullPrototypeCache.get(clazz);
-if(cachedClass!==undefined){
-returncachedClass;
-}
-}
-classNullPrototypeextendsclazz{
-get[SymbolToStringTag](){
-return'';
-}
-}
-ObjectDefineProperty(NullPrototype.prototype.constructor,'name',
-{value: `[${name}: null prototype]`});
-lazyNullPrototypeCache.set(clazz,NullPrototype);
-returnNullPrototype;
-}
-
-functionnoPrototypeIterator(ctx,value,recurseTimes){
-letnewVal;
-if(isSet(value)){
-constclazz=clazzWithNullPrototype(Set,'Set');
-newVal=newclazz(SetPrototypeValues(value));
-}elseif(isMap(value)){
-constclazz=clazzWithNullPrototype(Map,'Map');
-newVal=newclazz(MapPrototypeEntries(value));
-}elseif(ArrayIsArray(value)){
-constclazz=clazzWithNullPrototype(Array,'Array');
-newVal=newclazz(value.length);
-}elseif(isTypedArray(value)){
-constconstructor=findTypedConstructor(value);
-constclazz=clazzWithNullPrototype(constructor,constructor.name);
-newVal=newclazz(value);
-}
-if(newVal!==undefined){
-ObjectDefineProperties(newVal,ObjectGetOwnPropertyDescriptors(value));
-returnformatRaw(ctx,newVal,recurseTimes);
-}
-}
-
 // Note: using `formatValue` directly requires the indentation level to be
 // corrected by setting `ctx.indentationLvL += diff` and then to decrease the
 // value afterwards again.
@@ -795,7 +755,9 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 letextrasType=kObjectType;
 
 // Iterators and the rest are split to reduce checks.
-if(value[SymbolIterator]){
+// We have to check all values in case the constructor is set to null.
+// Otherwise it would not possible to identify all types properly.
+if(value[SymbolIterator]||constructor===null){
 noIterator=false;
 if(ArrayIsArray(value)){
 keys=getOwnNonIndexProperties(value,filter);
@@ -807,37 +769,66 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 extrasType=kArrayExtrasType;
 formatter=formatArray;
 }elseif(isSet(value)){
+constsize=setSizeGetter(value);
 keys=getKeys(value,ctx.showHidden);
-constprefix=getPrefix(constructor,tag,'Set');
-if(value.size===0&&keys.length===0&&protoProps===undefined)
+letprefix='';
+if(constructor!==null){
+if(constructor===tag)
+tag='';
+prefix=getPrefix(`${constructor}`,tag,'');
+formatter=formatSet.bind(null,value,size);
+}else{
+prefix=getPrefix(constructor,tag,'Set');
+formatter=formatSet.bind(null,SetPrototypeValues(value),size);
+}
+if(size===0&&keys.length===0&&protoProps===undefined)
 return`${prefix}{}`;
 braces=[`${prefix}{`,'}'];
-formatter=formatSet;
 }elseif(isMap(value)){
+constsize=mapSizeGetter(value);
 keys=getKeys(value,ctx.showHidden);
-constprefix=getPrefix(constructor,tag,'Map');
-if(value.size===0&&keys.length===0&&protoProps===undefined)
+letprefix='';
+if(constructor!==null){
+if(constructor===tag)
+tag='';
+prefix=getPrefix(`${constructor}`,tag,'');
+formatter=formatMap.bind(null,value,size);
+}else{
+prefix=getPrefix(constructor,tag,'Map');
+formatter=formatMap.bind(null,MapPrototypeEntries(value),size);
+}
+if(size===0&&keys.length===0&&protoProps===undefined)
 return`${prefix}{}`;
 braces=[`${prefix}{`,'}'];
-formatter=formatMap;
 }elseif(isTypedArray(value)){
 keys=getOwnNonIndexProperties(value,filter);
-constprefix=constructor!==null ?
-getPrefix(constructor,tag) :
-getPrefix(constructor,tag,findTypedConstructor(value).name);
+letbound=value;
+letprefix='';
+if(constructor===null){
+constconstr=findTypedConstructor(value);
+prefix=getPrefix(constructor,tag,constr.name);
+// Reconstruct the array information.
+bound=newconstr(value);
+}else{
+prefix=getPrefix(constructor,tag);
+}
 braces=[`${prefix}[`,']'];
 if(value.length===0&&keys.length===0&&!ctx.showHidden)
 return`${braces[0]}]`;
-formatter=formatTypedArray;
+// Special handle the value. The original value is required below. The
+// bound function is required to reconstruct missing information.
+formatter=formatTypedArray.bind(null,bound);
 extrasType=kArrayExtrasType;
 }elseif(isMapIterator(value)){
 keys=getKeys(value,ctx.showHidden);
 braces=getIteratorBraces('Map',tag);
-formatter=formatIterator;
+// Add braces to the formatter parameters.
+formatter=formatIterator.bind(null,braces);
 }elseif(isSetIterator(value)){
 keys=getKeys(value,ctx.showHidden);
 braces=getIteratorBraces('Set',tag);
-formatter=formatIterator;
+// Add braces to the formatter parameters.
+formatter=formatIterator.bind(null,braces);
 }else{
 noIterator=true;
 }
@@ -915,36 +906,20 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 formatter=ctx.showHidden ? formatWeakMap : formatWeakCollection;
 }elseif(isModuleNamespaceObject(value)){
 braces[0]=`[${tag}] {`;
-formatter=formatNamespaceObject;
+// Special handle keys for namespace objects.
+formatter=formatNamespaceObject.bind(null,keys);
 }elseif(isBoxedPrimitive(value)){
 base=getBoxedBase(value,ctx,keys,constructor,tag);
 if(keys.length===0&&protoProps===undefined){
 returnbase;
 }
 }else{
-// The input prototype got manipulated. Special handle these. We have to
-// rebuild the information so we are able to display everything.
-if(constructor===null){
-constspecialIterator=noPrototypeIterator(ctx,value,recurseTimes);
-if(specialIterator){
-returnspecialIterator;
-}
-}
-if(isMapIterator(value)){
-braces=getIteratorBraces('Map',tag);
-formatter=formatIterator;
-}elseif(isSetIterator(value)){
-braces=getIteratorBraces('Set',tag);
-formatter=formatIterator;
-// Handle other regular objects again.
-}else{
-if(keys.length===0&&protoProps===undefined){
-if(isExternal(value))
-returnctx.stylize('[External]','special');
-return`${getCtxStyle(value,constructor,tag)}{}`;
-}
-braces[0]=`${getCtxStyle(value,constructor,tag)}{`;
+if(keys.length===0&&protoProps===undefined){
+if(isExternal(value))
+returnctx.stylize('[External]','special');
+return`${getCtxStyle(value,constructor,tag)}{}`;
 }
+braces[0]=`${getCtxStyle(value,constructor,tag)}{`;
 }
 }
 
@@ -961,7 +936,7 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
 letoutput;
 constindentationLvl=ctx.indentationLvl;
 try{
-output=formatter(ctx,value,recurseTimes,keys,braces);
+output=formatter(ctx,value,recurseTimes);
 for(i=0;i<keys.length;i++){
 output.push(
 formatProperty(ctx,value,recurseTimes,keys[i],extrasType));
@@ -1316,7 +1291,7 @@ function formatPrimitive(fn, value, ctx) {
 returnfn(SymbolPrototypeToString(value),'symbol');
 }
 
-functionformatNamespaceObject(ctx,value,recurseTimes,keys){
+functionformatNamespaceObject(keys,ctx,value,recurseTimes){
 constoutput=newArray(keys.length);
 for(leti=0;i<keys.length;i++){
 try{
@@ -1418,7 +1393,7 @@ function formatArray(ctx, value, recurseTimes) {
 returnoutput;
 }
 
-functionformatTypedArray(ctx,value,recurseTimes){
+functionformatTypedArray(value,ctx,ignored,recurseTimes){
 constmaxLength=MathMin(MathMax(0,ctx.maxArrayLength),value.length);
 constremaining=value.length-maxLength;
 constoutput=newArray(maxLength);
@@ -1449,7 +1424,7 @@ function formatTypedArray(ctx, value, recurseTimes) {
 returnoutput;
 }
 
-functionformatSet(ctx,value,recurseTimes){
+functionformatSet(value,size,ctx,ignored,recurseTimes){
 constoutput=[];
 ctx.indentationLvl+=2;
 for(constvofvalue){
@@ -1460,11 +1435,11 @@ function formatSet(ctx, value, recurseTimes) {
 // arrays. For consistency's sake, do the same for `size`, even though this
 // property isn't selected by ObjectGetOwnPropertyNames().
 if(ctx.showHidden)
-output.push(`[size]: ${ctx.stylize(`${value.size}`,'number')}`);
+output.push(`[size]: ${ctx.stylize(`${size}`,'number')}`);
 returnoutput;
 }
 
-functionformatMap(ctx,value,recurseTimes){
+functionformatMap(value,size,ctx,ignored,recurseTimes){
 constoutput=[];
 ctx.indentationLvl+=2;
 for(const[k,v]ofvalue){
@@ -1474,7 +1449,7 @@ function formatMap(ctx, value, recurseTimes) {
 ctx.indentationLvl-=2;
 // See comment in formatSet
 if(ctx.showHidden)
-output.push(`[size]: ${ctx.stylize(`${value.size}`,'number')}`);
+output.push(`[size]: ${ctx.stylize(`${size}`,'number')}`);
 returnoutput;
 }
 
@@ -1552,7 +1527,7 @@ function formatWeakMap(ctx, value, recurseTimes) {
 returnformatMapIterInner(ctx,recurseTimes,entries,kWeak);
 }
 
-functionformatIterator(ctx,value,recurseTimes,keys,braces){
+functionformatIterator(braces,ctx,value,recurseTimes){
 const[entries,isKeyValue]=previewEntries(value,true);
 if(isKeyValue){
 // Mark entry iterators as such.
@@ -1587,7 +1562,7 @@ function formatProperty(ctx, value, recurseTimes, key, type, desc) {
 desc=desc||ObjectGetOwnPropertyDescriptor(value,key)||
 {value: value[key],enumerable: true};
 if(desc.value!==undefined){
-constdiff=(type!==kObjectType||ctx.compact!==true) ? 2 : 3;
+constdiff=(ctx.compact!==true||type!==kObjectType) ? 2 : 3;
 ctx.indentationLvl+=diff;
 str=formatValue(ctx,desc.value,recurseTimes);
 if(diff===3){

test/parallel/test-util-inspect.js

@@ -2216,6 +2216,19 @@ assert.strictEqual(
 configurable: true
 });
 assert.strictEqual(util.inspect(obj),'[Set: null prototype] { 1, 2 }');
+Object.defineProperty(obj,Symbol.iterator,{
+value: true,
+configurable: true
+});
+Object.defineProperty(obj,'size',{
+value: NaN,
+configurable: true,
+enumerable: true
+});
+assert.strictEqual(
+util.inspect(obj),
+'[Set: null prototype] { 1, 2, size: NaN }'
+);
 }
 
 // Check the getter option.