Error is not compatible with `Sync`/`Send`/`anyhow::Error` about serde-wasm-bindgen HOT 3 CLOSED

That looks reasonable, although note that Box<dyn std::error::Error> will be still prone to the same problem with erased backtrace (since it's an erased generic Rust error type).

Maybe store actual serde_wasm_bindgen::Error there instead?

Also note that you can use cfg on enum branches so the whole thing might be simplified to:

#[derive(Debug, Error)]
pub enum MyError {
	#[cfg(target_arch = "wasm32")]
    SerdeWasmBindgen(serde_wasm_bindgen::Error),
    // ...regular errors
}

This should also let Rust automatically implement Send on your error enum when possible (non-wasm32 targets), and !Send when not (wasm32) instead of you overriding it via manual unsafe impl.

from serde-wasm-bindgen.

In general, JsError / JsValue-based error is more useful in Wasm-related code because it creates a JS error with .stack correctly tracked by the JS engine and associated with the original thrown location inside Wasm. Rust backtraces can't provide that level of detail in Wasm, so creating errors from string at the last stage makes them much less useful for actual debugging.

That's why I prefer to do the opposite and convert JsError to string only when I really want to go from JS error to a Rust error and I'm okay with stripping the backtrace.

Most of the time, you also use serde-wasm-bindgen at the top level of the function exposed via #[wasm_bindgen] anyway, so as long as you're propagating it immediately to Result<..., JsValue>, the fact that JS values are not thread-safe shouldn't be a problem.

I wonder what your usecase is where this doesn't work.

from serde-wasm-bindgen.

In general, JsError / JsValue-based error is more useful in Wasm-related code because it creates a JS error with .stack correctly tracked by the JS engine and associated with the original thrown location inside Wasm. Rust backtraces can't provide that level of detail in Wasm, so creating errors from string at the last stage makes them much less useful for actual debugging.

That does indeed make a lot of sense!

I'm working on a cross-platform project that among several native targets also supports the web via wasm.

We're basically wrapping individual errors into a wrapper-enum error type in order to provide more fine-grained internal error-handling via thiserror.

It looks like I managed to make things work with this change:

Before:

#[derive(Debug, Error)]
pub enum MyError {
    SerdeWasmBindgen(Box<dyn std::error::Error + Send>),
    // ...
}

#[cfg(not(target_arch = "wasm32"))]
unsafe impl Send for MyError {}

After:

#[cfg(target_arch = "wasm32")]
type BoxedStdError = Box<dyn std::error::Error>;

#[cfg(not(target_arch = "wasm32"))]
type BoxedStdError = Box<dyn std::error::Error + Send>;

#[derive(Debug, Error)]
pub enum MyError {
    SerdeWasmBindgen(BoxedStdError),
    // ...
}

#[cfg(not(target_arch = "wasm32"))]
unsafe impl Send for MyError {}

from serde-wasm-bindgen.