Fix Error creation process to check and trigger Error relevant callbacks correctly

clover2123 · ksh8281 · commit 57c23d62f0d1 · 2024-05-14T10:08:26.000+09:00
Signed-off-by: HyukWoo Park &lt;hyukwoo.park@samsung.com&gt;
diff --git a/src/builtins/BuiltinError.cpp b/src/builtins/BuiltinError.cpp
@@ -52,7 +52,12 @@ static Value builtinErrorConstructor(ExecutionState& state, Value thisValue, siz
     Object* proto = Object::getPrototypeFromConstructor(state, newTarget.value(), [](ExecutionState& state, Context* constructorRealm) -> Object* {
         return constructorRealm->globalObject()->errorPrototype();
     });
+
+#if defined(ENABLE_EXTENDED_API)
+    ErrorObject* obj = new ErrorObject(state, proto, String::emptyString, true, state.context()->vmInstance()->isErrorCreationCallbackRegistered());
+#else
     ErrorObject* obj = new ErrorObject(state, proto, String::emptyString);
+#endif
 
     Value message = argv[0];
     if (!message.isUndefined()) {
@@ -63,12 +68,6 @@ static Value builtinErrorConstructor(ExecutionState& state, Value thisValue, siz
     Value options = argc > 1 ? argv[1] : Value();
     installErrorCause(state, obj, options);
 
-#if defined(ENABLE_EXTENDED_API)
-    if (UNLIKELY(state.context()->vmInstance()->isErrorCreationCallbackRegistered())) {
-        state.context()->vmInstance()->triggerErrorCreationCallback(state, obj);
-    }
-#endif
-
     return obj;
 }
 
@@ -82,17 +81,14 @@ static Value builtinErrorConstructor(ExecutionState& state, Value thisValue, siz
         Object* proto = Object::getPrototypeFromConstructor(state, newTarget.value(), [](ExecutionState& state, Context* constructorRealm) -> Object* {                                                                                                 \
             return constructorRealm->globalObject()->lowerCaseErrorName##ErrorPrototype();                                                                                                                                                              \
         });                                                                                                                                                                                                                                             \
-        ErrorObject* obj = new errorName##ErrorObject(state, proto, String::emptyString);                                                                                                                                                               \
+        ErrorObject* obj = new errorName##ErrorObject(state, proto, String::emptyString, true, state.context()->vmInstance()->isErrorCreationCallbackRegistered());                                                                                     \
         Value message = argv[0];                                                                                                                                                                                                                        \
         if (!message.isUndefined()) {                                                                                                                                                                                                                   \
             obj->defineOwnPropertyThrowsException(state, state.context()->staticStrings().message,                                                                                                                                                      \
                                                   ObjectPropertyDescriptor(message.toString(state), (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent))); \
         }                                                                                                                                                                                                                                               \
         Value options = argc > 1 ? argv[1] : Value();                                                                                                                                                                                                   \
         installErrorCause(state, obj, options);                                                                                                                                                                                                         \
-        if (UNLIKELY(state.context()->vmInstance()->isErrorCreationCallbackRegistered())) {                                                                                                                                                             \
-            state.context()->vmInstance()->triggerErrorCreationCallback(state, obj);                                                                                                                                                                    \
-        }                                                                                                                                                                                                                                               \
         return obj;                                                                                                                                                                                                                                     \
     }
 #else
@@ -134,7 +130,13 @@ static Value builtinAggregateErrorConstructor(ExecutionState& state, Value thisV
     Object* proto = Object::getPrototypeFromConstructor(state, newTarget.value(), [](ExecutionState& state, Context* constructorRealm) -> Object* {
         return constructorRealm->globalObject()->aggregateErrorPrototype();
     });
+
+#if defined(ENABLE_EXTENDED_API)
+    ErrorObject* O = new AggregateErrorObject(state, proto, String::emptyString, true, state.context()->vmInstance()->isErrorCreationCallbackRegistered());
+#else
     ErrorObject* O = new AggregateErrorObject(state, proto, String::emptyString);
+#endif
+
     Value message = argv[1];
     // If message is not undefined, then
     if (!message.isUndefined()) {
@@ -155,12 +157,6 @@ static Value builtinAggregateErrorConstructor(ExecutionState& state, Value thisV
     O->defineOwnPropertyThrowsException(state, ObjectPropertyName(state, String::fromASCII("errors")),
                                         ObjectPropertyDescriptor(Value(Object::createArrayFromList(state, errorsList.size(), errorsList.data())), (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
 
-#if defined(ENABLE_EXTENDED_API)
-    if (UNLIKELY(state.context()->vmInstance()->isErrorCreationCallbackRegistered())) {
-        state.context()->vmInstance()->triggerErrorCreationCallback(state, O);
-    }
-#endif
-
     // Return O.
     return O;
 }
diff --git a/src/runtime/ErrorObject.cpp b/src/runtime/ErrorObject.cpp
@@ -22,6 +22,9 @@
 #include "Context.h"
 #include "SandBox.h"
 #include "NativeFunctionObject.h"
+#ifdef ENABLE_EXTENDED_API
+#include "VMInstance.h"
+#endif
 
 namespace Escargot {
 
@@ -158,22 +161,39 @@ static Value builtinErrorObjectStackInfoSet(ExecutionState& state, Value thisVal
     return Value();
 }
 
-ErrorObject::ErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
+ErrorObject::ErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
     : DerivedObject(state, proto)
     , m_stackTraceData(nullptr)
 {
+    UNUSED_PARAMETER(triggerCallback);
+    Context* context = state.context();
+
     if (errorMessage->length()) {
         defineOwnPropertyThrowsException(state, state.context()->staticStrings().message,
                                          ObjectPropertyDescriptor(errorMessage, (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
     }
 
-    Context* context = state.context();
+#if defined(ENABLE_EXTENDED_API)
+    if (UNLIKELY(triggerCallback)) {
+        ASSERT(context->vmInstance()->isErrorCreationCallbackRegistered());
+        // trigger ErrorCreationCallback
+        context->vmInstance()->triggerErrorCreationCallback(state, this);
+        if (this->hasOwnProperty(state, ObjectPropertyName(context->staticStrings().stack))) {
+            // if ErrorCreationCallback is registered and this callback already inserts `stack` property for the created ErrorObject,
+            // we just ignore adding `stack` data here
+            return;
+        }
+    }
+#endif
+
     JSGetterSetter gs(
         new NativeFunctionObject(state, NativeFunctionInfo(context->staticStrings().stack, builtinErrorObjectStackInfoGet, 0, NativeFunctionInfo::Strict)),
         new NativeFunctionObject(state, NativeFunctionInfo(context->staticStrings().stack, builtinErrorObjectStackInfoSet, 0, NativeFunctionInfo::Strict)));
     ObjectPropertyDescriptor desc(gs, ObjectPropertyDescriptor::ConfigurablePresent);
     defineOwnProperty(state, ObjectPropertyName(context->staticStrings().stack), desc);
+
     if (fillStackInfo) {
+        // fill stack info at the creation of Error object rather than the moment of thrown
         updateStackTraceData(state);
     }
 }
@@ -185,54 +205,54 @@ void ErrorObject::updateStackTraceData(ExecutionState& state)
     setStackTraceData(StackTraceData::create(stackTraceDataVector));
 }
 
-ReferenceErrorObject::ReferenceErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+ReferenceErrorObject::ReferenceErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-TypeErrorObject::TypeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+TypeErrorObject::TypeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-RangeErrorObject::RangeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+RangeErrorObject::RangeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-SyntaxErrorObject::SyntaxErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+SyntaxErrorObject::SyntaxErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-URIErrorObject::URIErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+URIErrorObject::URIErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-EvalErrorObject::EvalErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+EvalErrorObject::EvalErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-AggregateErrorObject::AggregateErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+AggregateErrorObject::AggregateErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
 #if defined(ENABLE_WASM)
-WASMCompileErrorObject::WASMCompileErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+WASMCompileErrorObject::WASMCompileErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-WASMLinkErrorObject::WASMLinkErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+WASMLinkErrorObject::WASMLinkErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 
-WASMRuntimeErrorObject::WASMRuntimeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)
-    : ErrorObject(state, proto, errorMessage, fillStackInfo)
+WASMRuntimeErrorObject::WASMRuntimeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)
+    : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)
 {
 }
 #endif
diff --git a/src/runtime/ErrorObject.h b/src/runtime/ErrorObject.h
@@ -171,7 +171,7 @@ class ErrorObject : public DerivedObject {
     static void throwBuiltinError(ExecutionState& state, ErrorCode code, String* objectName, bool prototype, String* functionName, const char* templateString);
     static void throwBuiltinError(ExecutionState& state, ErrorCode code, String* errorMessage);
 
-    ErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    ErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
     void updateStackTraceData(ExecutionState& state);
 
     virtual bool isErrorObject() const
@@ -195,53 +195,53 @@ class ErrorObject : public DerivedObject {
 
 class ReferenceErrorObject : public ErrorObject {
 public:
-    ReferenceErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    ReferenceErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class TypeErrorObject : public ErrorObject {
 public:
-    TypeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    TypeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class SyntaxErrorObject : public ErrorObject {
 public:
-    SyntaxErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    SyntaxErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class RangeErrorObject : public ErrorObject {
 public:
-    RangeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    RangeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class URIErrorObject : public ErrorObject {
 public:
-    URIErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    URIErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class EvalErrorObject : public ErrorObject {
 public:
-    EvalErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    EvalErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class AggregateErrorObject : public ErrorObject {
 public:
-    AggregateErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    AggregateErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 #if defined(ENABLE_WASM)
 class WASMCompileErrorObject : public ErrorObject {
 public:
-    WASMCompileErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    WASMCompileErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class WASMLinkErrorObject : public ErrorObject {
 public:
-    WASMLinkErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    WASMLinkErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 
 class WASMRuntimeErrorObject : public ErrorObject {
 public:
-    WASMRuntimeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true);
+    WASMRuntimeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo = true, bool triggerCallback = false);
 };
 #endif
 } // namespace Escargot
diff --git a/src/runtime/ObjectStructure.cpp b/src/runtime/ObjectStructure.cpp
@@ -56,7 +56,6 @@ ObjectStructure* ObjectStructure::create(Context* ctx, ObjectStructureItemTightV
     bool hasSymbol = false;
     bool hasNonAtomicPropertyName = false;
     bool hasEnumerableProperty = true;
-    bool isInlineCacheable = true;
 
     for (size_t i = 0; i < properties.size(); i++) {
         const ObjectStructurePropertyName& propertyName = properties[i].m_propertyName;

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,9 @@`
`22`	`22`	`#include "Context.h"`
`23`	`23`	`#include "SandBox.h"`
`24`	`24`	`#include "NativeFunctionObject.h"`
	`25`	`+#ifdef ENABLE_EXTENDED_API`
	`26`	`+#include "VMInstance.h"`
	`27`	`+#endif`
`25`	`28`
`26`	`29`	`namespace Escargot {`
`27`	`30`
`@@ -158,22 +161,39 @@ static Value builtinErrorObjectStackInfoSet(ExecutionState& state, Value thisVal`
`158`	`161`	`return Value();`
`159`	`162`	`}`
`160`	`163`
`161`		`-ErrorObject::ErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
	`164`	`+ErrorObject::ErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
`162`	`165`	`: DerivedObject(state, proto)`
`163`	`166`	`, m_stackTraceData(nullptr)`
`164`	`167`	`{`
	`168`	`+ UNUSED_PARAMETER(triggerCallback);`
	`169`	`+ Context* context = state.context();`
	`170`	`+`
`165`	`171`	`if (errorMessage->length()) {`
`166`	`172`	`defineOwnPropertyThrowsException(state, state.context()->staticStrings().message,`
`167`	`173`	`ObjectPropertyDescriptor(errorMessage, (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent \| ObjectStructurePropertyDescriptor::ConfigurablePresent)));`
`168`	`174`	`}`
`169`	`175`
`170`		`- Context* context = state.context();`
	`176`	`+#if defined(ENABLE_EXTENDED_API)`
	`177`	`+ if (UNLIKELY(triggerCallback)) {`
	`178`	`+ ASSERT(context->vmInstance()->isErrorCreationCallbackRegistered());`
	`179`	`+ // trigger ErrorCreationCallback`
	`180`	`+ context->vmInstance()->triggerErrorCreationCallback(state, this);`
	`181`	`+ if (this->hasOwnProperty(state, ObjectPropertyName(context->staticStrings().stack))) {`
	`182`	+ // if ErrorCreationCallback is registered and this callback already inserts `stack` property for the created ErrorObject,
	`183`	+ // we just ignore adding `stack` data here
	`184`	`+ return;`
	`185`	`+ }`
	`186`	`+ }`
	`187`	`+#endif`
	`188`	`+`
`171`	`189`	`JSGetterSetter gs(`
`172`	`190`	`new NativeFunctionObject(state, NativeFunctionInfo(context->staticStrings().stack, builtinErrorObjectStackInfoGet, 0, NativeFunctionInfo::Strict)),`
`173`	`191`	`new NativeFunctionObject(state, NativeFunctionInfo(context->staticStrings().stack, builtinErrorObjectStackInfoSet, 0, NativeFunctionInfo::Strict)));`
`174`	`192`	`ObjectPropertyDescriptor desc(gs, ObjectPropertyDescriptor::ConfigurablePresent);`
`175`	`193`	`defineOwnProperty(state, ObjectPropertyName(context->staticStrings().stack), desc);`
	`194`	`+`
`176`	`195`	`if (fillStackInfo) {`
	`196`	`+ // fill stack info at the creation of Error object rather than the moment of thrown`
`177`	`197`	`updateStackTraceData(state);`
`178`	`198`	`}`
`179`	`199`	`}`
`@@ -185,54 +205,54 @@ void ErrorObject::updateStackTraceData(ExecutionState& state)`
`185`	`205`	`setStackTraceData(StackTraceData::create(stackTraceDataVector));`
`186`	`206`	`}`
`187`	`207`
`188`		`-ReferenceErrorObject::ReferenceErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`189`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`208`	`+ReferenceErrorObject::ReferenceErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`209`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`190`	`210`	`{`
`191`	`211`	`}`
`192`	`212`
`193`		`-TypeErrorObject::TypeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`194`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`213`	`+TypeErrorObject::TypeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`214`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`195`	`215`	`{`
`196`	`216`	`}`
`197`	`217`
`198`		`-RangeErrorObject::RangeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`199`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`218`	`+RangeErrorObject::RangeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`219`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`200`	`220`	`{`
`201`	`221`	`}`
`202`	`222`
`203`		`-SyntaxErrorObject::SyntaxErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`204`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`223`	`+SyntaxErrorObject::SyntaxErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`224`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`205`	`225`	`{`
`206`	`226`	`}`
`207`	`227`
`208`		`-URIErrorObject::URIErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`209`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`228`	`+URIErrorObject::URIErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`229`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`210`	`230`	`{`
`211`	`231`	`}`
`212`	`232`
`213`		`-EvalErrorObject::EvalErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`214`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`233`	`+EvalErrorObject::EvalErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`234`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`215`	`235`	`{`
`216`	`236`	`}`
`217`	`237`
`218`		`-AggregateErrorObject::AggregateErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`219`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`238`	`+AggregateErrorObject::AggregateErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`239`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`220`	`240`	`{`
`221`	`241`	`}`
`222`	`242`
`223`	`243`	`#if defined(ENABLE_WASM)`
`224`		`-WASMCompileErrorObject::WASMCompileErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`225`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`244`	`+WASMCompileErrorObject::WASMCompileErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`245`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`226`	`246`	`{`
`227`	`247`	`}`
`228`	`248`
`229`		`-WASMLinkErrorObject::WASMLinkErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`230`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`249`	`+WASMLinkErrorObject::WASMLinkErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`250`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`231`	`251`	`{`
`232`	`252`	`}`
`233`	`253`
`234`		`-WASMRuntimeErrorObject::WASMRuntimeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo)`
`235`		`- : ErrorObject(state, proto, errorMessage, fillStackInfo)`
	`254`	`+WASMRuntimeErrorObject::WASMRuntimeErrorObject(ExecutionState& state, Object* proto, String* errorMessage, bool fillStackInfo, bool triggerCallback)`
	`255`	`+ : ErrorObject(state, proto, errorMessage, fillStackInfo, triggerCallback)`
`236`	`256`	`{`
`237`	`257`	`}`
`238`	`258`	`#endif`