Downcast a JsValue to an exported struct

[io12]

Summary

In the code below, how can I cast the JsValue to Foo?

#[wasm_bindgen]
pub struct Foo(u8); // Assume this can't be serialized or deserialized

#[wasm_bindgen]
pub fn foo_downcast(foo: JsValue) {
    let foo: Foo = todo!();
    // ...
}

Additional Details

From<Foo> for JsValue is implemented automatically, so I'd expect something like TryInto<Foo> for JsValue to be implemented too, but I couldn't find anything.

Reasons why you'd want to do this

1. Passing a vector or slice of objects to an exported function (currently Vec<Foo> and &[Foo] are unsupported, but Vec<JsValue> and &[JsValue] are supported, I think)
2. Having automatic casting rules for parameters of exported functions (automatically parsing strings if the parameter is a string, etc)

[alexcrichton]

Ah yeah currently this isn't implemented. It would require an intrinsic of one form or another since the JS class lives in the JS file to test inheritance. This would be a nice feature to have though!

[aweinstock314]

We've developed a workaround that discovers the runtime class name through .__proto__.constructor.name:

use wasm_bindgen::convert::FromWasmAbi;
pub fn generic_of_jsval<T: FromWasmAbi<Abi=u32>>(js: JsValue, classname: &str) -> Result<T, JsValue> {
    use js_sys::{Object, Reflect};
    let ctor_name = Object::get_prototype_of(&js).constructor().name();
    if ctor_name == classname {
        let ptr = Reflect::get(&js, &JsValue::from_str("ptr"))?;
        let ptr_u32: u32 = ptr.as_f64().ok_or(JsValue::NULL)? as u32;
        let foo = unsafe { T::from_abi(ptr_u32) };
        Ok(foo)
    } else {
        Err(JsValue::NULL)
    }
}
#[wasm_bindgen]
pub fn foo_of_jsval(js: JsValue) -> Option<Foo> {
    generic_of_jsval(js, "Foo").unwrap_or(None)
}

Currently, "Foo" needs to be hard-coded in the snippet since the #[wasm_bindgen] derive macro doesn't generate a way to refer to it programatically. It looks like the ToTokens impl for ast::Struct (

wasm-bindgen/crates/backend/src/codegen.rs

Line 139 in 1795020

let name_str = self.js_name.to_string();

) has a js_name that could be added. Would adding another trait to wasm_bindgen::convert that exposes this metadata and generating it from the derive macro be the preferred way to do this?

