lib: avoid StackOverflow on serializeError

`serializeError` should avoid StackOverflow and the test should not
rely on `--stack-size`.
PR-URL: #58075
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>

Author: legendecas

lib/internal/error_serdes.js

@@ -36,6 +36,7 @@ const kSerializedObject = 1;
 constkInspectedError=2;
 constkInspectedSymbol=3;
 constkCustomInspectedObject=4;
+constkCircularReference=5;
 
 constkSymbolStringLength='Symbol('.length;
 
@@ -44,12 +45,12 @@ const errors = {
 };
 consterrorConstructorNames=newSafeSet(ObjectKeys(errors));
 
-functionTryGetAllProperties(object,target=object){
+functionTryGetAllProperties(object,target=object,rememberSet){
 constall={__proto__: null};
 if(object===null)
 returnall;
 ObjectAssign(all,
-TryGetAllProperties(ObjectGetPrototypeOf(object),target));
+TryGetAllProperties(ObjectGetPrototypeOf(object),target,rememberSet));
 constkeys=ObjectGetOwnPropertyNames(object);
 ArrayPrototypeForEach(keys,(key)=>{
 letdescriptor;
@@ -68,7 +69,7 @@ function TryGetAllProperties(object, target = object) {
 }
 }
 if(key==='cause'){
-descriptor.value=serializeError(descriptor.value);
+descriptor.value=serializeError(descriptor.value,rememberSet);
 all[key]=descriptor;
 }elseif('value'indescriptor&&
 typeofdescriptor.value!=='function'&&typeofdescriptor.value!=='symbol'){
@@ -108,21 +109,27 @@ function inspect(...args) {
 }
 
 letserialize;
-functionserializeError(error){
+functionserializeError(error,rememberSet=newSafeSet()){
 serialize??=require('v8').serialize;
 if(typeoferror==='symbol'){
 returnBuffer.from(StringFromCharCode(kInspectedSymbol)+inspect(error),'utf8');
 }
+
 try{
 if(typeoferror==='object'&&
 ObjectPrototypeToString(error)==='[object Error]'){
+if(rememberSet.has(error)){
+returnBuffer.from([kCircularReference]);
+}
+rememberSet.add(error);
+
 constconstructors=GetConstructors(error);
 for(leti=0;i<constructors.length;i++){
 constname=GetName(constructors[i]);
 if(errorConstructorNames.has(name)){
 constserialized=serialize({
 constructor: name,
-properties: TryGetAllProperties(error),
+properties: TryGetAllProperties(error,error,rememberSet),
 });
 returnBuffer.concat([Buffer.from([kSerializedError]),serialized]);
 }
@@ -183,6 +190,11 @@ function deserializeError(error) {
 __proto__: null,
 [customInspectSymbol]: ()=>fromBuffer(error).toString('utf8'),
 };
+casekCircularReference:
+return{
+__proto__: null,
+[customInspectSymbol]: ()=>'[Circular object]',
+};
 }
 require('assert').fail('This should not happen');
 }

test/sequential/test-error-serdes.js

@@ -1,4 +1,4 @@
-// Flags: --expose-internals --stack-size=64
+// Flags: --expose-internals
 'use strict';
 require('../common');
 constassert=require('assert');
@@ -59,7 +59,7 @@ class ErrorWithThowingCause extends Error {
 }
 classErrorWithCyclicCauseextendsError{
 getcause(){
-returnnewErrorWithCyclicCause();
+returnthis;
 }
 }
 consterrorWithCause=Object
@@ -83,14 +83,18 @@ assert.strictEqual(Object.hasOwn(cycle(errorWithCyclicCause), 'cause'), true);
 assert.deepStrictEqual(cycle(newErrorWithCause('Error with cause')).cause,newError('err'));
 assert.strictEqual(cycle(newErrorWithThowingCause('Error with cause')).cause,undefined);
 assert.strictEqual(Object.hasOwn(cycle(newErrorWithThowingCause('Error with cause')),'cause'),false);
-// When the cause is cyclic, it is serialized until Maximum call stack size is reached
+// When the cause is cyclic, it is serialized as a dumb circular reference object.
 letdepth=0;
 lete=cycle(newErrorWithCyclicCause('Error with cause'));
 while(e.cause){
 e=e.cause;
 depth++;
 }
-assert(depth>1);
+assert.strictEqual(depth,1);
+assert.strictEqual(
+inspect(cycle(newErrorWithCyclicCause('Error with cause')).cause),
+'[Circular object]',
+);
 
 
 {