Sharing UserData between Rust and Lua functions

[Luminoth]

Is there any way to make this example work?

#[derive(Debug, Default, Clone)]
struct SharedUserData {
    val: usize,
}

impl SharedUserData {
    fn get_val(&self) -> usize {
        self.val
    }

    fn incr_val(&mut self) {
        self.val += 1
    }
}

impl UserData for SharedUserData {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_method("get_val", |_, this, ()| Ok(this.get_val()));
        methods.add_method_mut("incr_val", |_, this, ()| {
            this.incr_val();
            Ok(())
        });
    }
}

fn shared_userdata_example() -> anyhow::Result<()> {
    let lua = Lua::new();

    let data = SharedUserData::default();

    lua.load(chunk! {
    function incr(data)
        print("[Lua]: Before = " .. data:get_val());
        data:incr_val();
        print("[Lua]: After = " .. data:get_val());
    end
    })
    .exec()?;

    println!("[Rust]: Before = {}", data.get_val());
    lua.globals()
        .get::<_, Function>("incr")?
        .call::<_, ()>(data.clone())?;
    println!("[Rust]: After = {}", data.get_val());

    Ok(())
}

I have it cloning right now because it's the only way I can get the UserData to pass across the interface, but obviously that means the increment in the Lua function doesn't propagate back to Rust. I believe the UserData can't cross the boundary as a reference because it's not static, but I'm not sure how to really resolve this.

[khvzak]

There are few options to solve this:

1. Wrap your UserData struct to Rc<RefCell> / Arc<RwLock>:

let lua = Lua::new();

let data = Rc::new(RefCell::new(SharedUserData::default()));

lua.load(chunk! {
function incr(data)
    print("[Lua]: Before = " .. data:get_val());
    data:incr_val();
    print("[Lua]: After = " .. data:get_val());
end
})
.exec()?;

println!("[Rust]: Before = {}", data.borrow().get_val());
lua.globals()
    .get::<_, Function>("incr")?
    .call::<_, ()>(data.clone())?;
println!("[Rust]: After = {}", data.borrow().get_val());

2. If UserData is no longer needed on Lua side, you can take it:

let lua = Lua::new();

let data = SharedUserData::default();

lua.load(chunk! {
function incr(data)
    print("[Lua]: Before = " .. data:get_val());
    data:incr_val();
    print("[Lua]: After = " .. data:get_val());
end
})
.exec()?;

println!("[Rust]: Before = {}", data.get_val());
let data_ud = lua.create_userdata(data)?;
lua.globals()
    .get::<_, Function>("incr")?
    .call::<_, ()>(data_ud.clone())?;
let data = data_ud.take::<SharedUserData>()?;
println!("[Rust]: After = {}", data.get_val());

3. Borrow userdata from Lua without consuming:

let lua = Lua::new();

let data = lua.create_userdata(SharedUserData::default())?;

lua.load(chunk! {
function incr(data)
    print("[Lua]: Before = " .. data:get_val());
    data:incr_val();
    print("[Lua]: After = " .. data:get_val());
end
})
.exec()?;

println!("[Rust]: Before = {}", data.borrow::<SharedUserData>()?.get_val());
lua.globals()
    .get::<_, Function>("incr")?
    .call::<_, ()>(data.clone())?;
println!("[Rust]: After = {}", data.borrow::<SharedUserData>()?.get_val());

[Luminoth]

The first option here totally makes sense to me, but if I take this idea one step further and say that what I actually want to pass in is a mutable reference to say, a bevy component, which I don't own and can't have Lua own (maybe?) there doesn't seem to be any way to do that.

It feels like in terms of safety if putting a value in an Rc and passing that in is allowed, passing by reference should be as well, I think?