worker: support more cases when (de)serializing errors

- error.cause is potentially an error, so is now handled recursively
- best effort to serialize thrown symbols
- handle thrown object with custom inspect
PR-URL: #47925
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

Author: MoLow

lib/internal/error_serdes.js

@@ -13,19 +13,31 @@ const {
  ObjectGetOwnPropertyNames,
  ObjectGetPrototypeOf,
  ObjectKeys,
+ ObjectPrototypeHasOwnProperty,
  ObjectPrototypeToString,
  RangeError,
  ReferenceError,
  SafeSet,
+ StringFromCharCode,
+ StringPrototypeSubstring,
  SymbolToStringTag,
  SyntaxError,
+ SymbolFor,
  TypeError,
+ TypedArrayPrototypeGetBuffer,
+ TypedArrayPrototypeGetByteOffset,
+ TypedArrayPrototypeGetByteLength,
  URIError,
 }=primordials;
+const{inspect: {custom: customInspectSymbol}}=require('util');
 
 constkSerializedError=0;
 constkSerializedObject=1;
 constkInspectedError=2;
+constkInspectedSymbol=3;
+constkCustomInspectedObject=4;
+
+constkSymbolStringLength='Symbol('.length;
 
 consterrors={
  Error, TypeError, RangeError, URIError, SyntaxError, ReferenceError, EvalError,
@@ -42,19 +54,24 @@ function TryGetAllProperties(object, target = object) {
 ArrayPrototypeForEach(keys,(key)=>{
 letdescriptor;
 try{
+// TODO: create a null-prototype descriptor with needed properties only
 descriptor=ObjectGetOwnPropertyDescriptor(object,key);
 }catch{return;}
 constgetter=descriptor.get;
 if(getter&&key!=='__proto__'){
 try{
 descriptor.value=FunctionPrototypeCall(getter,target);
+deletedescriptor.get;
+deletedescriptor.set;
 }catch{
 // Continue regardless of error.
 }
 }
-if('value'indescriptor&&typeofdescriptor.value!=='function'){
-deletedescriptor.get;
-deletedescriptor.set;
+if(key==='cause'){
+descriptor.value=serializeError(descriptor.value);
+all[key]=descriptor;
+}elseif('value'indescriptor&&
+typeofdescriptor.value!=='function'&&typeofdescriptor.value!=='symbol'){
 all[key]=descriptor;
 }
 });
@@ -95,6 +112,9 @@ function inspect(...args) {
 letserialize;
 functionserializeError(error){
 if(!serialize)serialize=require('v8').serialize;
+if(typeoferror==='symbol'){
+returnBuffer.from(StringFromCharCode(kInspectedSymbol)+inspect(error),'utf8');
+}
 try{
 if(typeoferror==='object'&&
 ObjectPrototypeToString(error)==='[object Error]'){
@@ -113,14 +133,27 @@ function serializeError(error) {
 }catch{
 // Continue regardless of error.
 }
+try{
+if(error!=null&&
+ObjectPrototypeHasOwnProperty(error,customInspectSymbol)){
+returnBuffer.from(StringFromCharCode(kCustomInspectedObject)+inspect(error),'utf8');
+}
+}catch{
+// Continue regardless of error.
+}
 try{
 constserialized=serialize(error);
 returnBuffer.concat([Buffer.from([kSerializedObject]),serialized]);
 }catch{
 // Continue regardless of error.
 }
-returnBuffer.concat([Buffer.from([kInspectedError]),
-Buffer.from(inspect(error),'utf8')]);
+returnBuffer.from(StringFromCharCode(kInspectedError)+inspect(error),'utf8');
+}
+
+functionfromBuffer(error){
+returnBuffer.from(TypedArrayPrototypeGetBuffer(error),
+TypedArrayPrototypeGetByteOffset(error)+1,
+TypedArrayPrototypeGetByteLength(error)-1);
 }
 
 letdeserialize;
@@ -132,19 +165,27 @@ function deserializeError(error) {
 constctor=errors[constructor];
 ObjectDefineProperty(properties,SymbolToStringTag,{
 __proto__: null,
-value: {value: 'Error',configurable: true},
+value: {__proto__: null,value: 'Error',configurable: true},
 enumerable: true,
 });
+if('cause'inproperties&&'value'inproperties.cause){
+properties.cause.value=deserializeError(properties.cause.value);
+}
 returnObjectCreate(ctor.prototype,properties);
 }
 casekSerializedObject:
 returndeserialize(error.subarray(1));
-casekInspectedError:{
-constbuf=Buffer.from(error.buffer,
-error.byteOffset+1,
-error.byteLength-1);
-returnbuf.toString('utf8');
+casekInspectedError:
+returnfromBuffer(error).toString('utf8');
+casekInspectedSymbol: {
+constbuf=fromBuffer(error);
+returnSymbolFor(StringPrototypeSubstring(buf.toString('utf8'),kSymbolStringLength,buf.length-1));
 }
+casekCustomInspectedObject:
+return{
+__proto__: null,
+[customInspectSymbol]: ()=>fromBuffer(error).toString('utf8'),
+};
 }
 require('assert').fail('This should not happen');
 }

test/parallel/test-error-serdes.js

@@ -2,6 +2,7 @@
 'use strict';
 require('../common');
 constassert=require('assert');
+const{ inspect }=require('util');
 const{ERR_INVALID_ARG_TYPE}=require('internal/errors').codes;
 const{ serializeError, deserializeError }=require('internal/error_serdes');
 
@@ -15,6 +16,9 @@ assert.strictEqual(cycle(1.4), 1.4);
 assert.strictEqual(cycle(null),null);
 assert.strictEqual(cycle(undefined),undefined);
 assert.strictEqual(cycle('foo'),'foo');
+assert.strictEqual(cycle(Symbol.for('foo')),Symbol.for('foo'));
+assert.strictEqual(cycle(Symbol('foo')).toString(),Symbol('foo').toString());
+
 
 leterr=newError('foo');
 for(leti=0;i<10;i++){
@@ -43,6 +47,52 @@ assert.strictEqual(cycle(new SubError('foo')).name, 'Error');
 assert.deepStrictEqual(cycle({message: 'foo'}),{message: 'foo'});
 assert.strictEqual(cycle(Function),'[Function: Function]');
 
+classErrorWithCauseextendsError{
+getcause(){
+returnnewError('err');
+}
+}
+classErrorWithThowingCauseextendsError{
+getcause(){
+thrownewError('err');
+}
+}
+classErrorWithCyclicCauseextendsError{
+getcause(){
+returnnewErrorWithCyclicCause();
+}
+}
+consterrorWithCause=Object
+.defineProperty(newError('Error with cause'),'cause',{get(){return{foo: 'bar'};}});
+consterrorWithThrowingCause=Object
+.defineProperty(newError('Error with cause'),'cause',{get(){thrownewError('err');}});
+consterrorWithCyclicCause=Object
+.defineProperty(newError('Error with cause'),'cause',{get(){returnerrorWithCyclicCause;}});
+
+assert.strictEqual(cycle(newError('Error with cause',{cause: 0})).cause,0);
+assert.strictEqual(cycle(newError('Error with cause',{cause: -1})).cause,-1);
+assert.strictEqual(cycle(newError('Error with cause',{cause: 1.4})).cause,1.4);
+assert.strictEqual(cycle(newError('Error with cause',{cause: null})).cause,null);
+assert.strictEqual(cycle(newError('Error with cause',{cause: undefined})).cause,undefined);
+assert.strictEqual(Object.hasOwn(cycle(newError('Error with cause',{cause: undefined})),'cause'),true);
+assert.strictEqual(cycle(newError('Error with cause',{cause: 'foo'})).cause,'foo');
+assert.deepStrictEqual(cycle(newError('Error with cause',{cause: newError('err')})).cause,newError('err'));
+assert.deepStrictEqual(cycle(errorWithCause).cause,{foo: 'bar'});
+assert.strictEqual(Object.hasOwn(cycle(errorWithThrowingCause),'cause'),false);
+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 Maxiumum call stack size is reached
+letdepth=0;
+lete=cycle(newErrorWithCyclicCause('Error with cause'));
+while(e.cause){
+e=e.cause;
+depth++;
+}
+assert(depth>1);
+
+
 {
 consterr=newERR_INVALID_ARG_TYPE('object','Object',42);
 assert.match(String(err),/^TypeError\[ERR_INVALID_ARG_TYPE\]:/);
@@ -66,3 +116,12 @@ assert.strictEqual(cycle(Function), '[Function: Function]');
 serializeError(newDynamicError());
 assert.strictEqual(called,true);
 }
+
+
+constdata={
+foo: 'bar',
+[inspect.custom](){
+return'barbaz';
+}
+};
+assert.strictEqual(inspect(cycle(data)),'barbaz');