v0.11.2

This matches with Luau 0.686 changes

CHANGELOG.md

@@ -1,3 +1,29 @@
+## v0.11.2 (Aug 10, 2025)
+
+- Faster stack push for `Variadic<T>`
+- Fix handling Windows paths with drive letter in Luau require (#623)
+- Make Luau registered aliases ascii case-insensitive (#620)
+- Fix deserializing negative zeros `-0.0` (#618)
+
+## v0.11.1 (Jul 15, 2025)
+
+- Fixed bug exhausting Lua auxiliary stack and leaving it without reserve (#615)
+- `Lua::push_c_function` now correctly handles OOM for Lua 5.1 and Luau
+
+## v0.11.0 (Jul 14, 2025)
+
+Changes since v0.11.0-beta.3
+
+- Allow linking external Lua libraries in a build script (e.g. pluto) using `external` mlua-sys feature flag
+- `Lua::inspect_stack` takes a callback with `&Debug` argument, instead of returning `Debug` directly
+- Added `Debug::function` method to get function running at a given level
+- `Debug::curr_line` is deprecated in favour of `Debug::current_line` that returns `Option<usize>`
+- Added `Lua::set_globals` method to replace global environment
+- `Table::set_metatable` now returns `Result<()>` (this operation can fail in sandboxed Luau mode)
+- `impl ToString` replaced with `Into<StdString>`  in `UserData` registration
+- `Value::as_str` and `Value::as_string_lossy` methods are deprecated (as they are non-idiomatic)
+- Bugfixes and improvements
+
 ## v0.11.0-beta.3 (Jun 23, 2025)
 
 - Luau in sandboxed mode has reduced options in `collectgarbage` function (to follow the official doc)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.11.0-beta.3" # remember to update mlua_derive
+version = "0.11.2" # remember to update mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
 rust-version = "1.79.0"
 edition = "2021"
@@ -49,7 +49,7 @@ userdata-wrappers = ["parking_lot/send_guard"]
 serialize = ["serde"]
 
 [dependencies]
-mlua_derive = { version = "=0.11.0-beta.2", optional = true, path = "mlua_derive" }
+mlua_derive = { version = "=0.11.0", optional = true, path = "mlua_derive" }
 bstr = { version = "1.0", features = ["std"], default-features = false }
 either = "1.0"
 num-traits = { version = "0.2.14" }
@@ -62,7 +62,7 @@ parking_lot = { version = "0.12", features = ["arc_lock"] }
 anyhow = { version = "1.0", optional = true }
 rustversion = "1.0"
 
-ffi = { package = "mlua-sys", version = "0.8.0", path = "mlua-sys" }
+ffi = { package = "mlua-sys", version = "0.8.3", path = "mlua-sys" }
 
 [dev-dependencies]
 trybuild = "1.0"
@@ -78,8 +78,8 @@ tempfile = "3"
 static_assertions = "1.0"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
-criterion = { version = "0.6", features = ["async_tokio"] }
-rustyline = "16.0"
+criterion = { version = "0.7", features = ["async_tokio"] }
+rustyline = "17.0"
 tokio = { version = "1.0", features = ["full"] }
 
 [lints.rust]

README.md

@@ -17,12 +17,6 @@
 [Benchmarks]: https://github.com/khvzak/script-bench-rs
 [FAQ]: FAQ.md
 
-# The main branch is the development version of `mlua`. Please see the [v0.10](https://github.com/mlua-rs/mlua/tree/v0.10) branch for the stable versions of `mlua`.
-
-> **Note**
->
-> See v0.10 [release notes](https://github.com/mlua-rs/mlua/blob/main/docs/release_notes/v0.10.md).
-
 `mlua` is a set of bindings to the [Lua](https://www.lua.org) programming language for Rust with a goal to provide a
 _safe_ (as much as possible), high level, easy to use, practical and flexible API.
 
@@ -100,11 +94,11 @@ cargo run --example async_http_server --features=lua54,async,macros,send
 curl -v http://localhost:3000
 ```
 
-### Serialization (serde) support
+### Serde support
 
-With the `serde` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition, `mlua` provides the [`serde::Serialize`] trait implementation for it (including `UserData` support).
+With the `serde` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition, `mlua` provides the [`serde::Serialize`] trait implementation for `mlua::Value` (including `UserData` support).
 
-[Example](examples/serialize.rs)
+[Example](examples/serde.rs)
 
 [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
@@ -135,7 +129,7 @@ Add to `Cargo.toml`:
 
 ``` toml
 [dependencies]
-mlua = { version = "0.10", features = ["lua54", "vendored"] }
+mlua = { version = "0.11", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -170,7 +164,7 @@ Add to `Cargo.toml`:
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.10", features = ["lua54", "module"] }
+mlua = { version = "0.11", features = ["lua54", "module"] }
 ```
 
 `lib.rs`:

examples/repl.rs

@@ -20,14 +20,16 @@ fn main() {
             match lua.load(&line).eval::<MultiValue>() {
                 Ok(values) => {
                     editor.add_history_entry(line).unwrap();
-                    println!(
-                        "{}",
-                        values
-                            .iter()
-                            .map(|value| format!("{:#?}", value))
-                            .collect::<Vec<_>>()
-                            .join("\t")
-                    );
+                    if values.len() > 0 {
+                        println!(
+                            "{}",
+                            values
+                                .iter()
+                                .map(|value| format!("{:#?}", value))
+                                .collect::<Vec<_>>()
+                                .join("\t")
+                        );
+                    }
                     break;
                 }
                 Err(Error::SyntaxError {

mlua-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua-sys"
-version = "0.8.1"
+version = "0.8.3"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 rust-version = "1.71"
 edition = "2021"
@@ -30,6 +30,7 @@ luau = ["luau0-src"]
 luau-codegen = ["luau"]
 luau-vector4 = ["luau"]
 vendored = ["lua-src", "luajit-src"]
+external = []
 module = []
 
 [dependencies]
@@ -40,7 +41,7 @@ cfg-if = "1.0"
 pkg-config = "0.3.17"
 lua-src = { version = ">= 548.1.0, < 548.2.0", optional = true }
 luajit-src = { version = ">= 210.6.0, < 210.7.0", optional = true }
-luau0-src = { version = "0.15.0", optional = true }
+luau0-src = { version = "0.15.4", optional = true }
 
 [lints.rust]
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(raw_dylib)'] }

mlua-sys/build/main_inner.rs

@@ -14,22 +14,29 @@ fn main() {
     #[cfg(all(feature = "luau", feature = "module", windows))]
     compile_error!("Luau does not support `module` mode on Windows");
 
-    #[cfg(all(feature = "module", feature = "vendored"))]
-    compile_error!("`vendored` and `module` features are mutually exclusive");
+    #[cfg(any(
+        all(feature = "vendored", any(feature = "external", feature = "module")),
+        all(feature = "external", any(feature = "vendored", feature = "module")),
+        all(feature = "module", any(feature = "vendored", feature = "external"))
+    ))]
+    compile_error!("`vendored`, `external` and `module` features are mutually exclusive");
 
     println!("cargo:rerun-if-changed=build");
 
-    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
-    if target_os == "windows" && cfg!(feature = "module") {
-        if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
-            // Don't use raw-dylib linking
-            find::probe_lua();
-            return;
+    // Check if compilation and linking is handled by external crate
+    if cfg!(not(feature = "external")) {
+        let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+        if target_os == "windows" && cfg!(feature = "module") {
+            if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
+                // Don't use raw-dylib linking
+                find::probe_lua();
+                return;
+            }
+
+            println!("cargo:rustc-cfg=raw_dylib");
         }
 
-        println!("cargo:rustc-cfg=raw_dylib");
+        #[cfg(not(feature = "module"))]
+        find::probe_lua();
     }
-
-    #[cfg(not(feature = "module"))]
-    find::probe_lua();
 }

mlua-sys/src/lua51/compat.rs

@@ -186,7 +186,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
     if lua_type(L, idx) == LUA_TNUMBER {
         let n = lua_tonumber(L, idx);
         let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
             return 1;
         }
     }

mlua-sys/src/lua52/compat.rs

@@ -51,7 +51,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
     if lua_type(L, idx) == LUA_TNUMBER {
         let n = lua_tonumber(L, idx);
         let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
             return 1;
         }
     }

mlua-sys/src/luau/compat.rs

@@ -120,7 +120,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
     if lua_type(L, idx) == LUA_TNUMBER {
         let n = lua_tonumber(L, idx);
         let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
             return 1;
         }
     }

mlua_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua_derive"
-version = "0.11.0-beta.2"
+version = "0.11.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 edition = "2021"
 description = "Procedural macros for the mlua crate."

mlua_derive/src/lib.rs

@@ -129,13 +129,13 @@ pub fn chunk(input: TokenStream) -> TokenStream {
             let globals = lua.globals();
             let env = lua.create_table()?;
             let meta = lua.create_table()?;
-            meta.raw_set("__index", globals.clone())?;
-            meta.raw_set("__newindex", globals)?;
+            meta.raw_set("__index", &globals)?;
+            meta.raw_set("__newindex", &globals)?;
 
             // Add captured variables
             #(#caps)*
 
-            env.set_metatable(Some(meta));
+            env.set_metatable(Some(meta))?;
             Ok(env)
         };
 

src/buffer.rs

@@ -1,6 +1,7 @@
 #[cfg(feature = "serde")]
 use serde::ser::{Serialize, Serializer};
 
+use crate::state::RawLua;
 use crate::types::ValueRef;
 
 /// A Luau buffer type.
@@ -16,12 +17,14 @@ pub struct Buffer(pub(crate) ValueRef);
 impl Buffer {
     /// Copies the buffer data into a new `Vec<u8>`.
     pub fn to_vec(&self) -> Vec<u8> {
-        unsafe { self.as_slice().to_vec() }
+        let lua = self.0.lua.lock();
+        self.as_slice(&lua).to_vec()
     }
 
     /// Returns the length of the buffer.
     pub fn len(&self) -> usize {
-        unsafe { self.as_slice().len() }
+        let lua = self.0.lua.lock();
+        self.as_slice(&lua).len()
     }
 
     /// Returns `true` if the buffer is empty.
@@ -34,7 +37,8 @@ impl Buffer {
     /// Offset is 0-based.
     #[track_caller]
     pub fn read_bytes<const N: usize>(&self, offset: usize) -> [u8; N] {
-        let data = unsafe { self.as_slice() };
+        let lua = self.0.lua.lock();
+        let data = self.as_slice(&lua);
         let mut bytes = [0u8; N];
         bytes.copy_from_slice(&data[offset..offset + N]);
         bytes
@@ -45,21 +49,23 @@ impl Buffer {
     /// Offset is 0-based.
     #[track_caller]
     pub fn write_bytes(&self, offset: usize, bytes: &[u8]) {
+        let lua = self.0.lua.lock();
         let data = unsafe {
-            let (buf, size) = self.as_raw_parts();
+            let (buf, size) = self.as_raw_parts(&lua);
             std::slice::from_raw_parts_mut(buf, size)
         };
         data[offset..offset + bytes.len()].copy_from_slice(bytes);
     }
 
-    pub(crate) unsafe fn as_slice(&self) -> &[u8] {
-        let (buf, size) = self.as_raw_parts();
-        std::slice::from_raw_parts(buf, size)
+    pub(crate) fn as_slice(&self, lua: &RawLua) -> &[u8] {
+        unsafe {
+            let (buf, size) = self.as_raw_parts(lua);
+            std::slice::from_raw_parts(buf, size)
+        }
     }
 
     #[cfg(feature = "luau")]
-    unsafe fn as_raw_parts(&self) -> (*mut u8, usize) {
-        let lua = self.0.lua.lock();
+    unsafe fn as_raw_parts(&self, lua: &RawLua) -> (*mut u8, usize) {
         let mut size = 0usize;
         let buf = ffi::lua_tobuffer(lua.ref_thread(), self.0.index, &mut size);
         mlua_assert!(!buf.is_null(), "invalid Luau buffer");
@@ -67,7 +73,7 @@ impl Buffer {
     }
 
     #[cfg(not(feature = "luau"))]
-    unsafe fn as_raw_parts(&self) -> (*mut u8, usize) {
+    unsafe fn as_raw_parts(&self, lua: &RawLua) -> (*mut u8, usize) {
         unreachable!()
     }
 }
@@ -75,7 +81,8 @@ impl Buffer {
 #[cfg(feature = "serde")]
 impl Serialize for Buffer {
     fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
-        serializer.serialize_bytes(unsafe { self.as_slice() })
+        let lua = self.0.lua.lock();
+        serializer.serialize_bytes(self.as_slice(&lua))
     }
 }
 

src/chunk.rs

@@ -160,18 +160,39 @@ pub enum CompileConstant {
     Boolean(bool),
     Number(crate::Number),
     Vector(crate::Vector),
-    String(String),
+    String(StdString),
 }
 
-#[cfg(feature = "luau")]
-impl From<&'static str> for CompileConstant {
-    fn from(s: &'static str) -> Self {
-        CompileConstant::String(s.to_string())
+#[cfg(any(feature = "luau", doc))]
+impl From<bool> for CompileConstant {
+    fn from(b: bool) -> Self {
+        CompileConstant::Boolean(b)
     }
 }
 
 #[cfg(any(feature = "luau", doc))]
-type LibraryMemberConstantMap = std::sync::Arc<HashMap<(String, String), CompileConstant>>;
+impl From<crate::Number> for CompileConstant {
+    fn from(n: crate::Number) -> Self {
+        CompileConstant::Number(n)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<crate::Vector> for CompileConstant {
+    fn from(v: crate::Vector) -> Self {
+        CompileConstant::Vector(v)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<&str> for CompileConstant {
+    fn from(s: &str) -> Self {
+        CompileConstant::String(s.to_owned())
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+type LibraryMemberConstantMap = HashMap<(StdString, StdString), CompileConstant>;
 
 /// Luau compiler
 #[cfg(any(feature = "luau", doc))]
@@ -182,14 +203,14 @@ pub struct Compiler {
     debug_level: u8,
     type_info_level: u8,
     coverage_level: u8,
-    vector_lib: Option<String>,
-    vector_ctor: Option<String>,
-    vector_type: Option<String>,
-    mutable_globals: Vec<String>,
-    userdata_types: Vec<String>,
-    libraries_with_known_members: Vec<String>,
+    vector_lib: Option<StdString>,
+    vector_ctor: Option<StdString>,
+    vector_type: Option<StdString>,
+    mutable_globals: Vec<StdString>,
+    userdata_types: Vec<StdString>,
+    libraries_with_known_members: Vec<StdString>,
     library_constants: Option<LibraryMemberConstantMap>,
-    disabled_builtins: Vec<String>,
+    disabled_builtins: Vec<StdString>,
 }
 
 #[cfg(any(feature = "luau", doc))]
@@ -267,70 +288,102 @@ impl Compiler {
         self
     }
 
+    /// Sets alternative global builtin to construct vectors, in addition to default builtin
+    /// `vector.create`.
+    ///
+    /// To set the library and method name, use the `lib.ctor` format.
     #[doc(hidden)]
     #[must_use]
-    pub fn set_vector_lib(mut self, lib: impl Into<String>) -> Self {
-        self.vector_lib = Some(lib.into());
+    pub fn set_vector_ctor(mut self, ctor: impl Into<StdString>) -> Self {
+        let ctor = ctor.into();
+        let lib_ctor = ctor.split_once('.');
+        self.vector_lib = lib_ctor.as_ref().map(|&(lib, _)| lib.to_owned());
+        self.vector_ctor = (lib_ctor.as_ref())
+            .map(|&(_, ctor)| ctor.to_owned())
+            .or(Some(ctor));
         self
     }
 
+    /// Sets alternative vector type name for type tables, in addition to default type `vector`.
     #[doc(hidden)]
     #[must_use]
-    pub fn set_vector_ctor(mut self, ctor: impl Into<String>) -> Self {
-        self.vector_ctor = Some(ctor.into());
-        self
-    }
-
-    #[doc(hidden)]
-    #[must_use]
-    pub fn set_vector_type(mut self, r#type: impl Into<String>) -> Self {
+    pub fn set_vector_type(mut self, r#type: impl Into<StdString>) -> Self {
         self.vector_type = Some(r#type.into());
         self
     }
 
+    /// Adds a mutable global.
+    ///
+    /// It disables the import optimization for fields accessed through it.
+    #[must_use]
+    pub fn add_mutable_global(mut self, global: impl Into<StdString>) -> Self {
+        self.mutable_globals.push(global.into());
+        self
+    }
+
     /// Sets a list of globals that are mutable.
     ///
     /// It disables the import optimization for fields accessed through these.
     #[must_use]
-    pub fn set_mutable_globals<S: Into<String>>(mut self, globals: Vec<S>) -> Self {
+    pub fn set_mutable_globals<S: Into<StdString>>(mut self, globals: impl IntoIterator<Item = S>) -> Self {
         self.mutable_globals = globals.into_iter().map(|s| s.into()).collect();
         self
     }
 
+    /// Adds a userdata type to the list that will be included in the type information.
+    #[must_use]
+    pub fn add_userdata_type(mut self, r#type: impl Into<StdString>) -> Self {
+        self.userdata_types.push(r#type.into());
+        self
+    }
+
     /// Sets a list of userdata types that will be included in the type information.
     #[must_use]
-    pub fn set_userdata_types<S: Into<String>>(mut self, types: Vec<S>) -> Self {
+    pub fn set_userdata_types<S: Into<StdString>>(mut self, types: impl IntoIterator<Item = S>) -> Self {
         self.userdata_types = types.into_iter().map(|s| s.into()).collect();
         self
     }
 
-    /// Sets constants for known library members.
+    /// Adds a constant for a known library member.
     ///
     /// The constants are used by the compiler to optimize the generated bytecode.
     /// Optimization level must be at least 2 for this to have any effect.
     ///
-    /// The first element of the tuple is the library name,the second is the member name, and the
-    /// third is the constant value.
+    /// The `name` is a string in the format `lib.member`, where `lib` is the library name
+    /// and `member` is the member (constant) name.
     #[must_use]
-    pub fn set_library_constants<L, M>(mut self, constants: Vec<(L, M, CompileConstant)>) -> Self
-    where
-        L: Into<String>,
-        M: Into<String>,
-    {
-        let map = constants
-            .into_iter()
-            .map(|(lib, member, cons)| ((lib.into(), member.into()), cons))
-            .collect::<HashMap<_, _>>();
-        self.library_constants = Some(std::sync::Arc::new(map));
-        self.libraries_with_known_members = (self.library_constants.clone())
-            .map(|map| map.keys().map(|(lib, _)| lib.clone()).collect())
-            .unwrap_or_default();
+    pub fn add_library_constant(
+        mut self,
+        name: impl AsRef<str>,
+        r#const: impl Into<CompileConstant>,
+    ) -> Self {
+        let Some((lib, member)) = name.as_ref().split_once('.') else {
+            return self;
+        };
+        let (lib, member) = (lib.to_owned(), member.to_owned());
+
+        if !self.libraries_with_known_members.contains(&lib) {
+            self.libraries_with_known_members.push(lib.clone());
+        }
+        self.library_constants
+            .get_or_insert_with(HashMap::new)
+            .insert((lib, member), r#const.into());
+        self
+    }
+
+    /// Adds a builtin that should be disabled.
+    #[must_use]
+    pub fn add_disabled_builtin(mut self, builtin: impl Into<StdString>) -> Self {
+        self.disabled_builtins.push(builtin.into());
         self
     }
 
     /// Sets a list of builtins that should be disabled.
     #[must_use]
-    pub fn set_disabled_builtins<S: Into<String>>(mut self, builtins: Vec<S>) -> Self {
+    pub fn set_disabled_builtins<S: Into<StdString>>(
+        mut self,
+        builtins: impl IntoIterator<Item = S>,
+    ) -> Self {
         self.disabled_builtins = builtins.into_iter().map(|s| s.into()).collect();
         self
     }
@@ -437,7 +490,7 @@ impl Compiler {
         if bytecode.first() == Some(&0) {
             // The rest of the bytecode is the error message starting with `:`
             // See https://github.com/luau-lang/luau/blob/0.640/Compiler/src/Compiler.cpp#L4336
-            let message = String::from_utf8_lossy(&bytecode[2..]).to_string();
+            let message = StdString::from_utf8_lossy(&bytecode[2..]).into_owned();
             return Err(Error::SyntaxError {
                 incomplete_input: message.ends_with("<eof>"),
                 message,
@@ -460,7 +513,7 @@ impl Chunk<'_> {
     /// - `@` - file path (when truncation is needed, the end of the file path is kept, as this is
     ///   more useful for identifying the file)
     /// - `=` - custom chunk name (when truncation is needed, the beginning of the name is kept)
-    pub fn set_name(mut self, name: impl Into<String>) -> Self {
+    pub fn set_name(mut self, name: impl Into<StdString>) -> Self {
         self.name = name.into();
         self
     }
@@ -708,7 +761,7 @@ impl Chunk<'_> {
         ChunkMode::Text
     }
 
-    fn convert_name(name: String) -> Result<CString> {
+    fn convert_name(name: StdString) -> Result<CString> {
         CString::new(name).map_err(|err| Error::runtime(format!("invalid name: {err}")))
     }
 

src/conversion.rs

@@ -645,7 +645,7 @@ impl FromLua for BString {
         match value {
             Value::String(s) => Ok((*s.as_bytes()).into()),
             #[cfg(feature = "luau")]
-            Value::Buffer(buf) => unsafe { Ok(buf.as_slice().into()) },
+            Value::Buffer(buf) => Ok(buf.to_vec().into()),
             _ => Ok((*lua
                 .coerce_string(value)?
                 .ok_or_else(|| Error::FromLuaConversionError {

src/debug.rs

@@ -1,66 +1,33 @@
 use std::borrow::Cow;
-use std::cell::UnsafeCell;
-use std::ops::Deref;
-#[cfg(not(feature = "luau"))]
-use std::ops::{BitOr, BitOrAssign};
 use std::os::raw::c_int;
 
-use ffi::lua_Debug;
+use ffi::{lua_Debug, lua_State};
 
+use crate::function::Function;
 use crate::state::RawLua;
-use crate::types::ReentrantMutexGuard;
-use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
+use crate::util::{assert_stack, linenumber_to_usize, ptr_to_lossy_str, ptr_to_str, StackGuard};
 
 /// Contains information about currently executing Lua code.
 ///
-/// The `Debug` structure is provided as a parameter to the hook function set with
-/// [`Lua::set_hook`]. You may call the methods on this structure to retrieve information about the
-/// Lua code executing at the time that the hook function was called. Further information can be
-/// found in the Lua [documentation].
+/// You may call the methods on this structure to retrieve information about the Lua code executing
+/// at the specific level. Further information can be found in the Lua [documentation].
 ///
 /// [documentation]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
-/// [`Lua::set_hook`]: crate::Lua::set_hook
 pub struct Debug<'a> {
-    lua: EitherLua<'a>,
-    ar: ActivationRecord,
-    #[cfg(feature = "luau")]
+    state: *mut lua_State,
+    lua: &'a RawLua,
+    #[cfg_attr(not(feature = "luau"), allow(unused))]
     level: c_int,
-}
-
-enum EitherLua<'a> {
-    Owned(ReentrantMutexGuard<'a, RawLua>),
-    #[cfg(not(feature = "luau"))]
-    Borrowed(&'a RawLua),
-}
-
-impl Deref for EitherLua<'_> {
-    type Target = RawLua;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            EitherLua::Owned(guard) => guard,
-            #[cfg(not(feature = "luau"))]
-            EitherLua::Borrowed(lua) => lua,
-        }
-    }
+    ar: *mut lua_Debug,
 }
 
 impl<'a> Debug<'a> {
-    // We assume the lock is held when this function is called.
-    #[cfg(not(feature = "luau"))]
-    pub(crate) fn new(lua: &'a RawLua, ar: *mut lua_Debug) -> Self {
+    pub(crate) fn new(lua: &'a RawLua, level: c_int, ar: *mut lua_Debug) -> Self {
         Debug {
-            lua: EitherLua::Borrowed(lua),
-            ar: ActivationRecord::Borrowed(ar),
-        }
-    }
-
-    pub(crate) fn new_owned(guard: ReentrantMutexGuard<'a, RawLua>, _level: c_int, ar: lua_Debug) -> Self {
-        Debug {
-            lua: EitherLua::Owned(guard),
-            ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
-            #[cfg(feature = "luau")]
-            level: _level,
+            state: lua.state(),
+            lua,
+            ar,
+            level,
         }
     }
 
@@ -74,7 +41,7 @@ impl<'a> Debug<'a> {
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn event(&self) -> DebugEvent {
         unsafe {
-            match (*self.ar.get()).event {
+            match (*self.ar).event {
                 ffi::LUA_HOOKCALL => DebugEvent::Call,
                 ffi::LUA_HOOKRET => DebugEvent::Ret,
                 ffi::LUA_HOOKTAILCALL => DebugEvent::TailCall,
@@ -85,24 +52,48 @@ impl<'a> Debug<'a> {
         }
     }
 
-    /// Corresponds to the `n` what mask.
+    /// Returns the function that is running at the given level.
+    ///
+    /// Corresponds to the `f` "what" mask.
+    pub fn function(&self) -> Function {
+        unsafe {
+            let _sg = StackGuard::new(self.state);
+            assert_stack(self.state, 1);
+
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("f"), self.ar) != 0,
+                "lua_getinfo failed with `f`"
+            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, self.level, cstr!("f"), self.ar) != 0,
+                "lua_getinfo failed with `f`"
+            );
+
+            ffi::lua_xmove(self.state, self.lua.ref_thread(), 1);
+            Function(self.lua.pop_ref_thread())
+        }
+    }
+
+    /// Corresponds to the `n` "what" mask.
     pub fn names(&self) -> DebugNames<'_> {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("n"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("n"), self.ar) != 0,
                 "lua_getinfo failed with `n`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("n"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("n"), self.ar) != 0,
                 "lua_getinfo failed with `n`"
             );
 
             DebugNames {
-                name: ptr_to_lossy_str((*self.ar.get()).name),
+                name: ptr_to_lossy_str((*self.ar).name),
                 #[cfg(not(feature = "luau"))]
-                name_what: match ptr_to_str((*self.ar.get()).namewhat) {
+                name_what: match ptr_to_str((*self.ar).namewhat) {
                     Some("") => None,
                     val => val,
                 },
@@ -112,118 +103,110 @@ impl<'a> Debug<'a> {
         }
     }
 
-    /// Corresponds to the `S` what mask.
+    /// Corresponds to the `S` "what" mask.
     pub fn source(&self) -> DebugSource<'_> {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("S"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("S"), self.ar) != 0,
                 "lua_getinfo failed with `S`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("s"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("s"), self.ar) != 0,
                 "lua_getinfo failed with `s`"
             );
 
             DebugSource {
-                source: ptr_to_lossy_str((*self.ar.get()).source),
+                source: ptr_to_lossy_str((*self.ar).source),
                 #[cfg(not(feature = "luau"))]
-                short_src: ptr_to_lossy_str((*self.ar.get()).short_src.as_ptr()),
+                short_src: ptr_to_lossy_str((*self.ar).short_src.as_ptr()),
                 #[cfg(feature = "luau")]
-                short_src: ptr_to_lossy_str((*self.ar.get()).short_src),
-                line_defined: linenumber_to_usize((*self.ar.get()).linedefined),
+                short_src: ptr_to_lossy_str((*self.ar).short_src),
+                line_defined: linenumber_to_usize((*self.ar).linedefined),
                 #[cfg(not(feature = "luau"))]
-                last_line_defined: linenumber_to_usize((*self.ar.get()).lastlinedefined),
+                last_line_defined: linenumber_to_usize((*self.ar).lastlinedefined),
                 #[cfg(feature = "luau")]
                 last_line_defined: None,
-                what: ptr_to_str((*self.ar.get()).what).unwrap_or("main"),
+                what: ptr_to_str((*self.ar).what).unwrap_or("main"),
             }
         }
     }
 
-    /// Corresponds to the `l` what mask. Returns the current line.
+    #[doc(hidden)]
+    #[deprecated(note = "Use `current_line` instead")]
     pub fn curr_line(&self) -> i32 {
+        self.current_line().map(|n| n as i32).unwrap_or(-1)
+    }
+
+    /// Corresponds to the `l` "what" mask. Returns the current line.
+    pub fn current_line(&self) -> Option<usize> {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("l"), self.ar) != 0,
                 "lua_getinfo failed with `l`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("l"), self.ar) != 0,
                 "lua_getinfo failed with `l`"
             );
 
-            (*self.ar.get()).currentline
+            linenumber_to_usize((*self.ar).currentline)
         }
     }
 
-    /// Corresponds to the `t` what mask. Returns true if the hook is in a function tail call, false
-    /// otherwise.
-    #[cfg(not(feature = "luau"))]
-    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    /// Corresponds to the `t` "what" mask. Returns true if the hook is in a function tail call,
+    /// false otherwise.
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua54", feature = "lua53", feature = "lua52")))
+    )]
     pub fn is_tail_call(&self) -> bool {
         unsafe {
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("t"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("t"), self.ar) != 0,
                 "lua_getinfo failed with `t`"
             );
-            (*self.ar.get()).currentline != 0
+            (*self.ar).istailcall != 0
         }
     }
 
-    /// Corresponds to the `u` what mask.
+    /// Corresponds to the `u` "what" mask.
     pub fn stack(&self) -> DebugStack {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), cstr!("u"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, cstr!("u"), self.ar) != 0,
                 "lua_getinfo failed with `u`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("au"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.state, self.level, cstr!("au"), self.ar) != 0,
                 "lua_getinfo failed with `au`"
             );
 
             #[cfg(not(feature = "luau"))]
             let stack = DebugStack {
-                num_ups: (*self.ar.get()).nups as _,
+                num_ups: (*self.ar).nups as _,
                 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar.get()).nparams as _,
+                num_params: (*self.ar).nparams as _,
                 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                is_vararg: (*self.ar.get()).isvararg != 0,
+                is_vararg: (*self.ar).isvararg != 0,
             };
             #[cfg(feature = "luau")]
             let stack = DebugStack {
-                num_ups: (*self.ar.get()).nupvals,
-                num_params: (*self.ar.get()).nparams,
-                is_vararg: (*self.ar.get()).isvararg != 0,
+                num_ups: (*self.ar).nupvals,
+                num_params: (*self.ar).nparams,
+                is_vararg: (*self.ar).isvararg != 0,
             };
             stack
         }
     }
 }
 
-enum ActivationRecord {
-    #[cfg(not(feature = "luau"))]
-    Borrowed(*mut lua_Debug),
-    Owned(UnsafeCell<lua_Debug>),
-}
-
-impl ActivationRecord {
-    #[inline]
-    fn get(&self) -> *mut lua_Debug {
-        match self {
-            #[cfg(not(feature = "luau"))]
-            ActivationRecord::Borrowed(x) => *x,
-            ActivationRecord::Owned(x) => x.get(),
-        }
-    }
-}
-
 /// Represents a specific event that triggered the hook.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum DebugEvent {
@@ -382,7 +365,7 @@ impl HookTriggers {
 }
 
 #[cfg(not(feature = "luau"))]
-impl BitOr for HookTriggers {
+impl std::ops::BitOr for HookTriggers {
     type Output = Self;
 
     fn bitor(mut self, rhs: Self) -> Self::Output {
@@ -397,7 +380,7 @@ impl BitOr for HookTriggers {
 }
 
 #[cfg(not(feature = "luau"))]
-impl BitOrAssign for HookTriggers {
+impl std::ops::BitOrAssign for HookTriggers {
     fn bitor_assign(&mut self, rhs: Self) {
         *self = *self | rhs;
     }

src/function.rs

@@ -434,7 +434,7 @@ impl Function {
     /// [`Compiler::set_coverage_level`]: crate::chunk::Compiler::set_coverage_level
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn coverage<F>(&self, mut func: F)
+    pub fn coverage<F>(&self, func: F)
     where
         F: FnMut(CoverageInfo),
     {
@@ -454,13 +454,16 @@ impl Function {
             } else {
                 None
             };
-            let rust_callback = &mut *(data as *mut F);
-            rust_callback(CoverageInfo {
-                function,
-                line_defined,
-                depth,
-                hits: slice::from_raw_parts(hits, size).to_vec(),
-            });
+            let rust_callback = &*(data as *const RefCell<F>);
+            if let Ok(mut rust_callback) = rust_callback.try_borrow_mut() {
+                // Call the Rust callback with CoverageInfo
+                rust_callback(CoverageInfo {
+                    function,
+                    line_defined,
+                    depth,
+                    hits: slice::from_raw_parts(hits, size).to_vec(),
+                });
+            }
         }
 
         let lua = self.0.lua.lock();
@@ -470,7 +473,8 @@ impl Function {
             assert_stack(state, 1);
 
             lua.push_ref(&self.0);
-            let func_ptr = &mut func as *mut F as *mut c_void;
+            let func = RefCell::new(func);
+            let func_ptr = &func as *const RefCell<F> as *mut c_void;
             ffi::lua_getcoverage(state, -1, func_ptr, callback::<F>);
         }
     }
@@ -653,6 +657,13 @@ impl LuaType for Function {
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AsyncCallFuture<R: FromLuaMulti>(Result<AsyncThread<R>>);
 
+#[cfg(feature = "async")]
+impl<R: FromLuaMulti> AsyncCallFuture<R> {
+    pub(crate) fn error(err: Error) -> Self {
+        AsyncCallFuture(Err(err))
+    }
+}
+
 #[cfg(feature = "async")]
 impl<R: FromLuaMulti> Future for AsyncCallFuture<R> {
     type Output = Result<R>;

src/lib.rs

@@ -75,9 +75,9 @@ mod macros;
 mod buffer;
 mod chunk;
 mod conversion;
+mod debug;
 mod error;
 mod function;
-mod hook;
 #[cfg(any(feature = "luau", doc))]
 mod luau;
 mod memory;
@@ -101,9 +101,9 @@ pub use bstr::BString;
 pub use ffi::{self, lua_CFunction, lua_State};
 
 pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
+pub use crate::debug::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
 pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
 pub use crate::function::{Function, FunctionInfo};
-pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
 pub use crate::multi::{MultiValue, Variadic};
 pub use crate::scope::Scope;
 pub use crate::state::{GCMode, Lua, LuaOptions, WeakLua};
@@ -124,7 +124,7 @@ pub use crate::userdata::{
 pub use crate::value::{Nil, Value};
 
 #[cfg(not(feature = "luau"))]
-pub use crate::hook::HookTriggers;
+pub use crate::debug::HookTriggers;
 
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]

src/luau/mod.rs

@@ -7,6 +7,7 @@ use crate::error::Result;
 use crate::function::Function;
 use crate::state::{callback_error_ext, ExtraData, Lua};
 use crate::traits::{FromLuaMulti, IntoLua};
+use crate::types::MaybeSend;
 
 pub use require::{NavigateError, Require, TextRequirer};
 
@@ -17,7 +18,7 @@ impl Lua {
     /// and load modules.
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn create_require_function<R: Require + 'static>(&self, require: R) -> Result<Function> {
+    pub fn create_require_function<R: Require + MaybeSend + 'static>(&self, require: R) -> Result<Function> {
         require::create_require_function(self, require)
     }
 

src/luau/require.rs

@@ -14,7 +14,7 @@ use crate::state::{callback_error_ext, Lua};
 use crate::table::Table;
 use crate::types::MaybeSend;
 
-/// An error that can occur during navigation in the Luau `require` system.
+/// An error that can occur during navigation in the Luau `require-by-string` system.
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
 #[derive(Debug, Clone)]
@@ -50,10 +50,10 @@ impl From<Error> for NavigateError {
 #[cfg(feature = "luau")]
 type WriteResult = ffi::luarequire_WriteResult;
 
-/// A trait for handling modules loading and navigation in the Luau `require` system.
+/// A trait for handling modules loading and navigation in the Luau `require-by-string` system.
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-pub trait Require: MaybeSend {
+pub trait Require {
     /// Returns `true` if "require" is permitted for the given chunk name.
     fn is_require_allowed(&self, chunk_name: &str) -> bool;
 
@@ -103,23 +103,33 @@ impl fmt::Debug for dyn Require {
     }
 }
 
-/// The standard implementation of Luau `require` navigation.
-#[doc(hidden)]
+/// The standard implementation of Luau `require-by-string` navigation.
 #[derive(Default, Debug)]
 pub struct TextRequirer {
+    /// An absolute path to the current Luau module (not mapped to a physical file)
     abs_path: PathBuf,
+    /// A relative path to the current Luau module (not mapped to a physical file)
     rel_path: PathBuf,
-    module_path: PathBuf,
+    /// A physical path to the current Luau module, which is a file or a directory with an
+    /// `init.lua(u)` file
+    resolved_path: Option<PathBuf>,
 }
 
 impl TextRequirer {
+    /// The prefix used for chunk names in the require system.
+    /// Only chunk names starting with this prefix are allowed to be used in `require`.
+    const CHUNK_PREFIX: &str = "@";
+
+    /// The file extensions that are considered valid for Luau modules.
+    const FILE_EXTENSIONS: &[&str] = &["luau", "lua"];
+
     /// Creates a new `TextRequirer` instance.
     pub fn new() -> Self {
         Self::default()
     }
 
     fn normalize_chunk_name(chunk_name: &str) -> &str {
-        if let Some((path, line)) = chunk_name.split_once(':') {
+        if let Some((path, line)) = chunk_name.rsplit_once(':') {
             if line.parse::<u32>().is_ok() {
                 return path;
             }
@@ -156,14 +166,17 @@ impl TextRequirer {
         components.into_iter().collect()
     }
 
-    fn find_module(path: &Path) -> StdResult<PathBuf, NavigateError> {
+    /// Resolve a Luau module path to a physical file or directory.
+    ///
+    /// Empty directories without init files are considered valid as "intermediate" directories.
+    fn resolve_module(path: &Path) -> StdResult<Option<PathBuf>, NavigateError> {
         let mut found_path = None;
 
         if path.components().next_back() != Some(Component::Normal("init".as_ref())) {
             let current_ext = (path.extension().and_then(|s| s.to_str()))
                 .map(|s| format!("{s}."))
                 .unwrap_or_default();
-            for ext in ["luau", "lua"] {
+            for ext in Self::FILE_EXTENSIONS {
                 let candidate = path.with_extension(format!("{current_ext}{ext}"));
                 if candidate.is_file() && found_path.replace(candidate).is_some() {
                     return Err(NavigateError::Ambiguous);
@@ -171,7 +184,7 @@ impl TextRequirer {
             }
         }
         if path.is_dir() {
-            for component in ["init.luau", "init.lua"] {
+            for component in Self::FILE_EXTENSIONS.iter().map(|ext| format!("init.{ext}")) {
                 let candidate = path.join(component);
                 if candidate.is_file() && found_path.replace(candidate).is_some() {
                     return Err(NavigateError::Ambiguous);
@@ -179,21 +192,22 @@ impl TextRequirer {
             }
 
             if found_path.is_none() {
-                found_path = Some(PathBuf::new());
+                // Directories without init files are considered valid "intermediate" path
+                return Ok(None);
             }
         }
 
-        found_path.ok_or(NavigateError::NotFound)
+        Ok(Some(found_path.ok_or(NavigateError::NotFound)?))
     }
 }
 
 impl Require for TextRequirer {
     fn is_require_allowed(&self, chunk_name: &str) -> bool {
-        chunk_name.starts_with('@')
+        chunk_name.starts_with(Self::CHUNK_PREFIX)
     }
 
     fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError> {
-        if !chunk_name.starts_with('@') {
+        if !chunk_name.starts_with(Self::CHUNK_PREFIX) {
             return Err(NavigateError::NotFound);
         }
         let chunk_name = Self::normalize_chunk_name(&chunk_name[1..]);
@@ -205,24 +219,24 @@ impl Require for TextRequirer {
             let cwd = env::current_dir().map_err(|_| NavigateError::NotFound)?;
             self.abs_path = Self::normalize_path(&cwd.join(chunk_filename));
             self.rel_path = ([Component::CurDir, Component::Normal(chunk_filename)].into_iter()).collect();
-            self.module_path = PathBuf::new();
+            self.resolved_path = None;
 
             return Ok(());
         }
 
         if chunk_path.is_absolute() {
-            let module_path = Self::find_module(&chunk_path)?;
+            let resolved_path = Self::resolve_module(&chunk_path)?;
             self.abs_path = chunk_path.clone();
             self.rel_path = chunk_path;
-            self.module_path = module_path;
+            self.resolved_path = resolved_path;
         } else {
             // Relative path
             let cwd = env::current_dir().map_err(|_| NavigateError::NotFound)?;
             let abs_path = Self::normalize_path(&cwd.join(&chunk_path));
-            let module_path = Self::find_module(&abs_path)?;
+            let resolved_path = Self::resolve_module(&abs_path)?;
             self.abs_path = abs_path;
             self.rel_path = chunk_path;
-            self.module_path = module_path;
+            self.resolved_path = resolved_path;
         }
 
         Ok(())
@@ -230,11 +244,11 @@ impl Require for TextRequirer {
 
     fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError> {
         let path = Self::normalize_path(path.as_ref());
-        let module_path = Self::find_module(&path)?;
+        let resolved_path = Self::resolve_module(&path)?;
 
         self.abs_path = path.clone();
         self.rel_path = path;
-        self.module_path = module_path;
+        self.resolved_path = resolved_path;
 
         Ok(())
     }
@@ -242,15 +256,18 @@ impl Require for TextRequirer {
     fn to_parent(&mut self) -> StdResult<(), NavigateError> {
         let mut abs_path = self.abs_path.clone();
         if !abs_path.pop() {
+            // It's important to return `NotFound` if we reached the root, as it's a "recoverable" error if we
+            // cannot go beyond the root directory.
+            // Luau "require-by-string` has a special logic to search for config file to resolve aliases.
             return Err(NavigateError::NotFound);
         }
         let mut rel_parent = self.rel_path.clone();
         rel_parent.pop();
-        let module_path = Self::find_module(&abs_path)?;
+        let resolved_path = Self::resolve_module(&abs_path)?;
 
         self.abs_path = abs_path;
         self.rel_path = Self::normalize_path(&rel_parent);
-        self.module_path = module_path;
+        self.resolved_path = resolved_path;
 
         Ok(())
     }
@@ -258,21 +275,23 @@ impl Require for TextRequirer {
     fn to_child(&mut self, name: &str) -> StdResult<(), NavigateError> {
         let abs_path = self.abs_path.join(name);
         let rel_path = self.rel_path.join(name);
-        let module_path = Self::find_module(&abs_path)?;
+        let resolved_path = Self::resolve_module(&abs_path)?;
 
         self.abs_path = abs_path;
         self.rel_path = rel_path;
-        self.module_path = module_path;
+        self.resolved_path = resolved_path;
 
         Ok(())
     }
 
     fn has_module(&self) -> bool {
-        self.module_path.is_file()
+        (self.resolved_path.as_deref())
+            .map(Path::is_file)
+            .unwrap_or(false)
     }
 
     fn cache_key(&self) -> String {
-        self.module_path.display().to_string()
+        self.resolved_path.as_deref().unwrap().display().to_string()
     }
 
     fn has_config(&self) -> bool {
@@ -285,7 +304,9 @@ impl Require for TextRequirer {
 
     fn loader(&self, lua: &Lua) -> Result<Function> {
         let name = format!("@{}", self.rel_path.display());
-        lua.load(&*self.module_path).set_name(name).into_function()
+        lua.load(self.resolved_path.as_deref().unwrap())
+            .set_name(name)
+            .into_function()
     }
 }
 
@@ -496,7 +517,10 @@ unsafe fn write_to_buffer(
 }
 
 #[cfg(feature = "luau")]
-pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> Result<Function> {
+pub(super) fn create_require_function<R: Require + MaybeSend + 'static>(
+    lua: &Lua,
+    require: R,
+) -> Result<Function> {
     unsafe extern "C-unwind" fn find_current_file(state: *mut ffi::lua_State) -> c_int {
         let mut ar: ffi::lua_Debug = mem::zeroed();
         for level in 2.. {
@@ -543,10 +567,26 @@ pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> R
         1
     }
 
-    let (error, r#type) = unsafe {
-        lua.exec_raw::<(Function, Function)>((), move |state| {
+    unsafe extern "C-unwind" fn to_lowercase(state: *mut ffi::lua_State) -> c_int {
+        let s = ffi::luaL_checkstring(state, 1);
+        let s = CStr::from_ptr(s);
+        if !s.to_bytes().iter().any(|&c| c.is_ascii_uppercase()) {
+            // If the string does not contain any uppercase ASCII letters, return it as is
+            return 1;
+        }
+        callback_error_ext(state, ptr::null_mut(), true, |extra, _| {
+            let s = (s.to_bytes().iter())
+                .map(|&c| c.to_ascii_lowercase())
+                .collect::<bstr::BString>();
+            (*extra).raw_lua().push(s).map(|_| 1)
+        })
+    }
+
+    let (error, r#type, to_lowercase) = unsafe {
+        lua.exec_raw::<(Function, Function, Function)>((), move |state| {
             ffi::lua_pushcfunctiond(state, error, cstr!("error"));
             ffi::lua_pushcfunctiond(state, r#type, cstr!("type"));
+            ffi::lua_pushcfunctiond(state, to_lowercase, cstr!("to_lowercase"));
         })
     }?;
 
@@ -559,6 +599,7 @@ pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> R
     env.raw_set("LOADER_CACHE", loader_cache)?;
     env.raw_set("error", error)?;
     env.raw_set("type", r#type)?;
+    env.raw_set("to_lowercase", to_lowercase)?;
 
     lua.load(
         r#"
@@ -568,7 +609,7 @@ pub fn create_require_function<R: Require + 'static>(lua: &Lua, require: R) -> R
         end
 
         -- Check if the module (path) is explicitly registered
-        local maybe_result = REGISTERED_MODULES[path]
+        local maybe_result = REGISTERED_MODULES[to_lowercase(path)]
         if maybe_result ~= nil then
             return maybe_result
         end

src/multi.rs

@@ -297,6 +297,15 @@ impl<T: IntoLua> IntoLuaMulti for Variadic<T> {
     fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
         MultiValue::from_lua_iter(lua, self)
     }
+
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        let nresults = self.len() as i32;
+        check_stack(lua.state(), nresults + 1)?;
+        for value in self.0 {
+            value.push_into_stack(lua)?;
+        }
+        Ok(nresults)
+    }
 }
 
 impl<T: FromLua> FromLuaMulti for Variadic<T> {

src/prelude.rs

@@ -25,7 +25,8 @@ pub use crate::HookTriggers as LuaHookTriggers;
 #[doc(no_inline)]
 pub use crate::{
     CompileConstant as LuaCompileConstant, CoverageInfo as LuaCoverageInfo,
-    NavigateError as LuaNavigateError, Require as LuaRequire, Vector as LuaVector,
+    NavigateError as LuaNavigateError, Require as LuaRequire, TextRequirer as LuaTextRequirer,
+    Vector as LuaVector,
 };
 
 #[cfg(feature = "async")]

src/serde/de.rs

@@ -165,7 +165,10 @@ impl<'de> serde::Deserializer<'de> for Deserializer {
                 serde_userdata(ud, |value| value.deserialize_any(visitor))
             }
             #[cfg(feature = "luau")]
-            Value::Buffer(buf) => visitor.visit_bytes(unsafe { buf.as_slice() }),
+            Value::Buffer(buf) => {
+                let lua = buf.0.lua.lock();
+                visitor.visit_bytes(buf.as_slice(&lua))
+            }
             Value::Function(_)
             | Value::Thread(_)
             | Value::UserData(_)

src/serde/ser.rs

@@ -256,7 +256,7 @@ impl<'a> ser::Serializer for Serializer<'a> {
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
         let table = self.lua.create_table_with_capacity(len.unwrap_or(0), 0)?;
         if self.options.set_array_metatable {
-            table.set_metatable(Some(self.lua.array_metatable()));
+            table.set_metatable(Some(self.lua.array_metatable()))?;
         }
         Ok(SerializeSeq::new(self.lua, table, self.options))
     }
@@ -529,8 +529,8 @@ impl ser::SerializeStruct for SerializeStruct<'_> {
     fn end(self) -> Result<Value> {
         match self.inner {
             Some(table @ Value::Table(_)) => Ok(table),
-            Some(value) if self.options.detect_serde_json_arbitrary_precision => {
-                let number_s = value.as_str().expect("not an arbitrary precision number");
+            Some(value @ Value::String(_)) if self.options.detect_serde_json_arbitrary_precision => {
+                let number_s = value.to_string()?;
                 if number_s.contains(['.', 'e', 'E']) {
                     if let Ok(number) = number_s.parse().map(Value::Number) {
                         return Ok(number);

src/state.rs

@@ -8,9 +8,9 @@ use std::result::Result as StdResult;
 use std::{fmt, mem, ptr};
 
 use crate::chunk::{AsChunk, Chunk};
+use crate::debug::Debug;
 use crate::error::{Error, Result};
 use crate::function::Function;
-use crate::hook::Debug;
 use crate::memory::MemoryState;
 use crate::multi::MultiValue;
 use crate::scope::Scope;
@@ -28,7 +28,7 @@ use crate::util::{assert_stack, check_stack, protect_lua_closure, push_string, r
 use crate::value::{Nil, Value};
 
 #[cfg(not(feature = "luau"))]
-use crate::{hook::HookTriggers, types::HookKind};
+use crate::{debug::HookTriggers, types::HookKind};
 
 #[cfg(any(feature = "luau", doc))]
 use crate::{buffer::Buffer, chunk::Compiler};
@@ -358,6 +358,8 @@ impl Lua {
         if cfg!(feature = "luau") && !modname.starts_with('@') {
             return Err(Error::runtime("module name must begin with '@'"));
         }
+        #[cfg(feature = "luau")]
+        let modname = modname.to_ascii_lowercase();
         unsafe {
             self.exec_raw::<()>(value, |state| {
                 ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, LOADED_MODULES_KEY);
@@ -544,7 +546,7 @@ impl Lua {
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn set_global_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
     where
-        F: Fn(&Lua, Debug) -> Result<VmState> + MaybeSend + 'static,
+        F: Fn(&Lua, &Debug) -> Result<VmState> + MaybeSend + 'static,
     {
         let lua = self.lock();
         unsafe {
@@ -577,7 +579,7 @@ impl Lua {
     /// # fn main() -> Result<()> {
     /// let lua = Lua::new();
     /// lua.set_hook(HookTriggers::EVERY_LINE, |_lua, debug| {
-    ///     println!("line {}", debug.curr_line());
+    ///     println!("line {:?}", debug.current_line());
     ///     Ok(VmState::Continue)
     /// });
     ///
@@ -594,7 +596,7 @@ impl Lua {
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
     where
-        F: Fn(&Lua, Debug) -> Result<VmState> + MaybeSend + 'static,
+        F: Fn(&Lua, &Debug) -> Result<VmState> + MaybeSend + 'static,
     {
         let lua = self.lock();
         unsafe { lua.set_thread_hook(lua.state(), HookKind::Thread(triggers, XRc::new(callback))) }
@@ -869,18 +871,16 @@ impl Lua {
         }
     }
 
-    /// Gets information about the interpreter runtime stack.
+    /// Gets information about the interpreter runtime stack at a given level.
     ///
-    /// This function returns [`Debug`] structure that can be used to get information about the
-    /// function executing at a given level. Level `0` is the current running function, whereas
-    /// level `n+1` is the function that has called level `n` (except for tail calls, which do
-    /// not count in the stack).
-    ///
-    /// [`Debug`]: crate::hook::Debug
-    pub fn inspect_stack(&self, level: usize) -> Option<Debug<'_>> {
+    /// This function calls callback `f`, passing the [`Debug`] structure that can be used to get
+    /// information about the function executing at a given level.
+    /// Level `0` is the current running function, whereas level `n+1` is the function that has
+    /// called level `n` (except for tail calls, which do not count in the stack).
+    pub fn inspect_stack<R>(&self, level: usize, f: impl FnOnce(&Debug) -> R) -> Option<R> {
         let lua = self.lock();
         unsafe {
-            let mut ar: ffi::lua_Debug = mem::zeroed();
+            let mut ar = mem::zeroed::<ffi::lua_Debug>();
             let level = level as c_int;
             #[cfg(not(feature = "luau"))]
             if ffi::lua_getstack(lua.state(), level, &mut ar) == 0 {
@@ -890,7 +890,8 @@ impl Lua {
             if ffi::lua_getinfo(lua.state(), level, cstr!(""), &mut ar) == 0 {
                 return None;
             }
-            Some(Debug::new_owned(lua, level, ar))
+
+            Some(f(&Debug::new(&lua, level, &mut ar)))
         }
     }
 
@@ -1287,8 +1288,24 @@ impl Lua {
     /// This function is unsafe because provides a way to execute unsafe C function.
     pub unsafe fn create_c_function(&self, func: ffi::lua_CFunction) -> Result<Function> {
         let lua = self.lock();
-        ffi::lua_pushcfunction(lua.ref_thread(), func);
-        Ok(Function(lua.pop_ref_thread()))
+        if cfg!(any(feature = "lua54", feature = "lua53", feature = "lua52")) {
+            ffi::lua_pushcfunction(lua.ref_thread(), func);
+            return Ok(Function(lua.pop_ref_thread()));
+        }
+
+        // Lua <5.2 requires memory allocation to push a C function
+        let state = lua.state();
+        {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 3)?;
+
+            if lua.unlikely_memory_error() {
+                ffi::lua_pushcfunction(state, func);
+            } else {
+                protect_lua!(state, 0, 1, |state| ffi::lua_pushcfunction(state, func))?;
+            }
+            Ok(Function(lua.pop_ref()))
+        }
     }
 
     /// Wraps a Rust async function or closure, creating a callable Lua function handle to it.
@@ -1417,7 +1434,7 @@ impl Lua {
         let lua = self.lock();
         unsafe {
             // Deregister the type if it already registered
-            if let Some(&table_id) = (*lua.extra.get()).registered_userdata_t.get(&type_id) {
+            if let Some(table_id) = (*lua.extra.get()).registered_userdata_t.remove(&type_id) {
                 ffi::luaL_unref(lua.state(), ffi::LUA_REGISTRYINDEX, table_id);
             }
 
@@ -1551,6 +1568,39 @@ impl Lua {
         }
     }
 
+    /// Sets the global environment.
+    ///
+    /// This will replace the current global environment with the provided `globals` table.
+    ///
+    /// For Lua 5.2+ the globals table is stored in the registry and shared between all threads.
+    /// For Lua 5.1 and Luau the globals table is stored in each thread.
+    ///
+    /// Please note that any existing Lua functions have cached global environment and will not
+    /// see the changes made by this method.
+    /// To update the environment for existing Lua functions, use [`Function::set_environment`].
+    pub fn set_globals(&self, globals: Table) -> Result<()> {
+        let lua = self.lock();
+        let state = lua.state();
+        unsafe {
+            #[cfg(feature = "luau")]
+            if (*lua.extra.get()).sandboxed {
+                return Err(Error::runtime("cannot change globals in a sandboxed Lua state"));
+            }
+
+            let _sg = StackGuard::new(state);
+            check_stack(state, 1)?;
+
+            lua.push_ref(&globals.0);
+
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            ffi::lua_rawseti(state, ffi::LUA_REGISTRYINDEX, ffi::LUA_RIDX_GLOBALS);
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            ffi::lua_replace(state, ffi::LUA_GLOBALSINDEX);
+        }
+
+        Ok(())
+    }
+
     /// Returns a handle to the active `Thread`.
     ///
     /// For calls to `Lua` this will be the main Lua thread, for parameters given to a callback,
@@ -2030,7 +2080,6 @@ impl Lua {
         WeakLua(XRc::downgrade(&self.raw))
     }
 
-    // Luau version located in `luau/mod.rs`
     #[cfg(not(feature = "luau"))]
     fn disable_c_modules(&self) -> Result<()> {
         let package: Table = self.globals().get("package")?;
@@ -2053,7 +2102,9 @@ impl Lua {
 
         // The third and fourth searchers looks for a loader as a C library
         searchers.raw_set(3, loader)?;
-        searchers.raw_remove(4)?;
+        if searchers.raw_len() >= 4 {
+            searchers.raw_remove(4)?;
+        }
 
         Ok(())
     }

src/state/extra.rs

@@ -76,7 +76,7 @@ pub(crate) struct ExtraData {
     #[cfg(not(feature = "luau"))]
     pub(super) hook_callback: Option<crate::types::HookCallback>,
     #[cfg(not(feature = "luau"))]
-    pub(super) hook_triggers: crate::hook::HookTriggers,
+    pub(super) hook_triggers: crate::debug::HookTriggers,
     #[cfg(feature = "lua54")]
     pub(super) warn_callback: Option<crate::types::WarnCallback>,
     #[cfg(feature = "luau")]
@@ -270,7 +270,7 @@ impl ExtraData {
         // Try to grow max stack size
         if self.ref_stack_top >= self.ref_stack_size {
             let mut inc = self.ref_stack_size; // Try to double stack size
-            while inc > 0 && ffi::lua_checkstack(self.ref_thread, inc) == 0 {
+            while inc > 0 && ffi::lua_checkstack(self.ref_thread, inc + REF_STACK_RESERVE) == 0 {
                 inc /= 2;
             }
             if inc == 0 {

src/state/raw.rs

@@ -38,7 +38,7 @@ use super::{Lua, LuaOptions, WeakLua};
 
 #[cfg(not(feature = "luau"))]
 use crate::{
-    hook::Debug,
+    debug::Debug,
     types::{HookCallback, HookKind, VmState},
 };
 
@@ -296,7 +296,7 @@ impl RawLua {
         if is_safe {
             let curr_libs = (*self.extra.get()).libs;
             if (curr_libs ^ (curr_libs | libs)).contains(StdLib::PACKAGE) {
-                mlua_expect!(self.lua().disable_c_modules(), "Error during disabling C modules");
+                mlua_expect!(self.lua().disable_c_modules(), "Error disabling C modules");
             }
         }
         #[cfg(feature = "luau")]
@@ -435,8 +435,8 @@ impl RawLua {
                 match (*extra).hook_callback.clone() {
                     Some(hook_callback) => {
                         let rawlua = (*extra).raw_lua();
-                        let debug = Debug::new(rawlua, ar);
-                        hook_callback((*extra).lua(), debug)
+                        let debug = Debug::new(rawlua, 0, ar);
+                        hook_callback((*extra).lua(), &debug)
                     }
                     None => {
                         ffi::lua_sethook(state, None, 0, 0);
@@ -465,9 +465,9 @@ impl RawLua {
 
             let status = callback_error_ext(state, ptr::null_mut(), false, |extra, _| {
                 let rawlua = (*extra).raw_lua();
-                let debug = Debug::new(rawlua, ar);
+                let debug = Debug::new(rawlua, 0, ar);
                 let hook_callback = (*hook_callback_ptr).clone();
-                hook_callback((*extra).lua(), debug)
+                hook_callback((*extra).lua(), &debug)
             });
             process_status(state, (*ar).event, status)
         }
@@ -728,7 +728,7 @@ impl RawLua {
 
                 let n = ffi::lua_tonumber(state, idx);
                 match num_traits::cast(n) {
-                    Some(i) if (n - (i as Number)).abs() < Number::EPSILON => Value::Integer(i),
+                    Some(i) if n.to_bits() == (i as Number).to_bits() => Value::Integer(i),
                     _ => Value::Number(n),
                 }
             }

src/string.rs

@@ -86,7 +86,7 @@ impl String {
 
     /// Get the bytes that make up this string.
     ///
-    /// The returned slice will not contain the terminating nul byte, but will contain any nul
+    /// The returned slice will not contain the terminating null byte, but will contain any null
     /// bytes embedded into the Lua string.
     ///
     /// # Examples
@@ -106,15 +106,15 @@ impl String {
         BorrowedBytes::from(self)
     }
 
-    /// Get the bytes that make up this string, including the trailing nul byte.
+    /// Get the bytes that make up this string, including the trailing null byte.
     pub fn as_bytes_with_nul(&self) -> BorrowedBytes<'_> {
         let BorrowedBytes { buf, borrow, _lua } = BorrowedBytes::from(self);
-        // Include the trailing nul byte (it's always present but excluded by default)
+        // Include the trailing null byte (it's always present but excluded by default)
         let buf = unsafe { slice::from_raw_parts((*buf).as_ptr(), (*buf).len() + 1) };
         BorrowedBytes { buf, borrow, _lua }
     }
 
-    // Does not return the terminating nul byte
+    // Does not return the terminating null byte
     unsafe fn to_slice(&self) -> (&[u8], Lua) {
         let lua = self.0.lua.upgrade();
         let slice = {

src/table.rs

@@ -13,7 +13,7 @@ use crate::util::{assert_stack, check_stack, get_metatable_ptr, StackGuard};
 use crate::value::{Nil, Value};
 
 #[cfg(feature = "async")]
-use futures_util::future::{self, Either, Future};
+use crate::function::AsyncCallFuture;
 
 #[cfg(feature = "serde")]
 use {
@@ -211,7 +211,7 @@ impl Table {
     ///
     /// let always_equals_mt = lua.create_table()?;
     /// always_equals_mt.set("__eq", lua.create_function(|_, (_t1, _t2): (Table, Table)| Ok(true))?)?;
-    /// table2.set_metatable(Some(always_equals_mt));
+    /// table2.set_metatable(Some(always_equals_mt))?;
     ///
     /// assert!(table1.equals(&table1.clone())?);
     /// assert!(table1.equals(&table2)?);
@@ -487,16 +487,12 @@ impl Table {
     /// [`getmetatable`]: https://www.lua.org/manual/5.4/manual.html#pdf-getmetatable
     pub fn metatable(&self) -> Option<Table> {
         let lua = self.0.lua.lock();
-        let state = lua.state();
+        let ref_thread = lua.ref_thread();
         unsafe {
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 2);
-
-            lua.push_ref(&self.0);
-            if ffi::lua_getmetatable(state, -1) == 0 {
+            if ffi::lua_getmetatable(ref_thread, self.0.index) == 0 {
                 None
             } else {
-                Some(Table(lua.pop_ref()))
+                Some(Table(lua.pop_ref_thread()))
             }
         }
     }
@@ -505,27 +501,23 @@ impl Table {
     ///
     /// If `metatable` is `None`, the metatable is removed (if no metatable is set, this does
     /// nothing).
-    pub fn set_metatable(&self, metatable: Option<Table>) {
-        // Workaround to throw readonly error without returning Result
+    pub fn set_metatable(&self, metatable: Option<Table>) -> Result<()> {
         #[cfg(feature = "luau")]
         if self.is_readonly() {
-            panic!("attempt to modify a readonly table");
+            return Err(Error::runtime("attempt to modify a readonly table"));
         }
 
         let lua = self.0.lua.lock();
-        let state = lua.state();
+        let ref_thread = lua.ref_thread();
         unsafe {
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 2);
-
-            lua.push_ref(&self.0);
-            if let Some(metatable) = metatable {
-                lua.push_ref(&metatable.0);
+            if let Some(metatable) = &metatable {
+                ffi::lua_pushvalue(ref_thread, metatable.0.index);
             } else {
-                ffi::lua_pushnil(state);
+                ffi::lua_pushnil(ref_thread);
             }
-            ffi::lua_setmetatable(state, -2);
+            ffi::lua_setmetatable(ref_thread, self.0.index);
         }
+        Ok(())
     }
 
     /// Returns true if the table has metatable attached.
@@ -897,7 +889,7 @@ impl ObjectLike for Table {
 
     #[cfg(feature = "async")]
     #[inline]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti,
     {
@@ -913,7 +905,7 @@ impl ObjectLike for Table {
     }
 
     #[cfg(feature = "async")]
-    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti,
     {
@@ -933,17 +925,17 @@ impl ObjectLike for Table {
 
     #[cfg(feature = "async")]
     #[inline]
-    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti,
     {
         match self.get(name) {
-            Ok(Value::Function(func)) => Either::Left(func.call_async(args)),
+            Ok(Value::Function(func)) => func.call_async(args),
             Ok(val) => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
-                Either::Right(future::ready(Err(Error::RuntimeError(msg))))
+                AsyncCallFuture::error(Error::RuntimeError(msg))
             }
-            Err(err) => Either::Right(future::ready(Err(err))),
+            Err(err) => AsyncCallFuture::error(err),
         }
     }
 

src/thread.rs

@@ -10,7 +10,7 @@ use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
 
 #[cfg(not(feature = "luau"))]
 use crate::{
-    hook::{Debug, HookTriggers},
+    debug::{Debug, HookTriggers},
     types::HookKind,
 };
 
@@ -86,13 +86,15 @@ unsafe impl Sync for Thread {}
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AsyncThread<R> {
     thread: Thread,
-    ret: PhantomData<R>,
+    ret: PhantomData<fn() -> R>,
     recycle: bool,
 }
 
 impl Thread {
+    /// Returns reference to the Lua state that this thread is associated with.
+    #[doc(hidden)]
     #[inline(always)]
-    fn state(&self) -> *mut ffi::lua_State {
+    pub fn state(&self) -> *mut ffi::lua_State {
         self.1
     }
 
@@ -269,7 +271,7 @@ impl Thread {
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
     where
-        F: Fn(&crate::Lua, Debug) -> Result<crate::VmState> + crate::MaybeSend + 'static,
+        F: Fn(&crate::Lua, &Debug) -> Result<crate::VmState> + crate::MaybeSend + 'static,
     {
         let lua = self.0.lua.lock();
         unsafe {

src/traits.rs

@@ -11,7 +11,7 @@ use crate::util::{check_stack, short_type_name};
 use crate::value::Value;
 
 #[cfg(feature = "async")]
-use std::future::Future;
+use {crate::function::AsyncCallFuture, std::future::Future};
 
 /// Trait for types convertible to [`Value`].
 pub trait IntoLua: Sized {
@@ -162,7 +162,7 @@ pub trait ObjectLike: Sealed {
     /// arguments.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti;
 
@@ -178,7 +178,7 @@ pub trait ObjectLike: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti;
 
@@ -196,7 +196,7 @@ pub trait ObjectLike: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti;
 

src/types.rs

@@ -1,9 +1,9 @@
 use std::cell::UnsafeCell;
 use std::os::raw::{c_int, c_void};
 
-use crate::error::Result;
 #[cfg(not(feature = "luau"))]
-use crate::hook::{Debug, HookTriggers};
+use crate::debug::{Debug, HookTriggers};
+use crate::error::Result;
 use crate::state::{ExtraData, Lua, RawLua};
 
 // Re-export mutex wrappers
@@ -79,10 +79,10 @@ pub(crate) enum HookKind {
 }
 
 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = XRc<dyn Fn(&Lua, Debug) -> Result<VmState> + Send>;
+pub(crate) type HookCallback = XRc<dyn Fn(&Lua, &Debug) -> Result<VmState> + Send>;
 
 #[cfg(all(not(feature = "send"), not(feature = "luau")))]
-pub(crate) type HookCallback = XRc<dyn Fn(&Lua, Debug) -> Result<VmState>>;
+pub(crate) type HookCallback = XRc<dyn Fn(&Lua, &Debug) -> Result<VmState>>;
 
 #[cfg(all(feature = "send", feature = "luau"))]
 pub(crate) type InterruptCallback = XRc<dyn Fn(&Lua) -> Result<VmState> + Send>;

src/userdata.rs

@@ -240,6 +240,13 @@ impl AsRef<str> for MetaMethod {
     }
 }
 
+impl From<MetaMethod> for StdString {
+    #[inline]
+    fn from(method: MetaMethod) -> Self {
+        method.name().to_owned()
+    }
+}
+
 /// Method registry for [`UserData`] implementors.
 pub trait UserDataMethods<T> {
     /// Add a regular method which accepts a `&T` as the first parameter.
@@ -249,7 +256,7 @@ pub trait UserDataMethods<T> {
     ///
     /// If `add_meta_method` is used to set the `__index` metamethod, the `__index` metamethod will
     /// be used as a fall-back if no regular method is found.
-    fn add_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -260,7 +267,7 @@ pub trait UserDataMethods<T> {
     /// Refer to [`add_method`] for more information about the implementation.
     ///
     /// [`add_method`]: UserDataMethods::add_method
-    fn add_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -273,7 +280,7 @@ pub trait UserDataMethods<T> {
     /// [`add_method`]: UserDataMethods::add_method
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -288,7 +295,7 @@ pub trait UserDataMethods<T> {
     /// [`add_method`]: UserDataMethods::add_method
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -301,7 +308,7 @@ pub trait UserDataMethods<T> {
     /// The first argument will be a [`AnyUserData`] of type `T` if the method is called with Lua
     /// method syntax: `my_userdata:my_method(arg1, arg2)`, or it is passed in as the first
     /// argument: `my_userdata.my_method(my_userdata, arg1, arg2)`.
-    fn add_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -312,7 +319,7 @@ pub trait UserDataMethods<T> {
     /// This is a version of [`add_function`] that accepts a `FnMut` argument.
     ///
     /// [`add_function`]: UserDataMethods::add_function
-    fn add_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -326,7 +333,7 @@ pub trait UserDataMethods<T> {
     /// [`add_function`]: UserDataMethods::add_function
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(Lua, A) -> FR + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -341,7 +348,7 @@ pub trait UserDataMethods<T> {
     /// side has a metatable. To prevent this, use [`add_meta_function`].
     ///
     /// [`add_meta_function`]: UserDataMethods::add_meta_function
-    fn add_meta_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -355,7 +362,7 @@ pub trait UserDataMethods<T> {
     /// side has a metatable. To prevent this, use [`add_meta_function`].
     ///
     /// [`add_meta_function`]: UserDataMethods::add_meta_function
-    fn add_meta_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -371,7 +378,7 @@ pub trait UserDataMethods<T> {
         docsrs,
         doc(cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau")))))
     )]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -387,7 +394,7 @@ pub trait UserDataMethods<T> {
     /// [`add_meta_method_mut`]: UserDataMethods::add_meta_method_mut
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -400,7 +407,7 @@ pub trait UserDataMethods<T> {
     /// Metamethods for binary operators can be triggered if either the left or right argument to
     /// the binary operator has a metatable, so the first argument here is not necessarily a
     /// userdata of type `T`.
-    fn add_meta_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -411,7 +418,7 @@ pub trait UserDataMethods<T> {
     /// This is a version of [`add_meta_function`] that accepts a `FnMut` argument.
     ///
     /// [`add_meta_function`]: UserDataMethods::add_meta_function
-    fn add_meta_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -427,7 +434,7 @@ pub trait UserDataMethods<T> {
         docsrs,
         doc(cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau")))))
     )]
-    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(Lua, A) -> FR + MaybeSend + 'static,
         A: FromLuaMulti,
@@ -446,7 +453,7 @@ pub trait UserDataFields<T> {
     ///
     /// If `add_meta_method` is used to set the `__index` metamethod, it will
     /// be used as a fall-back if no regular field or method are found.
-    fn add_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_field<V>(&mut self, name: impl Into<StdString>, value: V)
     where
         V: IntoLua + 'static;
 
@@ -457,7 +464,7 @@ pub trait UserDataFields<T> {
     ///
     /// If `add_meta_method` is used to set the `__index` metamethod, the `__index` metamethod will
     /// be used as a fall-back if no regular field or method are found.
-    fn add_field_method_get<M, R>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_get<M, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: Fn(&Lua, &T) -> Result<R> + MaybeSend + 'static,
         R: IntoLua;
@@ -470,21 +477,21 @@ pub trait UserDataFields<T> {
     ///
     /// If `add_meta_method` is used to set the `__newindex` metamethod, the `__newindex` metamethod
     /// will be used as a fall-back if no regular field is found.
-    fn add_field_method_set<M, A>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_set<M, A>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: FnMut(&Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua;
 
     /// Add a regular field getter as a function which accepts a generic [`AnyUserData`] of type `T`
     /// argument.
-    fn add_field_function_get<F, R>(&mut self, name: impl ToString, function: F)
+    fn add_field_function_get<F, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(&Lua, AnyUserData) -> Result<R> + MaybeSend + 'static,
         R: IntoLua;
 
     /// Add a regular field setter as a function which accepts a generic [`AnyUserData`] of type `T`
     /// first argument.
-    fn add_field_function_set<F, A>(&mut self, name: impl ToString, function: F)
+    fn add_field_function_set<F, A>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: FnMut(&Lua, AnyUserData, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua;
@@ -497,7 +504,7 @@ pub trait UserDataFields<T> {
     ///
     /// `mlua` will trigger an error on an attempt to define a protected metamethod,
     /// like `__gc` or `__metatable`.
-    fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_meta_field<V>(&mut self, name: impl Into<StdString>, value: V)
     where
         V: IntoLua + 'static;
 
@@ -509,7 +516,7 @@ pub trait UserDataFields<T> {
     ///
     /// `mlua` will trigger an error on an attempt to define a protected metamethod,
     /// like `__gc` or `__metatable`.
-    fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
+    fn add_meta_field_with<F, R>(&mut self, name: impl Into<StdString>, f: F)
     where
         F: FnOnce(&Lua) -> Result<R> + 'static,
         R: IntoLua;
@@ -881,16 +888,17 @@ impl AnyUserData {
         self.raw_metatable().map(UserDataMetatable)
     }
 
+    /// Returns a raw metatable of this [`AnyUserData`].
     fn raw_metatable(&self) -> Result<Table> {
         let lua = self.0.lua.lock();
-        let state = lua.state();
+        let ref_thread = lua.ref_thread();
         unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 3)?;
+            // Check that userdata is registered and not destructed
+            // All registered userdata types have a non-empty metatable
+            let _type_id = lua.get_userdata_ref_type_id(&self.0)?;
 
-            lua.push_userdata_ref(&self.0)?;
-            ffi::lua_getmetatable(state, -1); // Checked that non-empty on the previous call
-            Ok(Table(lua.pop_ref()))
+            ffi::lua_getmetatable(ref_thread, self.0.index);
+            Ok(Table(lua.pop_ref_thread()))
         }
     }
 

src/userdata/object.rs

@@ -8,7 +8,7 @@ use crate::value::Value;
 use crate::Function;
 
 #[cfg(feature = "async")]
-use futures_util::future::{self, Either, Future};
+use crate::function::AsyncCallFuture;
 
 impl ObjectLike for AnyUserData {
     #[inline]
@@ -35,7 +35,7 @@ impl ObjectLike for AnyUserData {
 
     #[cfg(feature = "async")]
     #[inline]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti,
     {
@@ -51,7 +51,7 @@ impl ObjectLike for AnyUserData {
     }
 
     #[cfg(feature = "async")]
-    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti,
     {
@@ -72,17 +72,17 @@ impl ObjectLike for AnyUserData {
     }
 
     #[cfg(feature = "async")]
-    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
         R: FromLuaMulti,
     {
         match self.get(name) {
-            Ok(Value::Function(func)) => Either::Left(func.call_async(args)),
+            Ok(Value::Function(func)) => func.call_async(args),
             Ok(val) => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
-                Either::Right(future::ready(Err(Error::RuntimeError(msg))))
+                AsyncCallFuture::error(Error::RuntimeError(msg))
             }
-            Err(err) => Either::Right(future::ready(Err(err))),
+            Err(err) => AsyncCallFuture::error(err),
         }
     }
 

src/userdata/ref.rs

@@ -63,7 +63,7 @@ impl<T> TryFrom<UserDataVariant<T>> for UserDataRef<T> {
 
     #[inline]
     fn try_from(variant: UserDataVariant<T>) -> Result<Self> {
-        let guard = if !cfg!(feature = "send") || is_sync::<T>() {
+        let guard = if cfg!(not(feature = "send")) || is_sync::<T>() {
             variant.raw_lock().try_lock_shared_guarded()
         } else {
             variant.raw_lock().try_lock_exclusive_guarded()

src/userdata/registry.rs

@@ -365,101 +365,101 @@ fn get_function_name<T>(name: &str) -> StdString {
 }
 
 impl<T> UserDataFields<T> for UserDataRegistry<T> {
-    fn add_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_field<V>(&mut self, name: impl Into<StdString>, value: V)
     where
         V: IntoLua + 'static,
     {
-        let name = name.to_string();
+        let name = name.into();
         self.raw.fields.push((name, value.into_lua(self.lua.lua())));
     }
 
-    fn add_field_method_get<M, R>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_get<M, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: Fn(&Lua, &T) -> Result<R> + MaybeSend + 'static,
         R: IntoLua,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_method(&name, move |lua, data, ()| method(lua, data));
         self.raw.field_getters.push((name, callback));
     }
 
-    fn add_field_method_set<M, A>(&mut self, name: impl ToString, method: M)
+    fn add_field_method_set<M, A>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: FnMut(&Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_method_mut(&name, method);
         self.raw.field_setters.push((name, callback));
     }
 
-    fn add_field_function_get<F, R>(&mut self, name: impl ToString, function: F)
+    fn add_field_function_get<F, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(&Lua, AnyUserData) -> Result<R> + MaybeSend + 'static,
         R: IntoLua,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_function(&name, function);
         self.raw.field_getters.push((name, callback));
     }
 
-    fn add_field_function_set<F, A>(&mut self, name: impl ToString, mut function: F)
+    fn add_field_function_set<F, A>(&mut self, name: impl Into<StdString>, mut function: F)
     where
         F: FnMut(&Lua, AnyUserData, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_function_mut(&name, move |lua, (data, val)| function(lua, data, val));
         self.raw.field_setters.push((name, callback));
     }
 
-    fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
+    fn add_meta_field<V>(&mut self, name: impl Into<StdString>, value: V)
     where
         V: IntoLua + 'static,
     {
         let lua = self.lua.lua();
-        let name = name.to_string();
+        let name = name.into();
         let field = Self::check_meta_field(lua, &name, value).and_then(|v| v.into_lua(lua));
         self.raw.meta_fields.push((name, field));
     }
 
-    fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
+    fn add_meta_field_with<F, R>(&mut self, name: impl Into<StdString>, f: F)
     where
         F: FnOnce(&Lua) -> Result<R> + 'static,
         R: IntoLua,
     {
         let lua = self.lua.lua();
-        let name = name.to_string();
+        let name = name.into();
         let field = f(lua).and_then(|v| Self::check_meta_field(lua, &name, v).and_then(|v| v.into_lua(lua)));
         self.raw.meta_fields.push((name, field));
     }
 }
 
 impl<T> UserDataMethods<T> for UserDataRegistry<T> {
-    fn add_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_method(&name, method);
         self.raw.methods.push((name, callback));
     }
 
-    fn add_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_method_mut(&name, method);
         self.raw.methods.push((name, callback));
     }
 
     #[cfg(feature = "async")]
-    fn add_async_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -467,13 +467,13 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
         MR: Future<Output = Result<R>> + MaybeSend + 'static,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_async_method(&name, method);
         self.raw.async_methods.push((name, callback));
     }
 
     #[cfg(feature = "async")]
-    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -481,70 +481,70 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
         MR: Future<Output = Result<R>> + MaybeSend + 'static,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_async_method_mut(&name, method);
         self.raw.async_methods.push((name, callback));
     }
 
-    fn add_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_function(&name, function);
         self.raw.methods.push((name, callback));
     }
 
-    fn add_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_function_mut(&name, function);
         self.raw.methods.push((name, callback));
     }
 
     #[cfg(feature = "async")]
-    fn add_async_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(Lua, A) -> FR + MaybeSend + 'static,
         A: FromLuaMulti,
         FR: Future<Output = Result<R>> + MaybeSend + 'static,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_async_function(&name, function);
         self.raw.async_methods.push((name, callback));
     }
 
-    fn add_meta_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_method(&name, method);
         self.raw.meta_methods.push((name, callback));
     }
 
-    fn add_meta_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    fn add_meta_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_method_mut(&name, method);
         self.raw.meta_methods.push((name, callback));
     }
 
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
@@ -552,13 +552,13 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
         MR: Future<Output = Result<R>> + MaybeSend + 'static,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_async_method(&name, method);
         self.raw.async_meta_methods.push((name, callback));
     }
 
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl Into<StdString>, method: M)
     where
         T: 'static,
         M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
@@ -566,42 +566,42 @@ impl<T> UserDataMethods<T> for UserDataRegistry<T> {
         MR: Future<Output = Result<R>> + MaybeSend + 'static,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_async_method_mut(&name, method);
         self.raw.async_meta_methods.push((name, callback));
     }
 
-    fn add_meta_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_function(&name, function);
         self.raw.meta_methods.push((name, callback));
     }
 
-    fn add_meta_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    fn add_meta_function_mut<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_function_mut(&name, function);
         self.raw.meta_methods.push((name, callback));
     }
 
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl Into<StdString>, function: F)
     where
         F: Fn(Lua, A) -> FR + MaybeSend + 'static,
         A: FromLuaMulti,
         FR: Future<Output = Result<R>> + MaybeSend + 'static,
         R: IntoLuaMulti,
     {
-        let name = name.to_string();
+        let name = name.into();
         let callback = self.box_async_function(&name, function);
         self.raw.async_meta_methods.push((name, callback));
     }

src/util/mod.rs

@@ -88,7 +88,7 @@ impl Drop for StackGuard {
 #[inline(always)]
 pub(crate) unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect: bool) -> Result<()> {
     // Always use protected mode if the string is too long
-    if protect || s.len() > (1 << 30) {
+    if protect || s.len() >= const { 1 << 30 } {
         protect_lua!(state, 0, 1, |state| {
             ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
         })
@@ -122,7 +122,7 @@ pub(crate) unsafe fn push_table(
 ) -> Result<()> {
     let narr: c_int = narr.try_into().unwrap_or(c_int::MAX);
     let nrec: c_int = nrec.try_into().unwrap_or(c_int::MAX);
-    if protect {
+    if protect || narr >= const { 1 << 30 } || nrec >= const { 1 << 27 } {
         protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
     } else {
         ffi::lua_createtable(state, narr, nrec);

src/value.rs

@@ -356,6 +356,10 @@ impl Value {
     ///
     /// If the value is a Lua [`String`], try to convert it to [`BorrowedStr`] or return `None`
     /// otherwise.
+    #[deprecated(
+        since = "0.11.0",
+        note = "This method does not follow Rust naming convention. Use `as_string().and_then(|s| s.to_str().ok())` instead."
+    )]
     #[inline]
     pub fn as_str(&self) -> Option<BorrowedStr<'_>> {
         self.as_string().and_then(|s| s.to_str().ok())
@@ -364,6 +368,10 @@ impl Value {
     /// Cast the value to [`StdString`].
     ///
     /// If the value is a Lua [`String`], converts it to [`StdString`] or returns `None` otherwise.
+    #[deprecated(
+        since = "0.11.0",
+        note = "This method does not follow Rust naming convention. Use `as_string().map(|s| s.to_string_lossy())` instead."
+    )]
     #[inline]
     pub fn as_string_lossy(&self) -> Option<StdString> {
         self.as_string().map(|s| s.to_string_lossy())

tests/async.rs

@@ -386,7 +386,7 @@ async fn test_async_table_object_like() -> Result<()> {
             table.get::<i64>("val")
         })?,
     )?;
-    table.set_metatable(Some(metatable));
+    table.set_metatable(Some(metatable))?;
     assert_eq!(table.call_async::<i64>(()).await.unwrap(), 15);
 
     match table.call_async_method::<()>("non_existent", ()).await {

tests/chunk.rs

@@ -119,12 +119,11 @@ fn test_compiler() -> Result<()> {
         .set_debug_level(2)
         .set_type_info_level(1)
         .set_coverage_level(2)
-        .set_vector_lib("vector")
-        .set_vector_ctor("new")
+        .set_vector_ctor("vector.new")
         .set_vector_type("vector")
-        .set_mutable_globals(vec!["mutable_global"])
-        .set_userdata_types(vec!["MyUserdata"])
-        .set_disabled_builtins(vec!["tostring"]);
+        .set_mutable_globals(["mutable_global"])
+        .set_userdata_types(["MyUserdata"])
+        .set_disabled_builtins(["tostring"]);
 
     assert!(compiler.compile("return tostring(vector.new(1, 2, 3))").is_ok());
 
@@ -142,16 +141,14 @@ fn test_compiler() -> Result<()> {
 #[cfg(feature = "luau")]
 #[test]
 fn test_compiler_library_constants() {
-    use mlua::{CompileConstant, Compiler, Vector};
+    use mlua::{Compiler, Vector};
 
     let compiler = Compiler::new()
         .set_optimization_level(2)
-        .set_library_constants(vec![
-            ("mylib", "const_bool", CompileConstant::Boolean(true)),
-            ("mylib", "const_num", CompileConstant::Number(123.0)),
-            ("mylib", "const_vec", CompileConstant::Vector(Vector::zero())),
-            ("mylib", "const_str", "value1".into()),
-        ]);
+        .add_library_constant("mylib.const_bool", true)
+        .add_library_constant("mylib.const_num", 123.0)
+        .add_library_constant("mylib.const_vec", Vector::zero())
+        .add_library_constant("mylib.const_str", "value1");
 
     let lua = Lua::new();
     lua.set_compiler(compiler);

tests/conversion.rs

@@ -267,7 +267,7 @@ fn test_registry_value_into_lua() -> Result<()> {
     let r = lua.create_registry_value(&s)?;
     let value1 = lua.pack(&r)?;
     let value2 = lua.pack(r)?;
-    assert_eq!(value1.as_str().as_deref(), Some("hello, world"));
+    assert_eq!(value1.to_string()?, "hello, world");
     assert_eq!(value1.to_pointer(), value2.to_pointer());
 
     // Push into stack
@@ -560,11 +560,11 @@ fn test_osstring_into_from_lua() -> Result<()> {
 
     let v = lua.pack(s.as_os_str())?;
     assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), "hello, world");
+    assert_eq!(v.as_string().unwrap(), "hello, world");
 
     let v = lua.pack(s)?;
     assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), "hello, world");
+    assert_eq!(v.as_string().unwrap(), "hello, world");
 
     let s = lua.create_string("hello, world")?;
     let bstr = lua.unpack::<OsString>(Value::String(s))?;
@@ -588,11 +588,11 @@ fn test_pathbuf_into_from_lua() -> Result<()> {
 
     let v = lua.pack(pb.as_path())?;
     assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), pb_str);
+    assert_eq!(v.to_string().unwrap(), pb_str);
 
     let v = lua.pack(pb.clone())?;
     assert!(v.is_string());
-    assert_eq!(v.as_str().unwrap(), pb_str);
+    assert_eq!(v.to_string().unwrap(), pb_str);
 
     let s = lua.create_string(pb_str)?;
     let bstr = lua.unpack::<PathBuf>(Value::String(s))?;
@@ -724,7 +724,7 @@ fn test_char_into_lua() -> Result<()> {
 
     let v = '🦀';
     let v2 = v.into_lua(&lua)?;
-    assert_eq!(Some(v.to_string()), v2.as_string_lossy());
+    assert_eq!(*v2.as_string().unwrap(), v.to_string());
 
     Ok(())
 }

tests/hooks.rs

@@ -24,7 +24,7 @@ fn test_line_counts() -> Result<()> {
     let lua = Lua::new();
     lua.set_hook(HookTriggers::EVERY_LINE, move |_lua, debug| {
         assert_eq!(debug.event(), DebugEvent::Line);
-        hook_output.lock().unwrap().push(debug.curr_line());
+        hook_output.lock().unwrap().push(debug.current_line().unwrap());
         Ok(VmState::Continue)
     })?;
     lua.load(
@@ -240,7 +240,7 @@ fn test_hook_threads() -> Result<()> {
     let hook_output = output.clone();
     co.set_hook(HookTriggers::EVERY_LINE, move |_lua, debug| {
         assert_eq!(debug.event(), DebugEvent::Line);
-        hook_output.lock().unwrap().push(debug.curr_line());
+        hook_output.lock().unwrap().push(debug.current_line().unwrap());
         Ok(VmState::Continue)
     })?;
 

tests/luau.rs

@@ -3,7 +3,6 @@
 use std::cell::Cell;
 use std::fmt::Debug;
 use std::os::raw::c_void;
-use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicU64, Ordering};
 use std::sync::Arc;
 
@@ -120,11 +119,13 @@ fn test_vector_metatable() -> Result<()> {
     "#,
         )
         .eval::<Table>()?;
-    vector_mt.set_metatable(Some(vector_mt.clone()));
+    vector_mt.set_metatable(Some(vector_mt.clone()))?;
     lua.set_type_metatable::<Vector>(Some(vector_mt.clone()));
     lua.globals().set("Vector3", vector_mt)?;
 
-    let compiler = Compiler::new().set_vector_lib("Vector3").set_vector_ctor("new");
+    let compiler = Compiler::new()
+        .set_vector_ctor("Vector3.new")
+        .set_vector_type("Vector3");
 
     // Test vector methods (fastcall)
     lua.load(
@@ -167,9 +168,9 @@ fn test_readonly_table() -> Result<()> {
     check_readonly_error(t.raw_pop::<Value>());
 
     // Special case
-    match catch_unwind(AssertUnwindSafe(|| t.set_metatable(None))) {
-        Ok(_) => panic!("expected panic, got nothing"),
-        Err(_) => {}
+    match t.set_metatable(None) {
+        Err(Error::RuntimeError(e)) if e.contains("attempt to modify a readonly table") => {}
+        r => panic!("expected RuntimeError(...) with a specific message, got {r:?}"),
     }
 
     Ok(())

tests/luau/require.rs

@@ -179,6 +179,11 @@ fn test_require_with_config() {
     let res = run_require(&lua, "./tests/luau/require/with_config/src/alias_requirer").unwrap();
     assert_eq!("result from dependency", get_str(&res, 1));
 
+    // RequirePathWithAlias (case-insensitive)
+    let res2 = run_require(&lua, "./tests/luau/require/with_config/src/alias_requirer_uc").unwrap();
+    assert_eq!("result from dependency", get_str(&res2, 1));
+    assert_eq!(res.to_pointer(), res2.to_pointer());
+
     // RequirePathWithParentAlias
     let res = run_require(&lua, "./tests/luau/require/with_config/src/parent_alias_requirer").unwrap();
     assert_eq!("result from other_dependency", get_str(&res, 1));

tests/luau/require/with_config/src/alias_requirer_uc.luau

@@ -0,0 +1 @@
+return require("@DeP")

tests/multi.rs

@@ -43,12 +43,12 @@ fn test_result_conversions() -> Result<()> {
     let multi_err1 = err1.into_lua_multi(&lua)?;
     assert_eq!(multi_err1.len(), 2);
     assert_eq!(multi_err1[0], Value::Nil);
-    assert_eq!(multi_err1[1].as_str().unwrap(), "failure1");
+    assert_eq!(multi_err1[1].as_string().unwrap(), "failure1");
 
     let ok2 = Ok::<_, Error>("!");
     let multi_ok2 = ok2.into_lua_multi(&lua)?;
     assert_eq!(multi_ok2.len(), 1);
-    assert_eq!(multi_ok2[0].as_str().unwrap(), "!");
+    assert_eq!(multi_ok2[0].as_string().unwrap(), "!");
     let err2 = Err::<String, _>("failure2".into_lua_err());
     let multi_err2 = err2.into_lua_multi(&lua)?;
     assert_eq!(multi_err2.len(), 2);

tests/serde.rs

@@ -25,7 +25,7 @@ fn test_serialize() -> Result<(), Box<dyn StdError>> {
     globals.set("null", lua.null())?;
 
     let empty_array = lua.create_table()?;
-    empty_array.set_metatable(Some(lua.array_metatable()));
+    empty_array.set_metatable(Some(lua.array_metatable()))?;
     globals.set("empty_array", empty_array)?;
 
     let val = lua
@@ -173,7 +173,7 @@ fn test_serialize_sorted() -> LuaResult<()> {
     globals.set("null", lua.null())?;
 
     let empty_array = lua.create_table()?;
-    empty_array.set_metatable(Some(lua.array_metatable()));
+    empty_array.set_metatable(Some(lua.array_metatable()))?;
     globals.set("empty_array", empty_array)?;
 
     let value = lua

tests/table.rs

@@ -298,10 +298,10 @@ fn test_metatable() -> Result<()> {
     let table = lua.create_table()?;
     let metatable = lua.create_table()?;
     metatable.set("__index", lua.create_function(|_, ()| Ok("index_value"))?)?;
-    table.set_metatable(Some(metatable));
+    table.set_metatable(Some(metatable))?;
     assert_eq!(table.get::<String>("any_key")?, "index_value");
     assert_eq!(table.raw_get::<Value>("any_key")?, Value::Nil);
-    table.set_metatable(None);
+    table.set_metatable(None)?;
     assert_eq!(table.get::<Value>("any_key")?, Value::Nil);
 
     Ok(())

tests/tests.rs

@@ -147,6 +147,31 @@ fn test_eval() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_replace_globals() -> Result<()> {
+    let lua = Lua::new();
+
+    let globals = lua.create_table()?;
+    globals.set("foo", "bar")?;
+
+    lua.set_globals(globals.clone())?;
+    let val = lua.load("return foo").eval::<StdString>()?;
+    assert_eq!(val, "bar");
+
+    // Updating globals in sandboxed Lua state is not allowed
+    #[cfg(feature = "luau")]
+    {
+        lua.sandbox(true)?;
+        match lua.set_globals(globals) {
+            Err(Error::RuntimeError(msg))
+                if msg.contains("cannot change globals in a sandboxed Lua state") => {}
+            r => panic!("expected RuntimeError(...) with a specific error message, got {r:?}"),
+        }
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_load_mode() -> Result<()> {
     let lua = unsafe { Lua::unsafe_new() };
@@ -577,6 +602,21 @@ fn test_num_conversion() -> Result<()> {
 
     assert_eq!(lua.unpack::<i128>(lua.pack(1i128 << 64)?)?, 1i128 << 64);
 
+    // Negative zero
+    let negative_zero = lua.load("-0.0").eval::<f64>()?;
+    assert_eq!(negative_zero, 0.0);
+    // LuaJIT treats -0.0 as a positive zero
+    #[cfg(not(feature = "luajit"))]
+    assert!(negative_zero.is_sign_negative());
+
+    // In Lua <5.3 all numbers are floats
+    #[cfg(not(any(feature = "lua54", feature = "lua53", feature = "luajit")))]
+    {
+        let negative_zero = lua.load("-0").eval::<f64>()?;
+        assert_eq!(negative_zero, 0.0);
+        assert!(negative_zero.is_sign_negative());
+    }
+
     Ok(())
 }
 
@@ -1202,6 +1242,17 @@ fn test_register_module() -> Result<()> {
             res.unwrap_err().to_string(),
             "runtime error: module name must begin with '@'"
         );
+
+        // Luau registered modules (aliases) are case-insensitive
+        let res = lua.register_module("@My_Module", &t);
+        assert!(res.is_ok());
+        lua.load(
+            r#"
+            local my_module = require("@MY_MODule")
+            assert(my_module.name == "my_module")
+        "#,
+        )
+        .exec()?;
     }
 
     Ok(())
@@ -1251,14 +1302,18 @@ fn test_inspect_stack() -> Result<()> {
     let lua = Lua::new();
 
     // Not inside any function
-    assert!(lua.inspect_stack(0).is_none());
+    assert!(lua.inspect_stack(0, |_| ()).is_none());
 
     let logline = lua.create_function(|lua, msg: StdString| {
-        let debug = lua.inspect_stack(1).unwrap(); // caller
-        let source = debug.source().short_src;
-        let source = source.as_deref().unwrap_or("?");
-        let line = debug.curr_line();
-        Ok(format!("{}:{} {}", source, line, msg))
+        let r = lua
+            .inspect_stack(1, |debug| {
+                let source = debug.source().short_src;
+                let source = source.as_deref().unwrap_or("?");
+                let line = debug.current_line().unwrap();
+                format!("{}:{} {}", source, line, msg)
+            })
+            .unwrap();
+        Ok(r)
     })?;
     lua.globals().set("logline", logline)?;
 
@@ -1281,8 +1336,7 @@ fn test_inspect_stack() -> Result<()> {
     .exec()?;
 
     let stack_info = lua.create_function(|lua, ()| {
-        let debug = lua.inspect_stack(1).unwrap(); // caller
-        let stack_info = debug.stack();
+        let stack_info = lua.inspect_stack(1, |debug| debug.stack()).unwrap();
         Ok(format!("{stack_info:?}"))
     })?;
     lua.globals().set("stack_info", stack_info)?;
@@ -1312,6 +1366,25 @@ fn test_inspect_stack() -> Result<()> {
     )
     .exec()?;
 
+    // Test retrieving currently running function
+    let running_function =
+        lua.create_function(|lua, ()| Ok(lua.inspect_stack(1, |debug| debug.function())))?;
+    lua.globals().set("running_function", running_function)?;
+    lua.load(
+        r#"
+        local function baz()
+            return running_function()
+        end
+        if jit == nil then
+            assert(baz() == baz)
+        else
+            -- luajit inline the "baz" function and returns the chunk itself
+            assert(baz() == running_function())
+        end
+    "#,
+    )
+    .exec()?;
+
     Ok(())
 }
 

tests/value.rs

@@ -255,16 +255,7 @@ fn test_value_conversions() -> Result<()> {
         Value::String(lua.create_string("hello")?).as_string().unwrap(),
         "hello"
     );
-    assert_eq!(
-        Value::String(lua.create_string("hello")?).as_str().unwrap(),
-        "hello"
-    );
-    assert_eq!(
-        Value::String(lua.create_string("hello")?)
-            .as_string_lossy()
-            .unwrap(),
-        "hello"
-    );
+    assert_eq!(Value::String(lua.create_string("hello")?).to_string()?, "hello");
     assert!(Value::Table(lua.create_table()?).is_table());
     assert!(Value::Table(lua.create_table()?).as_table().is_some());
     assert!(Value::Function(lua.create_function(|_, ()| Ok(())).unwrap()).is_function());