How do I pass a mutable reference into a call(...) and have it actually be changed?

[IoIxD]

I'm sorry if this is a newbie question but I've been at this for hours and have tried too many things to name honestly. I am currently on 0.9.0 beta 2.

• I have a mutable reference
• Rust normally complains that I can't pass a mutable reference to the function because "the reference will outlive the function", but in the interest of seeing if I can do it anyways by implementing a garbage collector and managing the memory myself, I leak the mutable reference out and pass it to the function.
• The reference is successfully passed to the function.
• It doesn't get modified. The Lua function modifies it with no issue, but the changes aren't propagated to the Rust side as they should be.

match obj.get::<_, Function>(callback_str.clone()) {
    Ok(func) => {
        let object = Box::leak(Box::new(object.to_owned()));
        let handle: RigidBodyHandle = object.handle.borrow().unwrap();
        let handles = Box::leak(Box::new(st.handles().to_owned()));
        let body = handles.get_mut(handle).unwrap();
        let body_wrapped = LuaWrapperRigidBodyRef(RefCell::new(body));

        match func.call((object, body_wrapped, st)) {
            Ok(()) => {}
            Err(err) => {
                return Err(mlua::Error::RuntimeError(format!(
                    "error returning from {} on {}: \n{}",
                    callback_str, class, err
                )));
            }
        }
    }
    Err(_) => {
        // Then the function simply doesn't exist. Ignore it.
    }
}

[khvzak]

You can try to use mlua scope functionality without leaking memory:

    let mut string_object = String::from("Hello, world!");

    let func = lua.create_function(|_, mut obj: mlua::UserDataRefMut<String>| {
        *obj = "Hello from Rust".to_string();
        Ok(())
    })?;

    lua.scope(|scope| {
        let mut_obj = scope.create_any_userdata_ref_mut(&mut string_object);
        func.call::<_, ()>(mut_obj)
    })?;

    // prints: Hello from Rust
    println!("{}", string_object);

Mutable reference to object (String in our case) is wrapped into special userdata that valid only inside scope().

I hope the approach above would work for you as it was designed for such cases.

[IoIxD]

So the problem here is that I need to create a wrapper around a mutable type. I'm binding things from a crate I didn't make - rapier2d. So I have LuaWrapperRigidBodyRefMut(&mut body) and its &mut body that "does not live long enough"

[IoIxD]

Do you have Discord, perchance?

[khvzak]

So the problem here is that I need to create a wrapper around a mutable type. I'm binding things from a crate I didn't make - rapier2d.

You don't need a wrapper. v0.9 has new api for "any" userdata which allow interaction with objects defined in another crates.
In the example above I used std::string::String to pass mutable reference to Lua without wrapper type.

Also the requirement T: UserData was lifted to T: 'static in many places.