Also, should the method that performs the downcast be added to wasm_bindgen itself (possibly to the same wasm_bindgen::convert trait, if we're adding a new one), or to a different component like js_sys?

[fxdave]

We've developed a workaround that discovers the runtime class name through .__proto__.constructor.name:

use wasm_bindgen::convert::FromWasmAbi;
pub fn generic_of_jsval<T: FromWasmAbi<Abi=u32>>(js: JsValue, classname: &str) -> Result<T, JsValue> {
    use js_sys::{Object, Reflect};
    let ctor_name = Object::get_prototype_of(&js).constructor().name();
    if ctor_name == classname {
        let ptr = Reflect::get(&js, &JsValue::from_str("ptr"))?;
        let ptr_u32: u32 = ptr.as_f64().ok_or(JsValue::NULL)? as u32;
        let foo = unsafe { T::from_abi(ptr_u32) };
        Ok(foo)
    } else {
        Err(JsValue::NULL)
    }
}
#[wasm_bindgen]
pub fn foo_of_jsval(js: JsValue) -> Option<Foo> {
    generic_of_jsval(js, "Foo").unwrap_or(None)
}

Currently, "Foo" needs to be hard-coded in the snippet since the #[wasm_bindgen] derive macro doesn't generate a way to refer to it programatically. It looks like the ToTokens impl for ast::Struct (

wasm-bindgen/crates/backend/src/codegen.rs

Line 139 in 1795020

let name_str = self.js_name.to_string();

) has a js_name that could be added. Would adding another trait to wasm_bindgen::convert that exposes this metadata and generating it from the derive macro be the preferred way to do this?
Also, should the method that performs the downcast be added to wasm_bindgen itself (possibly to the same wasm_bindgen::convert trait, if we're adding a new one), or to a different component like js_sys?

Thanks for this workaround. It works, however, I get this error message: Uncaught Error: recursive use of an object detected which would lead to unsafe aliasing in rust for this line:
let foo = unsafe { T::from_abi(ptr_u32) };.

I don't know why. Any ideas?

[io12]

It works, however, I get this error message: Uncaught Error: recursive use of an object detected which would lead to unsafe aliasing

This might be relevant #1578 (comment).

[fxdave]

It works, however, I get this error message: Uncaught Error: recursive use of an object detected which would lead to unsafe aliasing

This might be relevant #1578 (comment).

Thanks, the situation was a bit different. After checking the source code, the error meant 3 possible things:

1. Multiple &mut Ts exist.
2. &T and &mut T exist at the same time.
3. An enormous amount of &T exist (and its borrow count doesn't fit in the usize).
   (if this were in the error message, that would help)

However, none of the above was true in my case. In my case, I dispatched a custom event, and there were two listeners for that event. Thus the event.detail(), a JsValue holding T was owned twice. At least, I guess this was the problem because I removed the other listener, and it is fine now.

[AlexW00]

We've developed a workaround that discovers the runtime class name through .__proto__.constructor.name:

use wasm_bindgen::convert::FromWasmAbi;
pub fn generic_of_jsval<T: FromWasmAbi<Abi=u32>>(js: JsValue, classname: &str) -> Result<T, JsValue> {
    use js_sys::{Object, Reflect};
    let ctor_name = Object::get_prototype_of(&js).constructor().name();
    if ctor_name == classname {
        let ptr = Reflect::get(&js, &JsValue::from_str("ptr"))?;
        let ptr_u32: u32 = ptr.as_f64().ok_or(JsValue::NULL)? as u32;
        let foo = unsafe { T::from_abi(ptr_u32) };
        Ok(foo)
    } else {
        Err(JsValue::NULL)
    }
}
#[wasm_bindgen]
pub fn foo_of_jsval(js: JsValue) -> Option<Foo> {
    generic_of_jsval(js, "Foo").unwrap_or(None)
}

Currently, "Foo" needs to be hard-coded in the snippet since the #[wasm_bindgen] derive macro doesn't generate a way to refer to it programatically. It looks like the ToTokens impl for ast::Struct (

wasm-bindgen/crates/backend/src/codegen.rs

Line 139 in 1795020

let name_str = self.js_name.to_string();

) has a js_name that could be added. Would adding another trait to wasm_bindgen::convert that exposes this metadata and generating it from the derive macro be the preferred way to do this?
Also, should the method that performs the downcast be added to wasm_bindgen itself (possibly to the same wasm_bindgen::convert trait, if we're adding a new one), or to a different component like js_sys?

Thanks for this workaround. It works, however, I get this error message: Uncaught Error: recursive use of an object detected which would lead to unsafe aliasing in rust for this line: let foo = unsafe { T::from_abi(ptr_u32) };.

I don't know why. Any ideas?

Got the same error. However, I neither have callbacks nor multiple ownership in my code. I already spent a few hours trying to fix this error, but I am simply stuck. Does anyone have an idea, where this error might come from?
In my code, the generic_of_jsval function works once. When I call it a second time, i get the error:

Error: recursive use of an object detected which would lead to unsafe aliasing in rust

Here is the relevant code:

Calling the generic_of_jsval function:

// ignore getter as defined in another struct:
#[wasm_bindgen(getter)]
pub fn ignore(&self) -> RangeArray {
    self.ignore.clone()
}

// calling the from function, which then calls generic_of_jsval  (see below):
pub fn ignore_vec (&self) -> Vec<Range> { Vec::from(self.ignore()) }

Definitions:

#[wasm_bindgen]
#[derive(Clone)]
pub struct Range {
    start: js_sys::Number,
    end: js_sys::Number,
}

#[wasm_bindgen]
impl Range {
    #[wasm_bindgen(constructor)]
    pub fn new(start: js_sys::Number, end: js_sys::Number) -> Range {
        Range {
            start,
            end,
        }
    }

    #[wasm_bindgen(getter)]
    pub fn start(&self) -> js_sys::Number {
        self.start.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn end(&self) -> js_sys::Number {
        self.end.clone()
    }

}

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(typescript_type = "Array<Range>")]
    #[derive(Clone, Debug)]
    pub type RangeArray;
}


impl From<RangeArray> for Vec<Range> {
    fn from(range_array: RangeArray) -> Self {
        let arr: Result<Array, RangeArray> = range_array.dyn_into::<Array>();
        arr.map_or(vec![], |array: Array| {
            array.iter()
                .filter_map(|js_val_range: JsValue|
                    generic_of_jsval(js_val_range, "Range").ok())
                .collect()
        })
    }
}

[AlexKorn]

We've developed a workaround that discovers the runtime class name through .__proto__.constructor.name:

use wasm_bindgen::convert::FromWasmAbi;
pub fn generic_of_jsval<T: FromWasmAbi<Abi=u32>>(js: JsValue, classname: &str) -> Result<T, JsValue> {
    use js_sys::{Object, Reflect};
    let ctor_name = Object::get_prototype_of(&js).constructor().name();
    if ctor_name == classname {
        let ptr = Reflect::get(&js, &JsValue::from_str("ptr"))?;
        let ptr_u32: u32 = ptr.as_f64().ok_or(JsValue::NULL)? as u32;
        let foo = unsafe { T::from_abi(ptr_u32) };
        Ok(foo)
    } else {
        Err(JsValue::NULL)
    }
}
#[wasm_bindgen]
pub fn foo_of_jsval(js: JsValue) -> Option<Foo> {
    generic_of_jsval(js, "Foo").unwrap_or(None)
}

Currently, "Foo" needs to be hard-coded in the snippet since the #[wasm_bindgen] derive macro doesn't generate a way to refer to it programatically. It looks like the ToTokens impl for ast::Struct (

wasm-bindgen/crates/backend/src/codegen.rs

Line 139 in 1795020

let name_str = self.js_name.to_string();

) has a js_name that could be added. Would adding another trait to wasm_bindgen::convert that exposes this metadata and generating it from the derive macro be the preferred way to do this?
Also, should the method that performs the downcast be added to wasm_bindgen itself (possibly to the same wasm_bindgen::convert trait, if we're adding a new one), or to a different component like js_sys?

Thank you for workaround! You saved me a lot of time )
I modified it a bit to check whether we really get object (otherwise original function panics) and to produce reference to class instance:

