sys: make SystemError own its strings via OwnedString

src/jsc/SystemError.rs

@@ -1,54 +1,65 @@
 use core::ffi::c_int;
 use core::fmt;
 
-use bun_core::String;
+use bun_core::{OwnedString, String};
 
 use crate::{JSGlobalObject, JSPromise, JSValue};
 
 #[repr(C)]
+#[derive(Clone)]
 pub struct SystemError {
     pub errno: c_int,
     /// label for errno
-    pub code: String,
+    pub code: OwnedString,
     /// it is illegal to have an empty message
-    pub message: String,
-    pub path: String,
-    pub syscall: String,
-    pub hostname: String,
+    pub message: OwnedString,
+    pub path: OwnedString,
+    pub syscall: OwnedString,
+    pub hostname: OwnedString,
     /// MinInt = no file descriptor
     pub fd: c_int,
-    pub dest: String,
+    pub dest: OwnedString,
 }
 
 impl Default for SystemError {
     fn default() -> Self {
         Self {
             errno: 0,
-            code: String::default(),
-            message: String::default(),
-            path: String::default(),
-            syscall: String::default(),
-            hostname: String::default(),
+            code: OwnedString::default(),
+            message: OwnedString::default(),
+            path: OwnedString::default(),
+            syscall: OwnedString::default(),
+            hostname: OwnedString::default(),
             fd: c_int::MIN,
-            dest: String::default(),
+            dest: OwnedString::default(),
         }
     }
 }
 
-/// Reshape the T1 `bun_sys::SystemError` (non-`#[repr(C)]`, different field
-/// order) into the `#[repr(C)]` extern layout C++ reads. Data (T1) is split
-/// from the JSC bridge (T6) — this `From` is the canonical layering seam.
+/// Reshape the T1 `bun_sys::SystemError` into the `#[repr(C)]` extern layout
+/// C++ reads. Data (T1) is split from the JSC bridge (T6) — this `From` is
+/// the canonical layering seam.
 impl From<bun_sys::SystemError> for SystemError {
     fn from(e: bun_sys::SystemError) -> Self {
+        let bun_sys::SystemError {
+            errno,
+            code,
+            message,
+            path,
+            syscall,
+            hostname,
+            fd,
+            dest,
+        } = e;
         Self {
-            errno: e.errno as c_int,
-            code: e.code,
-            message: e.message,
-            path: e.path,
-            syscall: e.syscall,
-            hostname: e.hostname,
-            fd: e.fd as c_int,
-            dest: e.dest,
+            errno: errno as c_int,
+            code,
+            message,
+            path,
+            syscall,
+            hostname,
+            fd: fd.unwrap_or(c_int::MIN),
+            dest,
         }
     }
 }
@@ -73,49 +84,11 @@ impl SystemError {
         bun_sys::e_from_negated(self.errno)
     }
 
-    /// Releases one ref of every string field. Prefer letting
-    /// [`to_error_instance`](Self::to_error_instance) consume the value: this
-    /// is only for the paths that build no JS error at all.
-    pub fn deref(self) {
-        self.path.deref();
-        self.code.deref();
-        self.message.deref();
-        self.syscall.deref();
-        self.hostname.deref();
-        self.dest.deref();
-    }
-
-    pub fn ref_(&mut self) {
-        self.path.ref_();
-        self.code.ref_();
-        self.message.ref_();
-        self.syscall.ref_();
-        self.hostname.ref_();
-        self.dest.ref_();
-    }
-
-    /// Bitwise-copy + bump every `bun_core::String` ref.
-    /// `bun_core::String` has no `Clone` impl (intrusive WTF refcount), so
-    /// `#[derive(Clone)]` is unavailable; this is the manual equivalent.
-    pub fn dupe(&self) -> SystemError {
-        // SAFETY: `SystemError` is `#[repr(C)]` and every field is either `c_int`
-        // (trivially copyable) or `bun_core::String` — a `#[repr(C)]` smart-ptr
-        // whose bitwise copy is sound provided we immediately bump each ref
-        // (preventing a double-free on drop).
-        let mut v: SystemError = unsafe { core::ptr::read(self) };
-        v.ref_();
-        v
-    }
-
-    /// Converts to a JS `Error`, consuming `self`: each string field's ref is
-    /// released here, so converting the same `SystemError` twice would free
-    /// strings the first `Error` still holds. Take `self` by value so the
-    /// compiler rejects that; call [`dupe`](Self::dupe) when two `Error`s are
-    /// genuinely wanted.
+    /// Converts to a JS `Error`, consuming `self`. C++ only borrows the string
+    /// fields; `Drop` releases them when `self` goes out of scope. `.clone()`
+    /// first when two `Error`s are genuinely wanted.
     pub fn to_error_instance(self, global: &JSGlobalObject) -> JSValue {
-        let result = SystemError__toErrorInstance(&self, global);
-        self.deref();
-        result
+        SystemError__toErrorInstance(&self, global)
     }
 
     /// Like `to_error_instance` but populates the error's stack trace with async
