Error.captureStackTrace: lazily compute .stack header on non-Error targets

src/js/builtins/BunBuiltinNames.h

@@ -61,6 +61,7 @@ using namespace JSC;
     macro(byobRequest) \
     macro(bytes) \
     macro(cancel) \
+    macro(capturedStackTrace) \
     macro(checkBufferRead) \
     macro(checks) \
     macro(cloneArrayBuffer) \

src/jsc/bindings/CallSite.cpp

@@ -125,6 +125,10 @@ void CallSite::formatAsString(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WT
     std::optional<OrdinalNumber> column = columnNumber().zeroBasedInt() >= 0 ? std::optional(columnNumber()) : std::nullopt;
     std::optional<OrdinalNumber> line = lineNumber().zeroBasedInt() >= 0 ? std::optional(lineNumber()) : std::nullopt;
 
+    if (isAsync()) {
+        sb.append("async "_s);
+    }
+
     if (functionName.length() > 0) {
 
         if (isConstructor()) {

src/jsc/bindings/FormatStackTraceForJS.cpp

@@ -41,21 +41,36 @@
 
     WTF::StringBuilder sb;
 
+    WTF::String name = "Error"_s;
+    auto errorName = errorObject->getIfPropertyExists(lexicalGlobalObject, vm.propertyNames->name);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (errorName && !errorName.isUndefined()) {
+        auto* str = errorName.toString(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+        auto value = str->value(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+        name = value.data;
+    }
+
+    WTF::String message;
     auto errorMessage = errorObject->getIfPropertyExists(lexicalGlobalObject, vm.propertyNames->message);
     RETURN_IF_EXCEPTION(scope, {});
-    if (errorMessage) {
+    if (errorMessage && !errorMessage.isUndefined()) {
         auto* str = errorMessage.toString(lexicalGlobalObject);
         RETURN_IF_EXCEPTION(scope, {});
-        if (str->length() > 0) {
-            auto value = str->view(lexicalGlobalObject);
-            RETURN_IF_EXCEPTION(scope, {});
-            sb.append("Error: "_s);
-            sb.append(value.data);
-        } else {
-            sb.append("Error"_s);
-        }
+        auto value = str->value(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+        message = value.data;
+    }
+
+    if (name.isEmpty()) {
+        sb.append(message);
+    } else if (message.isEmpty()) {
+        sb.append(name);
     } else {
-        sb.append("Error"_s);
+        sb.append(name);
+        sb.append(": "_s);
+        sb.append(message);
     }
 
     for (size_t i = 0; i < framesCount; i++) {
@@ -428,7 +443,7 @@
     return Bun::formatStackTrace(vm, globalObject, lexicalGlobalObject, name, message, line, column, sourceURL, stackTrace, errorInstance);
 }
 
-static JSValue computeErrorInfoWithPrepareStackTrace(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, Vector<StackFrame>& stackFrames, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorObject, JSObject* prepareStackTrace)
+static JSArray* buildSourceMappedCallSitesArray(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, Vector<StackFrame>& stackFrames)
 {
     auto scope = DECLARE_THROW_SCOPE(vm);
 
@@ -513,6 +528,19 @@
     JSArray* callSitesArray = JSC::constructArray(globalObject, globalObject->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous), callSites);
     RETURN_IF_EXCEPTION(scope, {});
 
+    return callSitesArray;
+}
+
+static JSValue computeErrorInfoWithPrepareStackTrace(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, Vector<StackFrame>& stackFrames, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorObject, JSObject* prepareStackTrace)
+{
+    UNUSED_PARAM(line);
+    UNUSED_PARAM(column);
+    UNUSED_PARAM(sourceURL);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSArray* callSitesArray = buildSourceMappedCallSitesArray(vm, globalObject, lexicalGlobalObject, stackFrames);
+    RETURN_IF_EXCEPTION(scope, {});
+
     RELEASE_AND_RETURN(scope, formatStackTraceToJSValue(vm, globalObject, lexicalGlobalObject, errorObject, callSitesArray, prepareStackTrace));
 }
 
@@ -756,6 +784,73 @@
     return true;
 }
 
+JSC_DEFINE_CUSTOM_GETTER(nonErrorInstanceLazyStackCustomGetter, (JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, PropertyName))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSObject* receiver = JSValue::decode(thisValue).getObject();
+    if (!receiver) [[unlikely]]
+        return JSValue::encode(jsUndefined());
+
+    const auto& privateName = WebCore::builtinNames(vm).capturedStackTracePrivateName();
+    JSObject* errorObject = nullptr;
+    JSC::JSArray* callSites = nullptr;
+    for (JSObject* o = receiver; o;) {
+        JSValue v = o->getDirect(vm, privateName);
+        if (v && v.isNull())
+            return JSValue::encode(jsUndefined());
+        if (auto* arr = v ? dynamicDowncast<JSC::JSArray>(v) : nullptr) {
+            callSites = arr;
+            errorObject = o;
+            break;
+        }
+        JSValue proto = o->getPrototypeDirect();
+        o = proto.isObject() ? asObject(proto) : nullptr;
+    }
+    if (!callSites) [[unlikely]]
+        return JSValue::encode(jsUndefined());
+
+    JSC::EnsureStillAliveScope keepCallSites(callSites);
+
+    // Sentinel so re-entry through a name/message getter hits the isNull check above; restored if the user code throws.
+    errorObject->putDirect(vm, privateName, jsNull(), 0);
+
+    auto* globalObject = defaultGlobalObject(lexicalGlobalObject);
+
+    JSValue result;
+    if (globalObject->isInsideErrorPrepareStackTraceCallback) {
+        result = formatStackTraceToJSValue(vm, globalObject, lexicalGlobalObject, errorObject, callSites);
+    } else {
+        globalObject->isInsideErrorPrepareStackTraceCallback = true;
+        result = formatStackTraceToJSValueWithoutPrepareStackTrace(vm, globalObject, lexicalGlobalObject, errorObject, callSites);
+        globalObject->isInsideErrorPrepareStackTraceCallback = false;
+    }
+    if (scope.exception()) [[unlikely]] {
+        unsigned attrs = 0;
+        JSValue currentStack = errorObject->getDirect(vm, vm.propertyNames->stack, attrs);
+        if (currentStack && (attrs & JSC::PropertyAttribute::CustomAccessor))
+            errorObject->putDirect(vm, privateName, callSites, 0);
+        else
+            errorObject->putDirect(vm, privateName, jsUndefined(), 0);
+        return {};
+    }
+
+    errorObject->putDirect(vm, vm.propertyNames->stack, result, JSC::PropertyAttribute::DontEnum | 0);
+    errorObject->putDirect(vm, privateName, jsUndefined(), 0);
+    return JSValue::encode(result);
+}
+
+JSC_DEFINE_CUSTOM_SETTER(nonErrorInstanceLazyStackCustomSetter, (JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue, JSC::EncodedJSValue value, PropertyName))
+{
+    auto& vm = JSC::getVM(globalObject);
+    if (auto* object = JSValue::decode(thisValue).getObject()) {
+        object->putDirect(vm, vm.propertyNames->stack, JSValue::decode(value), JSC::PropertyAttribute::DontEnum | 0);
+        object->putDirect(vm, WebCore::builtinNames(vm).capturedStackTracePrivateName(), jsUndefined(), 0);
+    }
+    return true;
+}
+
 JSC_DEFINE_HOST_FUNCTION(errorConstructorFuncCaptureStackTrace, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
 {
     Zig::GlobalObject* globalObject = static_cast<Zig::GlobalObject*>(lexicalGlobalObject);
@@ -806,12 +901,19 @@
             instance->putDirectCustomAccessor(vm, vm.propertyNames->stack, globalObject->m_lazyStackCustomGetterSetter.get(globalObject), JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor | 0);
         }
     } else {
-        OrdinalNumber line;
-        OrdinalNumber column;
-        String sourceURL;
-        JSValue result = computeErrorInfoToJSValue(vm, stackTrace, line, column, sourceURL, errorObject, nullptr);
+        JSArray* callSitesArray = buildSourceMappedCallSitesArray(vm, globalObject, lexicalGlobalObject, stackTrace);
         RETURN_IF_EXCEPTION(scope, {});
-        errorObject->putDirect(vm, vm.propertyNames->stack, result, JSC::PropertyAttribute::DontEnum | 0);
+
+        {
+            const auto& propertyName = vm.propertyNames->stack;
+            VM::DeletePropertyModeScope deleteScope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
+            DeletePropertySlot slot;
+            JSObject::deleteProperty(errorObject, globalObject, propertyName, slot);
+        }
+        RETURN_IF_EXCEPTION(scope, {});
+
+        errorObject->putDirect(vm, WebCore::builtinNames(vm).capturedStackTracePrivateName(), callSitesArray, 0);
+        errorObject->putDirectCustomAccessor(vm, vm.propertyNames->stack, globalObject->m_nonErrorLazyStackCustomGetterSetter.get(globalObject), JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor | 0);
     }
 
     return JSC::JSValue::encode(JSC::jsUndefined());

src/jsc/bindings/FormatStackTraceForJS.h

@@ -78,6 +78,8 @@ JSC_DECLARE_HOST_FUNCTION(jsFunctionDefaultErrorPrepareStackTrace);
 // JSC Custom Accessors - error.stack getter/setter
 JSC_DECLARE_CUSTOM_GETTER(errorInstanceLazyStackCustomGetter);
 JSC_DECLARE_CUSTOM_SETTER(errorInstanceLazyStackCustomSetter);
+JSC_DECLARE_CUSTOM_GETTER(nonErrorInstanceLazyStackCustomGetter);
+JSC_DECLARE_CUSTOM_SETTER(nonErrorInstanceLazyStackCustomSetter);
 
 // Internal wrapper functions for JSC error info callbacks
 WTF::String computeErrorInfoWrapperToString(JSC::VM& vm, WTF::Vector<JSC::StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, WTF::String& sourceURL, void* bunErrorData);

src/jsc/bindings/ZigGlobalObject.cpp

@@ -2112,6 +2112,11 @@ void GlobalObject::finishCreation(VM& vm)
             init.set(CustomGetterSetter::create(init.vm, errorInstanceLazyStackCustomGetter, errorInstanceLazyStackCustomSetter));
         });
 
+    m_nonErrorLazyStackCustomGetterSetter.initLater(
+        [](const Initializer<CustomGetterSetter>& init) {
+            init.set(CustomGetterSetter::create(init.vm, nonErrorInstanceLazyStackCustomGetter, nonErrorInstanceLazyStackCustomSetter));
+        });
+
     m_JSDOMFileConstructor.initLater(
         [](const Initializer<JSObject>& init) {
             JSObject* fileConstructor = Bun::createJSDOMFileConstructor(init.vm, init.owner);

src/jsc/bindings/ZigGlobalObject.h

@@ -659,6 +659,7 @@ class GlobalObject : public Bun::GlobalScope {
     V(public, LazyPropertyOfGlobalObject<JSObject>, m_performanceObject)                                     \
     V(public, LazyPropertyOfGlobalObject<Bun::Process>, m_processObject)                                     \
     V(public, LazyPropertyOfGlobalObject<CustomGetterSetter>, m_lazyStackCustomGetterSetter)                 \
+    V(public, LazyPropertyOfGlobalObject<CustomGetterSetter>, m_nonErrorLazyStackCustomGetterSetter)         \
     V(public, LazyPropertyOfGlobalObject<Structure>, m_ServerRouteListStructure)                             \
     V(public, LazyPropertyOfGlobalObject<Structure>, m_JSBunRequestStructure)                                \
     V(public, LazyPropertyOfGlobalObject<JSObject>, m_JSBunRequestParamsPrototype)                           \