pub fn generic_of_jsval<T: RefFromWasmAbi<Abi = u32>>(
  js: &JsValue,
  classname: &str,
) -> Result<T::Anchor, JsValue> {
  if !js.is_object() {
    return Err(JsValue::from_str(
      format!("Value supplied as {} is not an object", classname).as_str(),
    ));
  }

  let ctor_name = Object::get_prototype_of(js).constructor().name();
  if ctor_name == classname {
    let ptr = Reflect::get(js, &JsValue::from_str("ptr"))?;
    let ptr_u32: u32 = ptr.as_f64().ok_or(JsValue::NULL)? as u32;
    let foo = unsafe { T::ref_from_abi(ptr_u32) };
    Ok(foo)
  } else {
    Err(JsValue::NULL)
  }
}

Note that return type is now not T itself, but T::Anchor, that is defined as Deref<Target = Self>.

@fxdave @AlexW00 as I tested, it solves issue with Error: recursive use of an object detected which would lead to unsafe aliasing in rust. For AlexW00 sample, if you do not mind cloning, invocation may be changed to

generic_of_jsval(js_val_range, "Range").ok().clone()

[anlumo]

@AlexKorn One problem with your solution I just ran into is that when I build my code for production, the minimizer changes the name of my struct to H, so the constructor name check fails (but only when building for production, fun to discover).

So, I'm currently trying to find a way to get the current JavaScript class name for my Rust struct.

[AlexKorn]

Got the same problem )
Our solution for now was to turn off minification for the library (by setting it as external dep in webpack and linking it manually in app).
The problem is that class name is specified in rust source, so it appears to be compiled in wasm and is not accessible to minifier.
One hacky solution comes to my mind: our library should make http requests, and to make it possible from both node & browser I added inititialization function in library's index.js that passes wrappers around axios to wasm module, something similar may be used that will pass class names for example as hashmap: as it will be invoked from javascript, it will be visible to minifier and minifier will change class names respectively. It's ugly, but it should work.

UPD: something less hacky: add wasm-exported method to each struct that just returns its classname, ex. get_classname, and generic_of_jsval may try to get this name from JsValue as first step. This may be easily made as derive macro.

[anlumo]

For now, I just went the easy way of marking the function unsafe and removing all checks. In my application, I'm certain that I'm getting the right type there anyways.