@@ -152,9 +125,7 @@ impl SystemError {
     /// implementing follows this convention. It is exclusively used
     /// to match the error code that `node:os` throws.
     pub fn to_error_instance_with_info_object(self, global: &JSGlobalObject) -> JSValue {
-        let result = SystemError__toErrorInstanceWithInfoObject(&self, global);
-        self.deref();
-        result
+        SystemError__toErrorInstanceWithInfoObject(&self, global)
     }
 }
 
@@ -173,8 +144,8 @@ pub fn verify_error_to_js(
     let reason: &[u8] = err.reason_bytes();
 
     let fallback = SystemError {
-        code: String::clone_utf8(code),
-        message: String::clone_utf8(reason),
+        code: String::clone_utf8(code).into(),
+        message: String::clone_utf8(reason).into(),
         ..Default::default()
     };
 

src/runtime/api/bun/js_bun_spawn_bindings.rs

@@ -53,22 +53,6 @@ fn signal_code_from_js(val: JSValue, global: &JSGlobalObject) -> JsResult<Signal
     bun_sys_jsc::signal_code_jsc::from_js(val, global)
 }
 
-/// Convert a `bun_sys::SystemError` (T1 stub shape) into the C-ABI
-/// `bun_jsc::SystemError` and materialize a JS Error instance.
-fn sys_system_error_to_js(err: &bun_sys::SystemError, global: &JSGlobalObject) -> JSValue {
-    let jsc_err = SystemError {
-        errno: err.errno,
-        code: err.code,
-        message: err.message,
-        path: err.path,
-        syscall: err.syscall,
-        hostname: err.hostname,
-        fd: err.fd,
-        dest: err.dest,
-    };
-    jsc_err.to_error_instance(global)
-}
-
 /// `Terminal.CreateResult` — local mirror that flattens `IntrusiveRc<Terminal>`
 /// to a `BackRef<Terminal>` used by `Subprocess.terminal`, so the scopeguard /
 /// field-assignment paths share one pointer type with `existing_terminal`.
@@ -1211,7 +1195,8 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             } else {
                 -UV_E::NFILE
             };
-            return Err(global_this.throw_value(sys_system_error_to_js(&systemerror, global_this)));
+            return Err(global_this
+                .throw_value(SystemError::from(systemerror).to_error_instance(global_this)));
         }
         Err(err) => {
             // See EMFILE arm above.
@@ -1241,8 +1226,9 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
                             if errno == sys::Errno::ENOENT {
                                 systemerror.errno = -UV_E::NOENT;
                             }
-                            return Err(global_this
-                                .throw_value(sys_system_error_to_js(&systemerror, global_this)));
+                            return Err(global_this.throw_value(
+                                SystemError::from(systemerror).to_error_instance(global_this),
+                            ));
                         }
                     }
                     _ => {}
@@ -2076,14 +2062,12 @@ fn throw_command_not_found(global_this: &JSGlobalObject, command: &[u8]) -> JsEr
         message: BunString::create_format(format_args!(
             "Executable not found in $PATH: \"{}\"",
             bstr::BStr::new(command)
-        )),
-        code: BunString::static_("ENOENT"),
+        ))
+        .into(),
+        code: BunString::static_("ENOENT").into(),
         errno: -UV_E::NOENT,
-        path: BunString::clone_utf8(command),
-        syscall: BunString::EMPTY,
-        hostname: BunString::EMPTY,
-        fd: -1,
-        dest: BunString::EMPTY,
+        path: BunString::clone_utf8(command).into(),
+        ..Default::default()
     };
     global_this.throw_value(err.to_error_instance(global_this))
 }

src/runtime/api/html_rewriter.rs

@@ -60,8 +60,8 @@ fn cell_get<'a, T>(cell: &Cell<*mut T>) -> Option<&'a mut T> {
 /// Construct a `SystemError` with code+message and remaining fields defaulted.
 fn system_error(code: &'static str, message: &'static str) -> SystemError {
     SystemError {
-        code: BunString::static_(code),
-        message: BunString::static_(message),
+        code: BunString::static_(code).into(),
+        message: BunString::static_(message).into(),
         ..Default::default()
     }
 }

src/runtime/dns_jsc/cares_jsc.rs

@@ -679,10 +679,10 @@ impl ErrorDeferred {
         };
         let system_error = SystemError {
             errno: self.errno as i32,
-            code: bstr::String::static_(code),
-            message,
-            syscall: bstr::String::clone_utf8(self.syscall),
-            hostname: self.hostname.take().unwrap_or(bstr::String::empty()),
+            code: bstr::String::static_(code).into(),
+            message: message.into(),
+            syscall: bstr::String::clone_utf8(self.syscall).into(),
+            hostname: self.hostname.take().unwrap_or(bstr::String::empty()).into(),
             ..Default::default()
         };
 
@@ -765,13 +765,14 @@ pub(crate) fn error_to_js_with_syscall(
     let code = this.code();
     let instance = SystemError {
         errno: this as i32,
-        code: bstr::String::static_(&code[4..]),
-        syscall: bstr::String::static_(syscall),
+        code: bstr::String::static_(&code[4..]).into(),
+        syscall: bstr::String::static_(syscall).into(),
         message: bstr::String::create_format(format_args!(
             "{} {}",
             BStr::new(syscall),
             BStr::new(&code[4..])
-        )),
+        ))
+        .into(),
         ..Default::default()
     }
     .to_error_instance(global_this);
