Is it possible to create an object-safe userdata trait?

[Dark42ed]

Hello, apologies if this is a beginner (or unrelated) post.

I have a trait Object described here, which needs to be object safe (dyn Object). Additionally it needs to be passed to lua in an Rc<RefCell<dyn Object>>, and all implementors of Object also implement Userdata. My problem here is that I cannot have UserData be a supertrait of Object since it makes Object non-object safe.

//            Non object safe
//                 vvvvv
pub trait Object: UserData {
  // Object safe methods
}

pub struct ConcreteObject {}
impl Object for ConcreteObject {}
impl UserData for ConcreteObject {}

It is possible to convert it into a userdata with Lua::create_any_userdata and Lua::register_userdata_type, however the problem is that lua won't use the UserData impl for ConcreteObject, but instead for dyn Object. Additionally I can of course pass ConcreteObject as an Rc<RefCell<ConcreteObject>> into lua, but then if say OtherConcreteObject needs to take it as a parameter I must specify Rc<RefCell<ConcreteObject>> rather than Rc<RefCell<dyn Object>>, so I would have to try borrowing it for each concrete object essentially turning it into an enum.

I could of course create an Enum of all Objects, but I would rather not as it makes it harder to use and it cannot be extended from outside libraries. Also thought I should mention I'm not too worried about the performance of dynamic dispatch. If it is impossible to do what I'm attempting however I'll just end up making an enum.

Am I overlooking something? Or is there just no way at the moment to do this with mlua? Thanks for help in advance, and if you need any clarification feel free to ask.

[khvzak]

You can implement UserData for Box<dyn Object> and pass any instances of dyn Object into Lua:

trait Object {}

struct ConcreteObject;
impl Object for ConcreteObject {}

impl UserData for Box<dyn Object> {}

let ud = lua.create_userdata::<Box<dyn Object>>(Box::new(ConcreteObject))?;

You probably should not use UserData as a supertrait because it only used as a method(s) registry and does not have any instance methods (this is why it cannot be made into trait object).

[Dark42ed]

Hello, thanks for the quick reply!
Unfortunately the way you described doesn't work the way I expected since lua won't use the UserData impl for ConcreteObject, but instead for dyn Object, and so any fields/methods defined on ConcreteObject don't carry over to the dyn Object. I wanted to know if there was any way for each ConcreteObject to have their own UserData impl, and Object would be able to use that to convert into a lua object (or create a new AnyUserData and proxy method and property gets/sets into the concrete impl)

use mlua::{Lua, UserData, AnyUserData};

pub trait Object {
    fn print(&self);
}
impl UserData for Box<dyn Object> {}

pub struct ConcreteObject {}
impl Object for ConcreteObject {
    fn print(&self) {
        println!("I am ConcreteObject!!!");
    }
}
impl UserData for ConcreteObject {}

pub struct OtherObject {}
impl Object for OtherObject {
    fn print(&self) {
        println!("I am OtherObject!!");
    }
}
impl UserData for OtherObject {
    fn add_methods<'lua, M: mlua::prelude::LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_method("DoSomething", |_lua, this, other: AnyUserData| {
            let other = other.take::<Box<dyn Object>>()?;
            this.print();
            other.print();
            Ok(())
        });
    }
}

fn main() {
    let lua = Lua::new();

    let ud = lua.create_userdata::<Box<dyn Object>>(Box::new(ConcreteObject{})).unwrap();
    let ud2 = lua.create_userdata::<Box<dyn Object>>(Box::new(OtherObject{})).unwrap();
    let other = OtherObject{};

    lua.globals().set("object1", ud).unwrap();
    lua.globals().set("object2", ud2).unwrap();
    lua.globals().set("other", other).unwrap();

    lua.load("
        print(object1)
        print(object2)
        print(other)
        print(other.DoSomething)
        print(object2.DoSomething)
        object2:DoSomething(object2)
    ").exec().unwrap();
}

Outputs:

Box<dyn Object>: 0x0000025e297ac9a8
Box<dyn Object>: 0x0000025e297ac978
OtherObject: 0x0000025e297ac618
function: 0x0000025e297c7fd8
thread 'main' panicked at src\main.rs:51:15:
called `Result::unwrap()` on an `Err` value: RuntimeError("[string \"src\\main.rs:44:9\"]:6: attempt to index Box<dyn Object> with 'DoSomething'\nstack traceback:\n\t[C]: in ?\n\t[string \"src\\main.rs:44:9\"]:6: in ?")

This might be impossible with what I'm trying to do however, since reducing to a Box<dyn Object> removes any other information from the struct (which is why my original idea was to have UserData as a supertrait, to preserve that information as well).
Running other:DoSomething() would of course work but then I wouldn't be able downcast other into a Box, i would have to downcast to a Box<OtherObject> and then to a Box<dyn Object>, which defeats the purpose of having the dynamic dispatch.

[khvzak]

It's a bit non-trivial, but you can add proxying __index metatamethod to Box<dyn Object> to forward requests to target imlementation.
Something like this:

pub trait Object {
    fn print(&self);

    fn call_method<'l>(&self, lua: &'l Lua, name: &str, args: MultiValue<'l>) -> LuaResult<MultiValue<'l>>;
}

impl UserData for Box<dyn Object> {
    fn add_methods<'lua, M: mlua::prelude::LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_meta_function(MetaMethod::Index, |lua, (_, name): (AnyUserData, String)| {
            lua.create_function(move |lua, (this, args): (UserDataRef<Self>, MultiValue)| {
                this.call_method(lua, &name, args)
            })
        });
    }
}

pub struct ConcreteObject {}

impl Object for ConcreteObject {
    fn print(&self) {
        println!("I am ConcreteObject!!!");
    }

    fn call_method<'l>(&self, lua: &'l Lua, name: &str, args: MultiValue<'l>) -> LuaResult<MultiValue<'l>> {
        lua.scope(|scope| scope.create_userdata_ref(self)?.call_method(name, args))
    }
}

impl UserData for ConcreteObject {}

pub struct OtherObject {}

impl Object for OtherObject {
    fn print(&self) {
        println!("I am OtherObject!!");
    }

    fn call_method<'l>(&self, lua: &'l Lua, name: &str, args: MultiValue<'l>) -> LuaResult<MultiValue<'l>> {
        lua.scope(|scope| scope.create_userdata_ref(self)?.call_method(name, args))
    }
}

impl UserData for OtherObject {
    fn add_methods<'lua, M: mlua::prelude::LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_method("DoSomething", |_lua, this, other: AnyUserData| {
            let other = other.borrow::<Box<dyn Object>>()?;
            this.print();
            other.print();
            Ok(())
        });
    }
}