Add Lua::create_require_function method

Author: khvzak

src/luau/mod.rs

@@ -2,14 +2,33 @@ use std::ffi::CStr;
 use std::os::raw::c_int;
 
 use crate::error::Result;
-use crate::state::{ExtraData, Lua, LuaOptions};
+use crate::function::Function;
+use crate::state::Lua;
 
 pub use require::{NavigateError, Require};
 
 // Since Luau has some missing standard functions, we re-implement them here
 
 impl Lua {
-    pub(crate) unsafe fn configure_luau(&self, mut options: LuaOptions) -> Result<()> {
+    /// Create a custom Luau `require` function using provided [`Require`] implementation to find
+    /// and load modules.
+    ///
+    /// The provided object is stored in the Lua registry and will not be garbage collected
+    /// until the Lua state is closed.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn create_require<R: Require + 'static>(&self, require: R) -> Result<Function> {
+        unsafe {
+            self.exec_raw((), move |state| {
+                let requirer_ptr = ffi::lua_newuserdata_t::<Box<dyn Require>>(state, Box::new(require));
+                // Keep the require object in the registry to prevent it from being garbage collected
+                ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, requirer_ptr as *const _);
+                ffi::lua_pushrequire(state, require::init_config, requirer_ptr as *mut _);
+            })
+        }
+    }
+
+    pub(crate) unsafe fn configure_luau(&self) -> Result<()> {
         let globals = self.globals();
 
         globals.raw_set("collectgarbage", self.create_c_function(lua_collectgarbage)?)?;
@@ -20,12 +39,9 @@ impl Lua {
             globals.raw_set("_VERSION", format!("Luau {version}"))?;
         }
 
-        // Enable `require` function
-        let requirer = (options.requirer.take()).unwrap_or_else(|| Box::new(require::TextRequirer::new()));
-        self.exec_raw::<()>((), |state| {
-            let requirer_ptr = (*ExtraData::get(state)).set_requirer(requirer);
-            ffi::luaopen_require(state, require::init_config, requirer_ptr as *mut _);
-        })?;
+        // Enable default `require` implementation
+        self.globals()
+            .raw_set("require", self.create_require(require::TextRequirer::new())?)?;
 
         Ok(())
     }

src/state.rs

@@ -82,7 +82,7 @@ pub enum GCMode {
 }
 
 /// Controls Lua interpreter behavior such as Rust panics handling.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 pub struct LuaOptions {
     /// Catch Rust panics when using [`pcall`]/[`xpcall`].
@@ -107,11 +107,6 @@ pub struct LuaOptions {
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub thread_pool_size: usize,
-
-    /// A custom [`crate::Require`] trait object to load Luau modules.
-    #[cfg(feature = "luau")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub requirer: Option<Box<dyn crate::Require>>,
 }
 
 impl Default for LuaOptions {
@@ -127,8 +122,6 @@ impl LuaOptions {
             catch_rust_panics: true,
             #[cfg(feature = "async")]
             thread_pool_size: 0,
-            #[cfg(feature = "luau")]
-            requirer: None,
         }
     }
 
@@ -151,17 +144,6 @@ impl LuaOptions {
         self.thread_pool_size = size;
         self
     }
-
-    /// Sets a custom [`crate::Require`] trait object to load Luau modules.
-    ///
-    /// By default, the standard Luau `ReplRequirer` implementation is used.
-    #[cfg(feature = "luau")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    #[must_use]
-    pub fn with_requirer<R: crate::Require + 'static>(mut self, requirer: R) -> Self {
-        self.requirer = Some(Box::new(requirer));
-        self
-    }
 }
 
 impl Drop for Lua {
@@ -288,7 +270,7 @@ impl Lua {
         };
 
         #[cfg(feature = "luau")]
-        mlua_expect!(lua.configure_luau(options), "Error configuring Luau");
+        mlua_expect!(lua.configure_luau(), "Error configuring Luau");
 
         lua
     }

src/state/extra.rs

@@ -93,8 +93,6 @@ pub(crate) struct ExtraData {
     pub(super) compiler: Option<Compiler>,
     #[cfg(feature = "luau-jit")]
     pub(super) enable_jit: bool,
-    #[cfg(feature = "luau")]
-    pub(super) requirer: Option<Box<dyn crate::luau::Require>>,
 }
 
 impl Drop for ExtraData {
@@ -196,8 +194,6 @@ impl ExtraData {
             enable_jit: true,
             #[cfg(feature = "luau")]
             running_gc: false,
-            #[cfg(feature = "luau")]
-            requirer: None,
         }));
 
         // Store it in the registry
@@ -214,7 +210,7 @@ impl ExtraData {
         self.weak.write(WeakLua(XRc::downgrade(raw)));
     }
 
-    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+    pub(super) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
         #[cfg(feature = "luau")]
         if cfg!(not(feature = "module")) {
             // In the main app we can use `lua_callbacks` to access ExtraData
@@ -261,13 +257,4 @@ impl ExtraData {
     pub(super) unsafe fn weak(&self) -> &WeakLua {
         self.weak.assume_init_ref()
     }
-
-    #[cfg(feature = "luau")]
-    pub(crate) fn set_requirer(
-        &mut self,
-        requirer: Box<dyn crate::luau::Require>,
-    ) -> *mut Box<dyn crate::luau::Require> {
-        self.requirer.replace(requirer);
-        self.requirer.as_mut().unwrap()
-    }
 }