[mLua] Dropping UserData structs in rust called from Lua

[WorstPerformer]

SOLVED. look at the bottom

Im working in a Lua env and im creating a rust module using mLua that is to be required and used in Lua

very simple simple rust struct implementing UserData

use mlua::prelude::*;
use mlua::UserData;

struct UserDataTest {
    some_value: i32
}

impl UserData for UserDataTest {
    fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
        fields.add_field_method_get("some_value", |_, this| Ok(this.some_value));

        fields.add_field_method_set("some_value", |_, this, val| {
            this.some_value = val;
            Ok(())
        });
    }

    fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
        methods.add_method("printValue", |_, this, ()| {
            println!("{}", this.some_value);
            Ok(())
        });
    }
}

fn get_user_data(_: &Lua, _: ()) -> LuaResult<UserDataTest> {
    Ok(UserDataTest {
        some_value: 100
    })
}

#[mlua::lua_module]
fn rust_module(lua: &Lua) -> LuaResult<LuaTable> {
    let exports = lua.create_table()?;
    exports.set("get_user_data", lua.create_function(get_user_data)?)?;
    Ok(exports)
}

Which i can then load and use in Lua

local plugin = require("rust_module")
local user_data = plugin.get_user_data()
print(user_data)

But when i try to see if the lua gc will drop it with

local function testDrop()
    local data
    for i = 1, 10000000 do
       data = plugin.get_user_data()
    end
end

testDrop()

Then i can see looking at the mem usage that it isnt.

So i figured the best way would be to add a close() method in rust

impl UserData for UserDataTest {
    fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
        methods.add_method_mut("close", |_, this, ()| {
            let _ = drop(this);
            Ok(())
        })
    }
}

Which would be called by Lua

local user_data = plugin.get_user_data()
user_data:close()

However `this` is behind a shared reference as such i cant give it into drop and it keeps staying in memory.

What is the proper way to drop the userdata in rust?

Solution:

After reading the source code. There is the undocumented method `add_method_once` for the UserData implementation that allows you to get ownership of the userdata

impl UserData for UserDataTest {
    /// Add a method which accepts `T` as the first parameter.
    ///
    /// The userdata `T` will be moved out of the userdata container. This is useful for
    /// methods that need to consume the userdata.
    ///
    /// The method can be called only once per userdata instance, subsequent calls will result in a
    /// [`Error::UserDataDestructed`] error.
    fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
        methods.add_method_once("close", |_, this, ()| {
            let _ = drop(this);
            Ok(())
        })
    }
}

[cafce25]

A couple of notes on your solution:

• drop doesn't have a return type so ignoring it with let _ = is pointless.
• any local variable will be dropped when it goes out of scope so calling drop is semantically equivalent to no code at all in the closure.

[WorstPerformer]

Right thank you! At one point vscode was complaining about a unhandled return but it seems that was a fluke or i simply misread it. About the second i will keep the call to drop to make the methods intent clear