@@ -796,15 +797,16 @@ pub(crate) fn system_error_with_syscall_and_hostname(
     let code = this.code();
     SystemError {
         errno: this as i32,
-        code: bstr::String::static_(&code[4..]),
+        code: bstr::String::static_(&code[4..]).into(),
         message: bstr::String::create_format(format_args!(
             "{} {} {}",
             BStr::new(syscall),
             BStr::new(&code[4..]),
             BStr::new(hostname)
-        )),
-        syscall: bstr::String::static_(syscall),
-        hostname: bstr::String::clone_utf8(hostname),
+        ))
+        .into(),
+        syscall: bstr::String::static_(syscall).into(),
+        hostname: bstr::String::clone_utf8(hostname).into(),
         ..Default::default()
     }
 }

src/runtime/dns_jsc/dns.rs

@@ -4746,13 +4746,9 @@ impl Resolver {
             ChannelResult::Err(err) => {
                 let system_error = SystemError {
                     errno: -1,
-                    code: bun_core::String::static_(err.code()),
-                    message: bun_core::String::static_(err.label()),
-                    path: bun_core::String::default(),
-                    syscall: bun_core::String::default(),
-                    hostname: bun_core::String::default(),
-                    fd: -1,
-                    dest: bun_core::String::default(),
+                    code: bun_core::String::static_(err.code()).into(),
+                    message: bun_core::String::static_(err.label()).into(),
+                    ..Default::default()
                 };
                 Err(global_this.throw_value(system_error.to_error_instance(global_this)))
             }
@@ -5453,17 +5449,12 @@ impl Resolver {
             ChannelResult::Result(res) => res,
             ChannelResult::Err(err) => {
                 let syscall = bun_core::String::create_atom(&query.name);
-                // SystemError has no Default impl upstream; spell out
-                // the field defaults (empty strings, fd = c_int::MIN).
                 let system_error = SystemError {
                     errno: -1,
-                    code: bun_core::String::static_(err.code()),
-                    message: bun_core::String::static_(err.label()),
-                    path: bun_core::String::empty(),
-                    syscall,
-                    hostname: bun_core::String::empty(),
-                    fd: c_int::MIN,
-                    dest: bun_core::String::empty(),
+                    code: bun_core::String::static_(err.code()).into(),
+                    message: bun_core::String::static_(err.label()).into(),
+                    syscall: syscall.into(),
+                    ..Default::default()
                 };
                 return Err(global_this.throw_value(system_error.to_error_instance(global_this)));
             }

src/runtime/ffi/ffi_body.rs

@@ -1514,14 +1514,10 @@ impl FFI {
                             )
                             .ok();
                             let system_error = SystemError {
-                                code: bun_core::String::clone_utf8(b"ERR_DLOPEN_FAILED"),
-                                message: bun_core::String::clone_utf8(&msg),
-                                syscall: bun_core::String::clone_utf8(b"dlopen"),
-                                errno: 0,
-                                path: bun_core::String::EMPTY,
-                                hostname: bun_core::String::EMPTY,
-                                fd: -1,
-                                dest: bun_core::String::EMPTY,
+                                code: bun_core::String::clone_utf8(b"ERR_DLOPEN_FAILED").into(),
+                                message: bun_core::String::clone_utf8(&msg).into(),
+                                syscall: bun_core::String::clone_utf8(b"dlopen").into(),
+                                ..Default::default()
                             };
                             return system_error.to_error_instance(global);
                         }

src/runtime/node/node_fs.rs

@@ -8071,14 +8071,10 @@ impl NodeFS {
                 );
                 let _ = global_this.throw_value(
                     bun_jsc::SystemError {
-                        errno: 0,
-                        message: BunString::init(&buf[..]),
-                        code: BunString::init(err.name()),
-                        path: BunString::init(path.as_slice()),
-                        syscall: BunString::default(),
-                        hostname: BunString::default(),
-                        fd: -1,
-                        dest: BunString::default(),
+                        message: BunString::init(&buf[..]).into(),
+                        code: BunString::init(err.name()).into(),
+                        path: BunString::init(path.as_slice()).into(),
+                        ..Default::default()
                     }
                     .to_error_instance(&global_this),
                 );