v0.8.3

This should fix #194

CHANGELOG.md

@@ -1,3 +1,35 @@
+## v0.8.3
+
+- Close to-be-closed variables for Lua 5.4 when using call_async functions (#192)
+- Fixed Lua assertion when inspecting another thread stack. (#195)
+- Use more reliable way to create LuaJIT VM (which can fail if use Rust allocator on non-x86 platforms)
+
+## v0.8.2
+
+- Performance optimizations in handling UserData
+- Minimal Luau updated to 0.536
+- Fixed bug in `Function::bind` when passing empty binds and no arguments (#189)
+
+## v0.8.1
+
+- Added `Lua::create_proxy` for accessing to UserData static fields and functions without instance
+- Added `Table::to_pointer()` and `String::to_pointer()` functions
+- Bugfixes and improvements (#176 #179)
+
+## v0.8.0
+Changes since 0.7.4
+- Roblox Luau support
+- Removed C glue
+- Added async support to `__index` and `__newindex` metamethods
+- Added `Function::info()` to get information about functions (#149).
+- Added `parking_lot` dependency under feature flag (for `UserData`)
+- `Hash` implementation for Lua String
+- Added `Value::to_pointer()` function
+- Performance improvements
+
+Breaking changes:
+- Refactored `AsChunk` trait (added implementation for `Path` and `PathBuf`).
+
 ## v0.8.0-beta.5
 
 - Lua sources no longer needed to build modules

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "mlua"
-version = "0.8.0-beta.5" # remember to update html_root_url and mlua_derive
+version = "0.8.3" # remember to update html_root_url and mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
-edition = "2018"
+edition = "2021"
 repository = "https://github.com/khvzak/mlua"
 documentation = "https://docs.rs/mlua"
 readme = "README.md"
-keywords = ["lua", "luajit", "async", "futures", "scripting"]
+keywords = ["lua", "luajit", "luau", "async", "scripting"]
 categories = ["api-bindings", "asynchronous"]
 license = "MIT"
 links = "lua"
@@ -41,7 +41,7 @@ serialize = ["serde", "erased-serde"]
 macros = ["mlua_derive/macros"]
 
 [dependencies]
-mlua_derive = { version = "=0.8.0-beta.1", optional = true, path = "mlua_derive" }
+mlua_derive = { version = "=0.8.0", optional = true, path = "mlua_derive" }
 bstr = { version = "0.2", features = ["std"], default_features = false }
 once_cell = { version = "1.0" }
 num-traits = { version = "0.2.14" }
@@ -57,11 +57,11 @@ parking_lot = { version = "0.12", optional = true }
 cc = { version = "1.0" }
 pkg-config = { version = "0.3.17" }
 lua-src = { version = ">= 544.0.0, < 550.0.0", optional = true }
-luajit-src = { version = ">= 210.3.1, < 220.0.0", optional = true }
-luau0-src = { version = "0.3", optional = true }
+luajit-src = { version = ">= 210.4.0, < 220.0.0", optional = true }
+luau0-src = { version = "0.3.6", optional = true }
 
 [dev-dependencies]
-rustyline = "9.0"
+rustyline = "10.0"
 criterion = { version = "0.3.4", features = ["html_reports", "async_tokio"] }
 trybuild = "1.0"
 futures = "0.3.5"

FAQ.md

@@ -0,0 +1,21 @@
+# mlua FAQ
+
+This file is for general questions that don't fit into the README or crate docs.
+
+## Loading a C module fails with error `undefined symbol: lua_xxx`. How to fix?
+
+Add the following rustflags to your [.cargo/config](http://doc.crates.io/config.html) in order to properly export Lua symbols:
+
+```toml
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-args=-rdynamic"]
+
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-args=-rdynamic"]
+```
+
+## I want to add support for a Lua VM fork to mlua. Do you accept pull requests?
+
+Adding new feature flag to support a Lua VM fork is a major step that requires huge effort to maintain it.
+Regular updates, testing, checking compatibility, etc.
+That's why I don't plan to support new Lua VM forks or other languages in mlua.

README.md

@@ -9,9 +9,13 @@
 [docs.rs]: https://docs.rs/mlua
 [Coverage Status]: https://codecov.io/gh/khvzak/mlua/branch/master/graph/badge.svg?token=99339FS1CG
 [codecov.io]: https://codecov.io/gh/khvzak/mlua
-[MSRV]: https://img.shields.io/badge/rust-1.53+-brightgreen.svg?&logo=rust
+[MSRV]: https://img.shields.io/badge/rust-1.56+-brightgreen.svg?&logo=rust
 
-[Guided Tour](examples/guided_tour.rs)
+[Guided Tour] | [Benchmarks] | [FAQ]
+
+[Guided Tour]: examples/guided_tour.rs
+[Benchmarks]: https://github.com/khvzak/script-bench-rs
+[FAQ]: FAQ.md
 
 `mlua` is bindings to [Lua](https://www.lua.org) programming language for Rust with a goal to provide
 _safe_ (as far as it's possible), high level, easy to use, practical and flexible API.
@@ -106,7 +110,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.8.0-beta.5", features = ["lua54", "vendored"] }
+mlua = { version = "0.8", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -141,7 +145,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.8.0-beta.5", features = ["lua54", "vendored", "module"] }
+mlua = { version = "0.8", features = ["lua54", "vendored", "module"] }
 ```
 
 `lib.rs` :
@@ -256,6 +260,14 @@ If you encounter them, a bug report would be very welcome:
 
   + If you detect that, after catching a panic or during a Drop triggered from a panic, a `Lua` or handle method is triggering other bugs or there is a Lua stack space leak, this is a bug. `mlua` instances are supposed to remain fully usable in the face of user generated panics. This guarantee does not extend to panics marked with "mlua internal error" simply because that is already indicative of a separate bug.
 
+## Sandboxing
+
+Please check the [Luau Sandboxing] page if you are interested in running untrusted Lua scripts in controlled environment.
+
+`mlua` provides `Lua::sandbox` method for enabling sandbox mode (Luau only).
+
+[Luau Sandboxing]: https://luau-lang.org/sandbox
+
 ## License
 
 This project is licensed under the [MIT license](LICENSE)

examples/repl.rs

@@ -5,7 +5,7 @@ use rustyline::Editor;
 
 fn main() {
     let lua = Lua::new();
-    let mut editor = Editor::<()>::new();
+    let mut editor = Editor::<()>::new().expect("Failed to make rustyline editor");
 
     loop {
         let mut prompt = "> ";

mlua_derive/Cargo.toml

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

src/chunk.rs

@@ -484,7 +484,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
                     return ChunkMode::Binary;
                 }
                 #[cfg(feature = "luau")]
-                if *source.get(0).unwrap_or(&u8::MAX) < b'\n' {
+                if *source.first().unwrap_or(&u8::MAX) < b'\n' {
                     return ChunkMode::Binary;
                 }
                 ChunkMode::Text

src/conversion.rs

@@ -250,18 +250,21 @@ impl<'lua> ToLua<'lua> for &str {
 }
 
 impl<'lua> ToLua<'lua> for Cow<'_, str> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.as_bytes())?))
     }
 }
 
 impl<'lua> ToLua<'lua> for Box<str> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&*self)?))
     }
 }
 
 impl<'lua> FromLua<'lua> for Box<str> {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         let ty = value.type_name();
         Ok(lua
@@ -278,12 +281,14 @@ impl<'lua> FromLua<'lua> for Box<str> {
 }
 
 impl<'lua> ToLua<'lua> for CString {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.as_bytes())?))
     }
 }
 
 impl<'lua> FromLua<'lua> for CString {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         let ty = value.type_name();
         let string = lua
@@ -306,24 +311,28 @@ impl<'lua> FromLua<'lua> for CString {
 }
 
 impl<'lua> ToLua<'lua> for &CStr {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.to_bytes())?))
     }
 }
 
 impl<'lua> ToLua<'lua> for Cow<'_, CStr> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.to_bytes())?))
     }
 }
 
 impl<'lua> ToLua<'lua> for BString {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&self)?))
     }
 }
 
 impl<'lua> FromLua<'lua> for BString {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         let ty = value.type_name();
         Ok(BString::from(
@@ -340,14 +349,16 @@ impl<'lua> FromLua<'lua> for BString {
 }
 
 impl<'lua> ToLua<'lua> for &BStr {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::String(lua.create_string(&self)?))
+        Ok(Value::String(lua.create_string(self)?))
     }
 }
 
 macro_rules! lua_convert_int {
     ($x:ty) => {
         impl<'lua> ToLua<'lua> for $x {
+            #[inline]
             fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
                 cast(self)
                     .map(Value::Integer)
@@ -362,22 +373,27 @@ macro_rules! lua_convert_int {
         }
 
         impl<'lua> FromLua<'lua> for $x {
+            #[inline]
             fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
                 let ty = value.type_name();
-                (if let Value::Integer(i) = value {
-                    cast(i)
-                } else if let Some(i) = lua.coerce_integer(value.clone())? {
-                    cast(i)
-                } else {
-                    cast(lua.coerce_number(value)?.ok_or_else(|| {
-                        Error::FromLuaConversionError {
-                            from: ty,
-                            to: stringify!($x),
-                            message: Some(
-                                "expected number or string coercible to number".to_string(),
-                            ),
+                (match value {
+                    Value::Integer(i) => cast(i),
+                    Value::Number(n) => cast(n),
+                    _ => {
+                        if let Some(i) = lua.coerce_integer(value.clone())? {
+                            cast(i)
+                        } else {
+                            cast(lua.coerce_number(value)?.ok_or_else(|| {
+                                Error::FromLuaConversionError {
+                                    from: ty,
+                                    to: stringify!($x),
+                                    message: Some(
+                                        "expected number or string coercible to number".to_string(),
+                                    ),
+                                }
+                            })?)
                         }
-                    })?)
+                    }
                 })
                 .ok_or_else(|| Error::FromLuaConversionError {
                     from: ty,
@@ -405,6 +421,7 @@ lua_convert_int!(usize);
 macro_rules! lua_convert_float {
     ($x:ty) => {
         impl<'lua> ToLua<'lua> for $x {
+            #[inline]
             fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
                 cast(self)
                     .ok_or_else(|| Error::ToLuaConversionError {
@@ -417,6 +434,7 @@ macro_rules! lua_convert_float {
         }
 
         impl<'lua> FromLua<'lua> for $x {
+            #[inline]
             fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
                 let ty = value.type_name();
                 lua.coerce_number(value)?
@@ -444,6 +462,7 @@ impl<'lua, T> ToLua<'lua> for &[T]
 where
     T: Clone + ToLua<'lua>,
 {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(
             lua.create_sequence_from(self.iter().cloned())?,
@@ -455,6 +474,7 @@ impl<'lua, T, const N: usize> ToLua<'lua> for [T; N]
 where
     T: ToLua<'lua>,
 {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self)?))
     }
@@ -464,6 +484,7 @@ impl<'lua, T, const N: usize> FromLua<'lua> for [T; N]
 where
     T: FromLua<'lua>,
 {
+    #[inline]
     fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
         match value {
             #[cfg(feature = "luau")]
@@ -496,24 +517,28 @@ where
 }
 
 impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self.into_vec())?))
     }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Box<[T]> {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         Ok(Vec::<T>::from_lua(value, lua)?.into_boxed_slice())
     }
 }
 
 impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Vec<T> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self)?))
     }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
         match value {
             #[cfg(feature = "luau")]
@@ -535,6 +560,7 @@ impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
 impl<'lua, K: Eq + Hash + ToLua<'lua>, V: ToLua<'lua>, S: BuildHasher> ToLua<'lua>
     for HashMap<K, V, S>
 {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(self)?))
     }
@@ -543,6 +569,7 @@ impl<'lua, K: Eq + Hash + ToLua<'lua>, V: ToLua<'lua>, S: BuildHasher> ToLua<'lu
 impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
     for HashMap<K, V, S>
 {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         if let Value::Table(table) = value {
             table.pairs().collect()
@@ -557,12 +584,14 @@ impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>, S: BuildHasher + Defa
 }
 
 impl<'lua, K: Ord + ToLua<'lua>, V: ToLua<'lua>> ToLua<'lua> for BTreeMap<K, V> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(self)?))
     }
 }
 
 impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<K, V> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         if let Value::Table(table) = value {
             table.pairs().collect()
@@ -577,6 +606,7 @@ impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<
 }
 
 impl<'lua, T: Eq + Hash + ToLua<'lua>, S: BuildHasher> ToLua<'lua> for HashSet<T, S> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(
             self.into_iter().map(|val| (val, true)),
@@ -585,6 +615,7 @@ impl<'lua, T: Eq + Hash + ToLua<'lua>, S: BuildHasher> ToLua<'lua> for HashSet<T
 }
 
 impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua> for HashSet<T, S> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         match value {
             Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
@@ -602,6 +633,7 @@ impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
 }
 
 impl<'lua, T: Ord + ToLua<'lua>> ToLua<'lua> for BTreeSet<T> {
+    #[inline]
     fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(
             self.into_iter().map(|val| (val, true)),
@@ -610,6 +642,7 @@ impl<'lua, T: Ord + ToLua<'lua>> ToLua<'lua> for BTreeSet<T> {
 }
 
 impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         match value {
             Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),

src/ffi/lua51/compat.rs

@@ -568,11 +568,10 @@ pub unsafe fn luaL_requiref(
             lua_getfield(L, -1, modname);
         }
     }
-    if cfg!(feature = "lua51") && glb != 0 {
+    if glb != 0 {
         lua_pushvalue(L, -1);
         lua_setglobal(L, modname);
-    }
-    if cfg!(feature = "luajit") && glb == 0 {
+    } else {
         lua_pushnil(L);
         lua_setglobal(L, modname);
     }

src/ffi/lua51/lua.rs

@@ -67,7 +67,10 @@ pub const LUA_MINSTACK: c_int = 20;
 pub type lua_Number = c_double;
 
 /// A Lua integer, usually equivalent to `i64`
-pub type lua_Integer = isize;
+#[cfg(target_pointer_width = "32")]
+pub type lua_Integer = i32;
+#[cfg(target_pointer_width = "64")]
+pub type lua_Integer = i64;
 
 /// Type for native C functions that can be passed to Lua.
 pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
@@ -321,6 +324,12 @@ pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
 }
 
+#[inline(always)]
+pub unsafe fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int) {
+    lua_pushvalue(from, idx);
+    lua_xmove(from, to, 1);
+}
+
 //
 // Debug API
 //

src/ffi/lua52/lua.rs

@@ -69,7 +69,10 @@ pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
 pub type lua_Number = c_double;
 
 /// A Lua integer, usually equivalent to `i64`
-pub type lua_Integer = isize;
+#[cfg(target_pointer_width = "32")]
+pub type lua_Integer = i32;
+#[cfg(target_pointer_width = "64")]
+pub type lua_Integer = i64;
 
 /// A Lua unsigned integer, equivalent to `u32` in Lua 5.2
 pub type lua_Unsigned = c_uint;
@@ -407,6 +410,12 @@ pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
 }
 
+#[inline(always)]
+pub unsafe fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int) {
+    lua_pushvalue(from, idx);
+    lua_xmove(from, to, 1);
+}
+
 //
 // Debug API
 //

src/ffi/lua53/lua.rs

@@ -434,6 +434,12 @@ pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
     lua_pop(L, 1)
 }
 
+#[inline(always)]
+pub unsafe fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int) {
+    lua_pushvalue(from, idx);
+    lua_xmove(from, to, 1);
+}
+
 //
 // Debug API
 //

src/ffi/lua54/lua.rs

@@ -455,6 +455,12 @@ pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
     lua_pop(L, 1)
 }
 
+#[inline(always)]
+pub unsafe fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int) {
+    lua_pushvalue(from, idx);
+    lua_xmove(from, to, 1);
+}
+
 #[inline(always)]
 pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
     lua_newuserdatauv(L, sz, 1)

src/ffi/luau/compat.rs

@@ -513,6 +513,9 @@ pub unsafe fn luaL_requiref(
     if glb != 0 {
         lua_pushvalue(L, -1);
         lua_setglobal(L, modname);
+    } else {
+        lua_pushnil(L);
+        lua_setglobal(L, modname);
     }
     lua_replace(L, -2);
 }

src/ffi/luau/lua.rs

@@ -133,6 +133,7 @@ extern "C" {
     pub fn lua_namecallatom(L: *mut lua_State, atom: *mut c_int) -> *const c_char;
     pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
     pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_touserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
     pub fn lua_userdatatag(L: *mut lua_State, idx: c_int) -> c_int;
@@ -259,6 +260,7 @@ extern "C" {
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     // TODO: lua_encodepointer
     pub fn lua_clock() -> c_double;
+    pub fn lua_setuserdatatag(L: *mut lua_State, idx: c_int, tag: c_int);
     pub fn lua_setuserdatadtor(
         L: *mut lua_State,
         tag: c_int,
@@ -436,7 +438,12 @@ extern "C" {
     pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
 
     pub fn lua_singlestep(L: *mut lua_State, enabled: c_int);
-    pub fn lua_breakpoint(L: *mut lua_State, funcindex: c_int, line: c_int, enabled: c_int);
+    pub fn lua_breakpoint(
+        L: *mut lua_State,
+        funcindex: c_int,
+        line: c_int,
+        enabled: c_int,
+    ) -> c_int;
 
     pub fn lua_getcoverage(
         L: *mut lua_State,

src/function.rs

@@ -198,7 +198,9 @@ impl<'lua> Function<'lua> {
             for i in 0..nbinds {
                 ffi::lua_pushvalue(state, ffi::lua_upvalueindex(i + 2));
             }
-            ffi::lua_rotate(state, 1, nbinds);
+            if nargs > 0 {
+                ffi::lua_rotate(state, 1, nbinds);
+            }
 
             nargs + nbinds
         }
@@ -208,6 +210,10 @@ impl<'lua> Function<'lua> {
         let args = args.to_lua_multi(lua)?;
         let nargs = args.len() as c_int;
 
+        if nargs == 0 {
+            return Ok(self.clone());
+        }
+
         if nargs + 1 > ffi::LUA_MAX_UPVALUES {
             return Err(Error::BindError);
         }

src/lib.rs

@@ -72,7 +72,7 @@
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
 // mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.8.0-beta.5")]
+#![doc(html_root_url = "https://docs.rs/mlua/0.8.3")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]

src/lua.rs

@@ -8,6 +8,7 @@ use std::mem::ManuallyDrop;
 use std::ops::{Deref, DerefMut};
 use std::os::raw::{c_char, c_int, c_void};
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe, Location};
+use std::ptr::NonNull;
 use std::sync::{Arc, Mutex};
 use std::{mem, ptr, str};
 
@@ -24,11 +25,11 @@ use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
 use crate::types::{
-    Callback, CallbackUpvalue, DestructedUserdataMT, Integer, LightUserData, LuaRef, MaybeSend,
+    Callback, CallbackUpvalue, DestructedUserdata, Integer, LightUserData, LuaRef, MaybeSend,
     Number, RegistryKey,
 };
 use crate::userdata::{AnyUserData, UserData, UserDataCell};
-use crate::userdata_impl::{StaticUserDataFields, StaticUserDataMethods};
+use crate::userdata_impl::{StaticUserDataFields, StaticUserDataMethods, UserDataProxy};
 use crate::util::{
     self, assert_stack, callback_error, check_stack, get_destructed_userdata_metatable,
     get_gc_metatable, get_gc_userdata, get_main_state, get_userdata, init_error_registry,
@@ -95,7 +96,7 @@ pub(crate) struct ExtraData {
     app_data: RefCell<HashMap<TypeId, Box<dyn Any + Send>>>,
 
     libs: StdLib,
-    mem_info: Option<ptr::NonNull<MemoryInfo>>,
+    mem_info: Option<NonNull<MemoryInfo>>,
 
     ref_thread: *mut ffi::lua_State,
     ref_stack_size: c_int,
@@ -110,6 +111,9 @@ pub(crate) struct ExtraData {
     #[cfg(feature = "async")]
     recycled_thread_cache: Vec<c_int>,
 
+    // Address of `WrappedFailure` metatable
+    wrapped_failure_mt_ptr: *const c_void,
+
     // Index of `Option<Waker>` userdata on the ref thread
     #[cfg(feature = "async")]
     ref_waker_idx: c_int,
@@ -125,7 +129,7 @@ pub(crate) struct ExtraData {
     sandboxed: bool,
 }
 
-#[cfg_attr(any(feature = "lua51", feature = "luajit"), allow(dead_code))]
+#[derive(Default)]
 struct MemoryInfo {
     used_memory: isize,
     memory_limit: isize,
@@ -378,25 +382,20 @@ impl Lua {
     }
 
     unsafe fn inner_new(libs: StdLib, options: LuaOptions) -> Lua {
-        #[cfg_attr(
-            any(feature = "lua51", feature = "luajit", feature = "luau"),
-            allow(dead_code)
-        )]
         unsafe extern "C" fn allocator(
             extra_data: *mut c_void,
             ptr: *mut c_void,
             osize: usize,
             nsize: usize,
         ) -> *mut c_void {
-            use std::alloc;
+            use std::alloc::{self, Layout};
 
             let mem_info = &mut *(extra_data as *mut MemoryInfo);
 
             if nsize == 0 {
                 // Free memory
                 if !ptr.is_null() {
-                    let layout =
-                        alloc::Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
+                    let layout = Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
                     alloc::dealloc(ptr as *mut u8, layout);
                     mem_info.used_memory -= osize as isize;
                 }
@@ -413,52 +412,51 @@ impl Lua {
                 return ptr::null_mut();
             }
 
-            let new_layout = alloc::Layout::from_size_align_unchecked(nsize, ffi::SYS_MIN_ALIGN);
+            let new_layout = Layout::from_size_align_unchecked(nsize, ffi::SYS_MIN_ALIGN);
+            mem_info.used_memory += mem_diff;
 
             if ptr.is_null() {
                 // Allocate new memory
                 let new_ptr = alloc::alloc(new_layout) as *mut c_void;
-                if !new_ptr.is_null() {
-                    mem_info.used_memory += mem_diff;
+                if new_ptr.is_null() {
+                    alloc::handle_alloc_error(new_layout);
                 }
                 return new_ptr;
             }
 
             // Reallocate memory
-            let old_layout = alloc::Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
+            let old_layout = Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
             let new_ptr = alloc::realloc(ptr as *mut u8, old_layout, nsize) as *mut c_void;
-
-            if !new_ptr.is_null() {
-                mem_info.used_memory += mem_diff;
-            } else if !ptr.is_null() && nsize < osize {
-                // Should not happen
+            if new_ptr.is_null() {
                 alloc::handle_alloc_error(new_layout);
             }
-
             new_ptr
         }
 
-        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-        let mem_info = Box::into_raw(Box::new(MemoryInfo {
-            used_memory: 0,
-            memory_limit: 0,
-        }));
+        // Skip Rust allocator for non-vendored LuaJIT (see https://github.com/khvzak/mlua/issues/176)
+        let use_rust_allocator = !(cfg!(feature = "luajit") && cfg!(not(feature = "vendored")));
 
-        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-        let state = ffi::lua_newstate(allocator, mem_info as *mut c_void);
-        #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
-        let state = ffi::luaL_newstate();
+        let (state, mem_info) = if use_rust_allocator {
+            let mut mem_info = Box::into_raw(Box::new(MemoryInfo::default()));
+            let mut state = ffi::lua_newstate(allocator, mem_info as *mut c_void);
+            // If state is null (it's possible for LuaJIT on non-x86 arch) then switch to Lua internal allocator
+            if state.is_null() {
+                drop(Box::from_raw(mem_info));
+                mem_info = ptr::null_mut();
+                state = ffi::luaL_newstate();
+            }
+            (state, mem_info)
+        } else {
+            (ffi::luaL_newstate(), ptr::null_mut())
+        };
+        assert!(!state.is_null(), "Failed to instantiate Lua VM");
 
         ffi::luaL_requiref(state, cstr!("_G"), ffi::luaopen_base, 1);
         ffi::lua_pop(state, 1);
 
         let lua = Lua::init_from_ptr(state);
         let extra = &mut *lua.extra.get();
-
-        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-        {
-            extra.mem_info = ptr::NonNull::new(mem_info);
-        }
+        extra.mem_info = NonNull::new(mem_info);
 
         mlua_expect!(
             load_from_std_lib(state, libs),
@@ -505,6 +503,7 @@ impl Lua {
     /// by calling this function again.
     #[allow(clippy::missing_safety_doc)]
     pub unsafe fn init_from_ptr(state: *mut ffi::lua_State) -> Lua {
+        assert!(!state.is_null(), "Lua state is NULL");
         let main_state = get_main_state(state).unwrap_or(state);
         let main_state_top = ffi::lua_gettop(main_state);
 
@@ -550,11 +549,18 @@ impl Lua {
             "Error while creating ref thread",
         );
 
+        let wrapped_failure_mt_ptr = {
+            get_gc_metatable::<WrappedFailure>(state);
+            let ptr = ffi::lua_topointer(state, -1);
+            ffi::lua_pop(state, 1);
+            ptr
+        };
+
         // Create empty Waker slot on the ref thread
         #[cfg(feature = "async")]
         let ref_waker_idx = {
             mlua_expect!(
-                push_gc_userdata::<Option<Waker>>(ref_thread, None),
+                push_gc_userdata::<Option<Waker>>(ref_thread, None, true),
                 "Error while creating Waker slot"
             );
             ffi::lua_gettop(ref_thread)
@@ -580,6 +586,7 @@ impl Lua {
             multivalue_cache: Vec::with_capacity(MULTIVALUE_CACHE_SIZE),
             #[cfg(feature = "async")]
             recycled_thread_cache: Vec::new(),
+            wrapped_failure_mt_ptr,
             #[cfg(feature = "async")]
             ref_waker_idx,
             #[cfg(not(feature = "luau"))]
@@ -594,7 +601,7 @@ impl Lua {
 
         mlua_expect!(
             (|state| {
-                push_gc_userdata(state, Arc::clone(&extra))?;
+                push_gc_userdata(state, Arc::clone(&extra), true)?;
                 protect_lua!(state, 1, 0, fn(state) {
                     let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
                     ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, extra_key);
@@ -603,13 +610,13 @@ impl Lua {
             "Error while storing extra data",
         );
 
-        // Register `DestructedUserdataMT` type
+        // Register `DestructedUserdata` type
         get_destructed_userdata_metatable(main_state);
         let destructed_mt_ptr = ffi::lua_topointer(main_state, -1);
-        let destructed_mt_typeid = Some(TypeId::of::<DestructedUserdataMT>());
+        let destructed_ud_typeid = TypeId::of::<DestructedUserdata>();
         (*extra.get())
             .registered_userdata_mt
-            .insert(destructed_mt_ptr, destructed_mt_typeid);
+            .insert(destructed_mt_ptr, Some(destructed_ud_typeid));
         ffi::lua_pop(main_state, 1);
 
         mlua_debug_assert!(
@@ -1423,19 +1430,16 @@ impl Lua {
         unsafe {
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 3)?;
-            push_string(self.state, s)?;
+
+            let protect = !self.unlikely_memory_error();
+            push_string(self.state, s, protect)?;
             Ok(String(self.pop_ref()))
         }
     }
 
     /// Creates and returns a new empty table.
     pub fn create_table(&self) -> Result<Table> {
-        unsafe {
-            let _sg = StackGuard::new(self.state);
-            check_stack(self.state, 2)?;
-            protect_lua!(self.state, 0, 1, fn(state) ffi::lua_newtable(state))?;
-            Ok(Table(self.pop_ref()))
-        }
+        self.create_table_with_capacity(0, 0)
     }
 
     /// Creates and returns a new empty table, with the specified capacity.
@@ -1446,7 +1450,9 @@ impl Lua {
         unsafe {
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 3)?;
-            push_table(self.state, narr, nrec)?;
+
+            let protect = !self.unlikely_memory_error();
+            push_table(self.state, narr, nrec, protect)?;
             Ok(Table(self.pop_ref()))
         }
     }
@@ -1464,11 +1470,16 @@ impl Lua {
 
             let iter = iter.into_iter();
             let lower_bound = iter.size_hint().0;
-            push_table(self.state, 0, lower_bound as c_int)?;
+            let protect = !self.unlikely_memory_error();
+            push_table(self.state, 0, lower_bound as c_int, protect)?;
             for (k, v) in iter {
                 self.push_value(k.to_lua(self)?)?;
                 self.push_value(v.to_lua(self)?)?;
-                protect_lua!(self.state, 3, 1, fn(state) ffi::lua_rawset(state, -3))?;
+                if protect {
+                    protect_lua!(self.state, 3, 1, fn(state) ffi::lua_rawset(state, -3))?;
+                } else {
+                    ffi::lua_rawset(self.state, -3);
+                }
             }
 
             Ok(Table(self.pop_ref()))
@@ -1487,12 +1498,17 @@ impl Lua {
 
             let iter = iter.into_iter();
             let lower_bound = iter.size_hint().0;
-            push_table(self.state, lower_bound as c_int, 0)?;
+            let protect = !self.unlikely_memory_error();
+            push_table(self.state, lower_bound as c_int, 0, protect)?;
             for (i, v) in iter.enumerate() {
                 self.push_value(v.to_lua(self)?)?;
-                protect_lua!(self.state, 2, 1, |state| {
-                    ffi::lua_rawseti(state, -2, (i + 1) as Integer);
-                })?;
+                if protect {
+                    protect_lua!(self.state, 2, 1, |state| {
+                        ffi::lua_rawseti(state, -2, (i + 1) as Integer);
+                    })?;
+                } else {
+                    ffi::lua_rawseti(self.state, -2, (i + 1) as Integer);
+                }
             }
 
             Ok(Table(self.pop_ref()))
@@ -1651,7 +1667,11 @@ impl Lua {
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 3)?;
 
-            let thread_state = protect_lua!(self.state, 0, 1, |state| ffi::lua_newthread(state))?;
+            let thread_state = if self.unlikely_memory_error() {
+                ffi::lua_newthread(self.state)
+            } else {
+                protect_lua!(self.state, 0, 1, |state| ffi::lua_newthread(state))?
+            };
             self.push_ref(&func.0);
             ffi::lua_xmove(self.state, thread_state, 1);
 
@@ -1700,15 +1720,16 @@ impl Lua {
         all(feature = "luajit", feature = "vendored"),
         feature = "luau",
     ))]
-    pub(crate) unsafe fn recycle_thread(&self, thread: &mut Thread) {
+    pub(crate) unsafe fn recycle_thread(&self, thread: &mut Thread) -> bool {
         let extra = &mut *self.extra.get();
-        let thread_state = ffi::lua_tothread(extra.ref_thread, thread.0.index);
         if extra.recycled_thread_cache.len() < extra.recycled_thread_cache.capacity() {
+            let thread_state = ffi::lua_tothread(extra.ref_thread, thread.0.index);
             #[cfg(feature = "lua54")]
             let status = ffi::lua_resetthread(thread_state);
             #[cfg(feature = "lua54")]
             if status != ffi::LUA_OK {
-                return;
+                // Error object is on top, drop it
+                ffi::lua_settop(thread_state, 0);
             }
             #[cfg(all(feature = "luajit", feature = "vendored"))]
             ffi::lua_resetthread(self.state, thread_state);
@@ -1716,10 +1737,15 @@ impl Lua {
             ffi::lua_resetthread(thread_state);
             extra.recycled_thread_cache.push(thread.0.index);
             thread.0.index = 0;
+            return true;
         }
+        false
     }
 
     /// Create a Lua userdata object from a custom userdata type.
+    ///
+    /// All userdata instances of type `T` shares the same metatable.
+    #[inline]
     pub fn create_userdata<T>(&self, data: T) -> Result<AnyUserData>
     where
         T: 'static + MaybeSend + UserData,
@@ -1732,6 +1758,7 @@ impl Lua {
     /// Requires `feature = "serialize"`
     #[cfg(feature = "serialize")]
     #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+    #[inline]
     pub fn create_ser_userdata<T>(&self, data: T) -> Result<AnyUserData>
     where
         T: 'static + MaybeSend + UserData + Serialize,
@@ -1739,6 +1766,46 @@ impl Lua {
         unsafe { self.make_userdata(UserDataCell::new_ser(data)) }
     }
 
+    /// Create a Lua userdata "proxy" object from a custom userdata type.
+    ///
+    /// Proxy object is an empty userdata object that has `T` metatable attached.
+    /// The main purpose of this object is to provide access to static fields and functions
+    /// without creating an instance of type `T`.
+    ///
+    /// You can get or set uservalues on this object but you cannot borrow any Rust type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result, UserData, UserDataFields, UserDataMethods};
+    /// # fn main() -> Result<()> {
+    /// # let lua = Lua::new();
+    /// struct MyUserData(i32);
+    ///
+    /// impl UserData for MyUserData {
+    ///     fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+    ///         fields.add_field_method_get("val", |_, this| Ok(this.0));
+    ///     }
+    ///
+    ///     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+    ///         methods.add_function("new", |_, value: i32| Ok(MyUserData(value)));
+    ///     }
+    /// }
+    ///
+    /// lua.globals().set("MyUserData", lua.create_proxy::<MyUserData>()?)?;
+    ///
+    /// lua.load("assert(MyUserData.new(321).val == 321)").exec()?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn create_proxy<T>(&self) -> Result<AnyUserData>
+    where
+        T: 'static + UserData,
+    {
+        unsafe { self.make_userdata(UserDataCell::new(UserDataProxy::<T>(PhantomData))) }
+    }
+
     /// Returns a handle to the global environment.
     pub fn globals(&self) -> Table {
         unsafe {
@@ -1826,9 +1893,13 @@ impl Lua {
                 check_stack(self.state, 4)?;
 
                 self.push_value(v)?;
-                let res = protect_lua!(self.state, 1, 1, |state| {
-                    ffi::lua_tolstring(state, -1, ptr::null_mut())
-                })?;
+                let res = if self.unlikely_memory_error() {
+                    ffi::lua_tolstring(self.state, -1, ptr::null_mut())
+                } else {
+                    protect_lua!(self.state, 1, 1, |state| {
+                        ffi::lua_tolstring(state, -1, ptr::null_mut())
+                    })?
+                };
                 if !res.is_null() {
                     Some(String(self.pop_ref()))
                 } else {
@@ -1944,7 +2015,8 @@ impl Lua {
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 3)?;
 
-            push_string(self.state, name)?;
+            let protect = !self.unlikely_memory_error();
+            push_string(self.state, name, protect)?;
             ffi::lua_rawget(self.state, ffi::LUA_REGISTRYINDEX);
 
             self.pop_value()
@@ -2137,6 +2209,7 @@ impl Lua {
     ///     Ok(())
     /// }
     /// ```
+    #[track_caller]
     pub fn set_app_data<T: 'static + MaybeSend>(&self, data: T) {
         let extra = unsafe { &mut (*self.extra.get()) };
         extra
@@ -2147,6 +2220,7 @@ impl Lua {
     }
 
     /// Gets a reference to an application data object stored by [`Lua::set_app_data()`] of type `T`.
+    #[track_caller]
     pub fn app_data_ref<T: 'static>(&self) -> Option<Ref<T>> {
         let extra = unsafe { &(*self.extra.get()) };
         let app_data = extra
@@ -2158,6 +2232,7 @@ impl Lua {
     }
 
     /// Gets a mutable reference to an application data object stored by [`Lua::set_app_data()`] of type `T`.
+    #[track_caller]
     pub fn app_data_mut<T: 'static>(&self) -> Option<RefMut<T>> {
         let extra = unsafe { &(*self.extra.get()) };
         let mut app_data = extra
@@ -2169,6 +2244,7 @@ impl Lua {
     }
 
     /// Removes an application data of type `T`.
+    #[track_caller]
     pub fn remove_app_data<T: 'static>(&self) -> Option<T> {
         let extra = unsafe { &mut (*self.extra.get()) };
         extra
@@ -2228,7 +2304,8 @@ impl Lua {
             }
 
             Value::Error(err) => {
-                push_gc_userdata(self.state, WrappedFailure::Error(err))?;
+                let protect = !self.unlikely_memory_error();
+                push_gc_userdata(self.state, WrappedFailure::Error(err), protect)?;
             }
         }
 
@@ -2238,6 +2315,8 @@ impl Lua {
     // Uses 2 stack spaces, does not call checkstack
     pub(crate) unsafe fn pop_value(&self) -> Value {
         let state = self.state;
+        let extra = &mut *self.extra.get();
+
         match ffi::lua_type(state, -1) {
             ffi::LUA_TNIL => {
                 ffi::lua_pop(state, 1);
@@ -2256,15 +2335,29 @@ impl Lua {
                 ud
             }
 
+            #[cfg(any(feature = "lua54", feature = "lua53"))]
             ffi::LUA_TNUMBER => {
-                if ffi::lua_isinteger(state, -1) != 0 {
-                    let i = Value::Integer(ffi::lua_tointeger(state, -1));
-                    ffi::lua_pop(state, 1);
-                    i
+                let v = if ffi::lua_isinteger(state, -1) != 0 {
+                    Value::Integer(ffi::lua_tointeger(state, -1))
                 } else {
-                    let n = Value::Number(ffi::lua_tonumber(state, -1));
-                    ffi::lua_pop(state, 1);
-                    n
+                    Value::Number(ffi::lua_tonumber(state, -1))
+                };
+                ffi::lua_pop(state, 1);
+                v
+            }
+
+            #[cfg(any(
+                feature = "lua52",
+                feature = "lua51",
+                feature = "luajit",
+                feature = "luau"
+            ))]
+            ffi::LUA_TNUMBER => {
+                let n = ffi::lua_tonumber(state, -1);
+                ffi::lua_pop(state, 1);
+                match num_traits::cast(n) {
+                    Some(i) if (n - (i as Number)).abs() < Number::EPSILON => Value::Integer(i),
+                    _ => Value::Number(n),
                 }
             }
 
@@ -2284,9 +2377,11 @@ impl Lua {
             ffi::LUA_TFUNCTION => Value::Function(Function(self.pop_ref())),
 
             ffi::LUA_TUSERDATA => {
+                let wrapped_failure_mt_ptr = extra.wrapped_failure_mt_ptr;
                 // We must prevent interaction with userdata types other than UserData OR a WrappedError.
                 // WrappedPanics are automatically resumed.
-                match get_gc_userdata::<WrappedFailure>(state, -1).as_mut() {
+                match get_gc_userdata::<WrappedFailure>(state, -1, wrapped_failure_mt_ptr).as_mut()
+                {
                     Some(WrappedFailure::Error(err)) => {
                         let err = err.clone();
                         ffi::lua_pop(state, 1);
@@ -2325,12 +2420,6 @@ impl Lua {
             "Lua instance passed Value created from a different main Lua state"
         );
         let extra = &*self.extra.get();
-        #[cfg(not(feature = "luau"))]
-        {
-            ffi::lua_pushvalue(extra.ref_thread, lref.index);
-            ffi::lua_xmove(extra.ref_thread, self.state, 1);
-        }
-        #[cfg(feature = "luau")]
         ffi::lua_xpush(extra.ref_thread, self.state, lref.index);
     }
 
@@ -2399,7 +2488,7 @@ impl Lua {
         let metatable_nrec = methods.meta_methods.len() + fields.meta_fields.len();
         #[cfg(feature = "async")]
         let metatable_nrec = metatable_nrec + methods.async_meta_methods.len();
-        push_table(self.state, 0, metatable_nrec as c_int)?;
+        push_table(self.state, 0, metatable_nrec as c_int, true)?;
         for (k, m) in methods.meta_methods {
             self.push_value(Value::Function(self.create_callback(m)?))?;
             rawset_field(self.state, -2, k.validate()?.name())?;
@@ -2420,7 +2509,7 @@ impl Lua {
         let mut field_getters_index = None;
         let field_getters_nrec = fields.field_getters.len();
         if field_getters_nrec > 0 {
-            push_table(self.state, 0, field_getters_nrec as c_int)?;
+            push_table(self.state, 0, field_getters_nrec as c_int, true)?;
             for (k, m) in fields.field_getters {
                 self.push_value(Value::Function(self.create_callback(m)?))?;
                 rawset_field(self.state, -2, &k)?;
@@ -2432,7 +2521,7 @@ impl Lua {
         let mut field_setters_index = None;
         let field_setters_nrec = fields.field_setters.len();
         if field_setters_nrec > 0 {
-            push_table(self.state, 0, field_setters_nrec as c_int)?;
+            push_table(self.state, 0, field_setters_nrec as c_int, true)?;
             for (k, m) in fields.field_setters {
                 self.push_value(Value::Function(self.create_callback(m)?))?;
                 rawset_field(self.state, -2, &k)?;
@@ -2446,7 +2535,7 @@ impl Lua {
         #[cfg(feature = "async")]
         let methods_nrec = methods_nrec + methods.async_methods.len();
         if methods_nrec > 0 {
-            push_table(self.state, 0, methods_nrec as c_int)?;
+            push_table(self.state, 0, methods_nrec as c_int, true)?;
             for (k, m) in methods.methods {
                 self.push_value(Value::Function(self.create_callback(m)?))?;
                 rawset_field(self.state, -2, &k)?;
@@ -2509,7 +2598,7 @@ impl Lua {
 
         let extra = &*self.extra.get();
         match extra.registered_userdata_mt.get(&mt_ptr) {
-            Some(&type_id) if type_id == Some(TypeId::of::<DestructedUserdataMT>()) => {
+            Some(&type_id) if type_id == Some(TypeId::of::<DestructedUserdata>()) => {
                 Err(Error::UserDataDestructed)
             }
             Some(&type_id) => Ok(type_id),
@@ -2577,10 +2666,15 @@ impl Lua {
 
             let func = mem::transmute(func);
             let extra = Arc::clone(&self.extra);
-            push_gc_userdata(self.state, CallbackUpvalue { data: func, extra })?;
-            protect_lua!(self.state, 1, 1, fn(state) {
-                ffi::lua_pushcclosure(state, call_callback, 1);
-            })?;
+            let protect = !self.unlikely_memory_error();
+            push_gc_userdata(self.state, CallbackUpvalue { data: func, extra }, protect)?;
+            if protect {
+                protect_lua!(self.state, 1, 1, fn(state) {
+                    ffi::lua_pushcclosure(state, call_callback, 1);
+                })?;
+            } else {
+                ffi::lua_pushcclosure(self.state, call_callback, 1);
+            }
 
             Ok(Function(self.pop_ref()))
         }
@@ -2636,10 +2730,15 @@ impl Lua {
                 let func = &*(*upvalue).data;
                 let fut = func(lua, args);
                 let extra = Arc::clone(&(*upvalue).extra);
-                push_gc_userdata(state, AsyncPollUpvalue { data: fut, extra })?;
-                protect_lua!(state, 1, 1, fn(state) {
+                let protect = !lua.unlikely_memory_error();
+                push_gc_userdata(state, AsyncPollUpvalue { data: fut, extra }, protect)?;
+                if protect {
+                    protect_lua!(state, 1, 1, fn(state) {
+                        ffi::lua_pushcclosure(state, poll_future, 1);
+                    })?;
+                } else {
                     ffi::lua_pushcclosure(state, poll_future, 1);
-                })?;
+                }
 
                 Ok(1)
             })
@@ -2698,10 +2797,16 @@ impl Lua {
 
             let func = mem::transmute(func);
             let extra = Arc::clone(&self.extra);
-            push_gc_userdata(self.state, AsyncCallbackUpvalue { data: func, extra })?;
-            protect_lua!(self.state, 1, 1, fn(state) {
-                ffi::lua_pushcclosure(state, call_callback, 1);
-            })?;
+            let protect = !self.unlikely_memory_error();
+            let upvalue = AsyncCallbackUpvalue { data: func, extra };
+            push_gc_userdata(self.state, upvalue, protect)?;
+            if protect {
+                protect_lua!(self.state, 1, 1, fn(state) {
+                    ffi::lua_pushcclosure(state, call_callback, 1);
+                })?;
+            } else {
+                ffi::lua_pushcclosure(self.state, call_callback, 1);
+            }
 
             Function(self.pop_ref())
         };
@@ -2775,19 +2880,25 @@ impl Lua {
         // We push metatable first to ensure having correct metatable with `__gc` method
         ffi::lua_pushnil(self.state);
         self.push_userdata_metatable::<T>()?;
+        let protect = !self.unlikely_memory_error();
         #[cfg(not(feature = "lua54"))]
-        push_userdata(self.state, data)?;
+        push_userdata(self.state, data, protect)?;
         #[cfg(feature = "lua54")]
-        push_userdata_uv(self.state, data, USER_VALUE_MAXSLOT as c_int)?;
+        push_userdata_uv(self.state, data, USER_VALUE_MAXSLOT as c_int, protect)?;
         ffi::lua_replace(self.state, -3);
         ffi::lua_setmetatable(self.state, -2);
 
         // Set empty environment for Lua 5.1
         #[cfg(any(feature = "lua51", feature = "luajit"))]
-        protect_lua!(self.state, 1, 1, fn(state) {
-            ffi::lua_newtable(state);
-            ffi::lua_setuservalue(state, -2);
-        })?;
+        if protect {
+            protect_lua!(self.state, 1, 1, fn(state) {
+                ffi::lua_newtable(state);
+                ffi::lua_setuservalue(state, -2);
+            })?;
+        } else {
+            ffi::lua_newtable(self.state);
+            ffi::lua_setuservalue(self.state, -2);
+        }
 
         Ok(AnyUserData(self.pop_ref()))
     }
@@ -2823,7 +2934,7 @@ impl Lua {
         let _sg = StackGuard::new(state);
         assert_stack(state, 1);
         let extra = extra_data(state)?;
-        let inner = &*(*extra.get()).inner.as_ref().unwrap();
+        let inner = (*extra.get()).inner.as_ref().unwrap();
         Some(Lua(Arc::clone(inner)))
     }
 
@@ -2845,20 +2956,30 @@ impl Lua {
             }
         }
     }
+
+    #[inline]
+    pub(crate) unsafe fn unlikely_memory_error(&self) -> bool {
+        let extra = &mut *self.extra.get();
+        // MemoryInfo is empty in module mode so we cannot predict memory limits
+        extra
+            .mem_info
+            .map(|x| x.as_ref().memory_limit == 0)
+            .unwrap_or_default()
+    }
 }
 
 struct StateGuard<'a>(&'a mut LuaInner, *mut ffi::lua_State);
 
 impl<'a> StateGuard<'a> {
     fn new(inner: &'a mut LuaInner, mut state: *mut ffi::lua_State) -> Self {
-        mem::swap(&mut (*inner).state, &mut state);
+        mem::swap(&mut inner.state, &mut state);
         Self(inner, state)
     }
 }
 
 impl<'a> Drop for StateGuard<'a> {
     fn drop(&mut self) {
-        mem::swap(&mut (*self.0).state, &mut self.1);
+        mem::swap(&mut self.0.state, &mut self.1);
     }
 }
 

src/luau.rs

@@ -85,10 +85,12 @@ fn lua_require(lua: &Lua, name: Option<std::string::String>) -> Result<Value> {
         search_path = "?.luau;?.lua".into();
     }
 
-    let mut source = None;
+    let (mut source, mut source_name) = (None, String::new());
     for path in search_path.split(';') {
-        if let Ok(buf) = std::fs::read(path.replacen('?', &name, 1)) {
+        let file_path = path.replacen('?', &name, 1);
+        if let Ok(buf) = std::fs::read(&file_path) {
             source = Some(buf);
+            source_name = file_path;
             break;
         }
     }
@@ -96,7 +98,7 @@ fn lua_require(lua: &Lua, name: Option<std::string::String>) -> Result<Value> {
 
     let value = lua
         .load(&source)
-        .set_name(&format!("={}", name))?
+        .set_name(&format!("={}", source_name))?
         .set_mode(ChunkMode::Text)
         .call::<_, Value>(())?;
 

src/multi.rs

@@ -11,6 +11,7 @@ use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
 /// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
 /// on success, or in the case of an error, returning `nil` and an error message.
 impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E> {
+    #[inline]
     fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
         let mut result = MultiValue::new_or_cached(lua);
         match self {
@@ -25,6 +26,7 @@ impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E>
 }
 
 impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
+    #[inline]
     fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
         let mut v = MultiValue::new_or_cached(lua);
         v.push_front(self.to_lua(lua)?);
@@ -33,6 +35,7 @@ impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
 }
 
 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
+    #[inline]
     fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
         let res = T::from_lua(values.pop_front().unwrap_or(Nil), lua);
         lua.cache_multivalue(values);
@@ -41,12 +44,14 @@ impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
 }
 
 impl<'lua> ToLuaMulti<'lua> for MultiValue<'lua> {
+    #[inline]
     fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
         Ok(self)
     }
 }
 
 impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
+    #[inline]
     fn from_lua_multi(values: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
         Ok(values)
     }
@@ -83,7 +88,7 @@ pub struct Variadic<T>(Vec<T>);
 
 impl<T> Variadic<T> {
     /// Creates an empty `Variadic` wrapper containing no values.
-    pub fn new() -> Variadic<T> {
+    pub const fn new() -> Variadic<T> {
         Variadic(Vec::new())
     }
 }
@@ -124,6 +129,7 @@ impl<T> DerefMut for Variadic<T> {
 }
 
 impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
+    #[inline]
     fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
         let mut values = MultiValue::new_or_cached(lua);
         values.refill(self.0.into_iter().map(|e| e.to_lua(lua)))?;
@@ -132,6 +138,7 @@ impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
 }
 
 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
+    #[inline]
     fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
         let res = values
             .drain_all()
@@ -146,12 +153,14 @@ impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
 macro_rules! impl_tuple {
     () => (
         impl<'lua> ToLuaMulti<'lua> for () {
+            #[inline]
             fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
                 Ok(MultiValue::new_or_cached(lua))
             }
         }
 
         impl<'lua> FromLuaMulti<'lua> for () {
+            #[inline]
             fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
                 lua.cache_multivalue(values);
                 Ok(())
@@ -166,6 +175,7 @@ macro_rules! impl_tuple {
         {
             #[allow(unused_mut)]
             #[allow(non_snake_case)]
+            #[inline]
             fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
                 let ($($name,)* $last,) = self;
 
@@ -181,6 +191,7 @@ macro_rules! impl_tuple {
         {
             #[allow(unused_mut)]
             #[allow(non_snake_case)]
+            #[inline]
             fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
                 $(let $name = values.pop_front().unwrap_or(Nil);)*
                 let $last = FromLuaMulti::from_lua_multi(values, lua)?;

src/scope.rs

@@ -355,13 +355,14 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                 crate::util::push_userdata::<UserDataCell<Rc<RefCell<T>>>>(
                     lua.state,
                     UserDataCell::new(data.clone()),
+                    true,
                 )?;
                 ffi::lua_touserdata(lua.state, -1)
             };
 
             // Prepare metatable, add meta methods first and then meta fields
             let meta_methods_nrec = ud_methods.meta_methods.len() + ud_fields.meta_fields.len() + 1;
-            push_table(lua.state, 0, meta_methods_nrec as c_int)?;
+            push_table(lua.state, 0, meta_methods_nrec as c_int, true)?;
 
             for (k, m) in ud_methods.meta_methods {
                 let data = data.clone();
@@ -377,7 +378,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             let mut field_getters_index = None;
             let field_getters_nrec = ud_fields.field_getters.len();
             if field_getters_nrec > 0 {
-                push_table(lua.state, 0, field_getters_nrec as c_int)?;
+                push_table(lua.state, 0, field_getters_nrec as c_int, true)?;
                 for (k, m) in ud_fields.field_getters {
                     let data = data.clone();
                     lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
@@ -389,7 +390,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             let mut field_setters_index = None;
             let field_setters_nrec = ud_fields.field_setters.len();
             if field_setters_nrec > 0 {
-                push_table(lua.state, 0, field_setters_nrec as c_int)?;
+                push_table(lua.state, 0, field_setters_nrec as c_int, true)?;
                 for (k, m) in ud_fields.field_setters {
                     let data = data.clone();
                     lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
@@ -402,7 +403,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             let methods_nrec = ud_methods.methods.len();
             if methods_nrec > 0 {
                 // Create table used for methods lookup
-                push_table(lua.state, 0, methods_nrec as c_int)?;
+                push_table(lua.state, 0, methods_nrec as c_int, true)?;
                 for (k, m) in ud_methods.methods {
                     let data = data.clone();
                     lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
@@ -596,6 +597,7 @@ impl<'lua, 'scope> Drop for Scope<'lua, 'scope> {
     }
 }
 
+#[allow(clippy::type_complexity)]
 enum NonStaticMethod<'lua, T> {
     Method(Box<dyn Fn(&'lua Lua, &T, MultiValue<'lua>) -> Result<MultiValue<'lua>>>),
     MethodMut(Box<dyn FnMut(&'lua Lua, &mut T, MultiValue<'lua>) -> Result<MultiValue<'lua>>>),

src/serde/de.rs

@@ -8,7 +8,6 @@ use rustc_hash::FxHashSet;
 use serde::de::{self, IntoDeserializer};
 
 use crate::error::{Error, Result};
-use crate::ffi;
 use crate::table::{Table, TablePairs, TableSequence};
 use crate::value::Value;
 
@@ -563,9 +562,7 @@ impl RecursionGuard {
     #[inline]
     fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
         let visited = Rc::clone(visited);
-        let lua = table.0.lua;
-        let ptr =
-            unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+        let ptr = table.to_pointer();
         visited.borrow_mut().insert(ptr);
         RecursionGuard { ptr, visited }
     }
@@ -585,9 +582,7 @@ fn check_value_if_skip(
 ) -> Result<bool> {
     match value {
         Value::Table(table) => {
-            let lua = table.0.lua;
-            let ptr =
-                unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+            let ptr = table.to_pointer();
             if visited.borrow().contains(&ptr) {
                 if options.deny_recursive_tables {
                     return Err(de::Error::custom("recursive table detected"));

src/serde/ser.rs

@@ -327,10 +327,17 @@ impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
 
             lua.push_ref(&self.table.0);
             lua.push_value(value)?;
-            protect_lua!(lua.state, 2, 0, fn(state) {
-                let len = ffi::lua_rawlen(state, -2) as Integer;
-                ffi::lua_rawseti(state, -2, len + 1);
-            })
+            if lua.unlikely_memory_error() {
+                let len = ffi::lua_rawlen(lua.state, -2) as Integer;
+                ffi::lua_rawseti(lua.state, -2, len + 1);
+                ffi::lua_pop(lua.state, 1);
+                Ok(())
+            } else {
+                protect_lua!(lua.state, 2, 0, fn(state) {
+                    let len = ffi::lua_rawlen(state, -2) as Integer;
+                    ffi::lua_rawseti(state, -2, len + 1);
+                })
+            }
         }
     }
 

src/string.rs

@@ -1,5 +1,6 @@
 use std::borrow::{Borrow, Cow};
 use std::hash::{Hash, Hasher};
+use std::os::raw::c_void;
 use std::string::String as StdString;
 use std::{slice, str};
 
@@ -112,6 +113,17 @@ impl<'lua> String<'lua> {
             slice::from_raw_parts(data as *const u8, size + 1)
         }
     }
+
+    /// Converts the string to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        let lua = self.0.lua;
+        unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) }
+    }
 }
 
 impl<'lua> AsRef<[u8]> for String<'lua> {

src/table.rs

@@ -1,10 +1,11 @@
 use std::marker::PhantomData;
+use std::os::raw::c_void;
 
 #[cfg(feature = "serialize")]
 use {
     rustc_hash::FxHashSet,
     serde::ser::{self, Serialize, SerializeMap, SerializeSeq, Serializer},
-    std::{cell::RefCell, os::raw::c_void, result::Result as StdResult},
+    std::{cell::RefCell, result::Result as StdResult},
 };
 
 use crate::error::{Error, Result};
@@ -198,7 +199,13 @@ impl<'lua> Table<'lua> {
             lua.push_ref(&self.0);
             lua.push_value(key)?;
             lua.push_value(value)?;
-            protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_rawset(state, -3))
+            if lua.unlikely_memory_error() {
+                ffi::lua_rawset(lua.state, -3);
+                ffi::lua_pop(lua.state, 1);
+                Ok(())
+            } else {
+                protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_rawset(state, -3))
+            }
         }
     }
 
@@ -376,6 +383,18 @@ impl<'lua> Table<'lua> {
         unsafe { lua.ref_thread_exec(|refthr| ffi::lua_getreadonly(refthr, self.0.index) != 0) }
     }
 
+    /// Converts the table to a generic C pointer.
+    ///
+    /// Different tables will give different pointers.
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        let lua = self.0.lua;
+        unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) }
+    }
+
     /// Consume this table and return an iterator over the pairs of the table.
     ///
     /// This works like the Lua `pairs` function, but does not invoke the `__pairs` metamethod.
@@ -693,8 +712,7 @@ impl<'lua> Serialize for Table<'lua> {
             static VISITED: RefCell<FxHashSet<*const c_void>> = RefCell::new(FxHashSet::default());
         }
 
-        let lua = self.0.lua;
-        let ptr = unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) };
+        let ptr = self.to_pointer();
         let res = VISITED.with(|visited| {
             {
                 let mut visited = visited.borrow_mut();

src/thread.rs

@@ -4,7 +4,7 @@ use std::os::raw::c_int;
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{check_stack, error_traceback, pop_error, StackGuard};
+use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
 use crate::value::{FromLuaMulti, ToLuaMulti};
 
 #[cfg(any(
@@ -136,8 +136,12 @@ impl<'lua> Thread<'lua> {
 
             let ret = ffi::lua_resume(thread_state, lua.state, nargs, &mut nresults as *mut c_int);
             if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
-                protect_lua!(lua.state, 0, 0, |_| error_traceback(thread_state))?;
-                return Err(pop_error(thread_state, ret));
+                check_stack(lua.state, 3)?;
+                protect_lua!(lua.state, 0, 1, |state| error_traceback_thread(
+                    state,
+                    thread_state
+                ))?;
+                return Err(pop_error(lua.state, ret));
             }
 
             let mut results = args; // Reuse MultiValue container
@@ -357,7 +361,16 @@ impl<'lua, R> Drop for AsyncThread<'lua, R> {
     fn drop(&mut self) {
         if self.recycle {
             unsafe {
-                self.thread.0.lua.recycle_thread(&mut self.thread);
+                let lua = self.thread.0.lua;
+                // For Lua 5.4 this also closes all pending to-be-closed variables
+                if !lua.recycle_thread(&mut self.thread) {
+                    #[cfg(feature = "lua54")]
+                    if self.thread.status() == ThreadStatus::Error {
+                        let thread_state =
+                            lua.ref_thread_exec(|t| ffi::lua_tothread(t, self.thread.0.index));
+                        ffi::lua_resetthread(thread_state);
+                    }
+                }
             }
         }
     }

src/types.rs

@@ -83,7 +83,7 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}
 
-pub(crate) struct DestructedUserdataMT;
+pub(crate) struct DestructedUserdata;
 
 /// An auto generated key into the Lua registry.
 ///

src/userdata_impl.rs

@@ -622,3 +622,8 @@ lua_userdata_impl!(Arc<RwLock<T>>);
 lua_userdata_impl!(Arc<parking_lot::Mutex<T>>);
 #[cfg(feature = "parking_lot")]
 lua_userdata_impl!(Arc<parking_lot::RwLock<T>>);
+
+// A special proxy object for UserData
+pub(crate) struct UserDataProxy<T>(pub(crate) PhantomData<T>);
+
+lua_userdata_impl!(UserDataProxy<T>);

src/util.rs

@@ -1,6 +1,7 @@
 use std::any::{Any, TypeId};
 use std::ffi::CStr;
 use std::fmt::Write;
+use std::mem::MaybeUninit;
 use std::os::raw::{c_char, c_int, c_void};
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
 use std::sync::Arc;
@@ -136,26 +137,21 @@ where
     F: Fn(*mut ffi::lua_State) -> R,
     R: Copy,
 {
-    union URes<R: Copy> {
-        uninit: (),
-        init: R,
-    }
-
     struct Params<F, R: Copy> {
         function: F,
-        result: URes<R>,
+        result: MaybeUninit<R>,
         nresults: c_int,
     }
 
     unsafe extern "C" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
     where
-        R: Copy,
         F: Fn(*mut ffi::lua_State) -> R,
+        R: Copy,
     {
         let params = ffi::lua_touserdata(state, -1) as *mut Params<F, R>;
         ffi::lua_pop(state, 1);
 
-        (*params).result.init = ((*params).function)(state);
+        (*params).result.write(((*params).function)(state));
 
         if (*params).nresults == ffi::LUA_MULTRET {
             ffi::lua_gettop(state)
@@ -174,7 +170,7 @@ where
 
     let mut params = Params {
         function: f,
-        result: URes { uninit: () },
+        result: MaybeUninit::uninit(),
         nresults,
     };
 
@@ -185,7 +181,7 @@ where
     if ret == ffi::LUA_OK {
         // `LUA_OK` is only returned when the `do_call` function has completed successfully, so
         // `params.result` is definitely initialized.
-        Ok(params.result.init)
+        Ok(params.result.assume_init())
     } else {
         Err(pop_error(state, ret))
     }
@@ -203,7 +199,7 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
         "pop_error called with non-error return code"
     );
 
-    match get_gc_userdata::<WrappedFailure>(state, -1).as_mut() {
+    match get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_mut() {
         Some(WrappedFailure::Error(err)) => {
             ffi::lua_pop(state, 1);
             err.clone()
@@ -251,17 +247,33 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
 pub unsafe fn push_string<S: AsRef<[u8]> + ?Sized>(
     state: *mut ffi::lua_State,
     s: &S,
+    protect: bool,
 ) -> Result<()> {
     let s = s.as_ref();
-    protect_lua!(state, 0, 1, |state| {
+    if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
+        })
+    } else {
         ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
-    })
+        Ok(())
+    }
 }
 
 // Uses 3 stack spaces, does not call checkstack.
 #[inline]
-pub unsafe fn push_table(state: *mut ffi::lua_State, narr: c_int, nrec: c_int) -> Result<()> {
-    protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
+pub unsafe fn push_table(
+    state: *mut ffi::lua_State,
+    narr: c_int,
+    nrec: c_int,
+    protect: bool,
+) -> Result<()> {
+    if protect {
+        protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
+    } else {
+        ffi::lua_createtable(state, narr, nrec);
+        Ok(())
+    }
 }
 
 // Uses 4 stack spaces, does not call checkstack.
@@ -281,10 +293,14 @@ where
 // Internally uses 3 stack spaces, does not call checkstack.
 #[cfg(not(feature = "luau"))]
 #[inline]
-pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
-    let ud = protect_lua!(state, 0, 1, |state| {
+pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
+        })?
+    } else {
         ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
-    })?;
+    };
     ptr::write(ud, t);
     Ok(())
 }
@@ -292,20 +308,20 @@ pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
 // Internally uses 3 stack spaces, does not call checkstack.
 #[cfg(feature = "luau")]
 #[inline]
-pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
+pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
     unsafe extern "C" fn destructor<T>(ud: *mut c_void) {
-        let ud = ud as *mut T;
-        if *(ud.offset(1) as *mut u8) == 0 {
-            ptr::drop_in_place(ud);
-        }
+        ptr::drop_in_place(ud as *mut T);
     }
 
-    let ud = protect_lua!(state, 0, 1, |state| {
-        let size = mem::size_of::<T>() + 1;
+    let size = mem::size_of::<T>() + 1;
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
+        })?
+    } else {
         ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
-    })?;
+    };
     ptr::write(ud, t);
-    *(ud.offset(1) as *mut u8) = 0; // Mark as not destructed
 
     Ok(())
 }
@@ -313,10 +329,19 @@ pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
 // Internally uses 3 stack spaces, does not call checkstack.
 #[cfg(feature = "lua54")]
 #[inline]
-pub unsafe fn push_userdata_uv<T>(state: *mut ffi::lua_State, t: T, nuvalue: c_int) -> Result<()> {
-    let ud = protect_lua!(state, 0, 1, |state| {
+pub unsafe fn push_userdata_uv<T>(
+    state: *mut ffi::lua_State,
+    t: T,
+    nuvalue: c_int,
+    protect: bool,
+) -> Result<()> {
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
+        })?
+    } else {
         ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
-    })?;
+    };
     ptr::write(ud, t);
     Ok(())
 }
@@ -340,33 +365,51 @@ pub unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
     get_destructed_userdata_metatable(state);
     ffi::lua_setmetatable(state, -2);
     let ud = get_userdata::<T>(state, -1);
+
+    // Update userdata tag to disable destructor and mark as destructed
+    #[cfg(feature = "luau")]
+    ffi::lua_setuserdatatag(state, -1, 1);
+
     ffi::lua_pop(state, 1);
-    if cfg!(feature = "luau") {
-        *(ud.offset(1) as *mut u8) = 1; // Mark as destructed
-    }
     ptr::read(ud)
 }
 
 // Pushes the userdata and attaches a metatable with __gc method.
 // Internally uses 3 stack spaces, does not call checkstack.
-pub unsafe fn push_gc_userdata<T: Any>(state: *mut ffi::lua_State, t: T) -> Result<()> {
-    push_userdata(state, t)?;
+pub unsafe fn push_gc_userdata<T: Any>(
+    state: *mut ffi::lua_State,
+    t: T,
+    protect: bool,
+) -> Result<()> {
+    push_userdata(state, t, protect)?;
     get_gc_metatable::<T>(state);
     ffi::lua_setmetatable(state, -2);
     Ok(())
 }
 
 // Uses 2 stack spaces, does not call checkstack
-pub unsafe fn get_gc_userdata<T: Any>(state: *mut ffi::lua_State, index: c_int) -> *mut T {
+pub unsafe fn get_gc_userdata<T: Any>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+    mt_ptr: *const c_void,
+) -> *mut T {
     let ud = ffi::lua_touserdata(state, index) as *mut T;
     if ud.is_null() || ffi::lua_getmetatable(state, index) == 0 {
         return ptr::null_mut();
     }
-    get_gc_metatable::<T>(state);
-    let res = ffi::lua_rawequal(state, -1, -2);
-    ffi::lua_pop(state, 2);
-    if res == 0 {
-        return ptr::null_mut();
+    if !mt_ptr.is_null() {
+        let ud_mt_ptr = ffi::lua_topointer(state, -1);
+        ffi::lua_pop(state, 1);
+        if !ptr::eq(ud_mt_ptr, mt_ptr) {
+            return ptr::null_mut();
+        }
+    } else {
+        get_gc_metatable::<T>(state);
+        let res = ffi::lua_rawequal(state, -1, -2);
+        ffi::lua_pop(state, 2);
+        if res == 0 {
+            return ptr::null_mut();
+        }
     }
     ud
 }
@@ -505,7 +548,7 @@ pub unsafe fn init_userdata_metatable<T>(
         // Push `__index` generator function
         init_userdata_metatable_index(state)?;
 
-        push_string(state, "__index")?;
+        push_string(state, "__index", true)?;
         let index_type = ffi::lua_rawget(state, -3);
         match index_type {
             ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
@@ -530,7 +573,7 @@ pub unsafe fn init_userdata_metatable<T>(
         // Push `__newindex` generator function
         init_userdata_metatable_newindex(state)?;
 
-        push_string(state, "__newindex")?;
+        push_string(state, "__newindex", true)?;
         let newindex_type = ffi::lua_rawget(state, -3);
         match newindex_type {
             ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
@@ -642,7 +685,7 @@ pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
         return 1;
     }
 
-    if get_gc_userdata::<WrappedFailure>(state, -1).is_null() {
+    if get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
         let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
         if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
             ffi::luaL_traceback(state, state, s, 0);
@@ -653,6 +696,20 @@ pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
     1
 }
 
+// A variant of `error_traceback` that can safely inspect another (yielded) thread stack
+pub unsafe fn error_traceback_thread(state: *mut ffi::lua_State, thread: *mut ffi::lua_State) {
+    // Move error object to the main thread to safely call `__tostring` metamethod if present
+    ffi::lua_xmove(thread, state, 1);
+
+    if get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
+        let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
+        if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+            ffi::luaL_traceback(state, thread, s, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+}
+
 // A variant of `pcall` that does not allow Lua to catch Rust panics from `callback_error`.
 pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
     ffi::luaL_checkstack(state, 2, ptr::null());
@@ -669,7 +726,7 @@ pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
         ffi::lua_gettop(state)
     } else {
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             ffi::lua_error(state);
         }
@@ -685,7 +742,7 @@ pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
         ffi::luaL_checkstack(state, 2, ptr::null());
 
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             1
         } else {
@@ -715,7 +772,7 @@ pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
         ffi::lua_gettop(state) - 1
     } else {
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             ffi::lua_error(state);
         }
@@ -758,7 +815,7 @@ pub unsafe fn init_gc_metatable<T: Any>(
 ) -> Result<()> {
     check_stack(state, 6)?;
 
-    push_table(state, 0, 3)?;
+    push_table(state, 0, 3, true)?;
 
     #[cfg(not(feature = "luau"))]
     {
@@ -799,7 +856,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         callback_error(state, |_| {
             check_stack(state, 3)?;
 
-            let err_buf = match get_gc_userdata::<WrappedFailure>(state, -1).as_ref() {
+            let err_buf = match get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref() {
                 Some(WrappedFailure::Error(error)) => {
                     let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
                     ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
@@ -836,7 +893,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
                 }
             }?;
 
-            push_string(state, &*err_buf)?;
+            push_string(state, &*err_buf, true)?;
             (*err_buf).clear();
 
             Ok(1)
@@ -857,7 +914,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         callback_error(state, |_| Err(Error::CallbackDestructed))
     }
 
-    push_table(state, 0, 26)?;
+    push_table(state, 0, 26, true)?;
     ffi::lua_pushcfunction(state, destructed_error);
     for &method in &[
         "__add",
@@ -899,6 +956,8 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         "__pairs",
         #[cfg(any(feature = "lua53", feature = "lua52", feature = "luajit52"))]
         "__ipairs",
+        #[cfg(feature = "luau")]
+        "__iter",
         #[cfg(feature = "lua54")]
         "__close",
     ] {
@@ -914,7 +973,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
 
     // Create error print buffer
     init_gc_metatable::<String>(state, None)?;
-    push_gc_userdata(state, String::new())?;
+    push_gc_userdata(state, String::new(), true)?;
     protect_lua!(state, 1, 0, fn(state) {
         let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
         ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);

src/value.rs

@@ -1,4 +1,5 @@
 use std::iter::{self, FromIterator};
+use std::ops::Index;
 use std::os::raw::c_void;
 use std::{ptr, slice, str, vec};
 
@@ -103,13 +104,14 @@ impl<'lua> Value<'lua> {
     /// There is no way to convert the pointer back to its original value.
     ///
     /// Typically this function is used only for hashing and debug information.
+    #[inline]
     pub fn to_pointer(&self) -> *const c_void {
         unsafe {
             match self {
                 Value::LightUserData(ud) => ud.0,
-                Value::String(String(v))
-                | Value::Table(Table(v))
-                | Value::Function(Function(v))
+                Value::Table(t) => t.to_pointer(),
+                Value::String(s) => s.to_pointer(),
+                Value::Function(Function(v))
                 | Value::Thread(Thread(v))
                 | Value::UserData(AnyUserData(v)) => v
                     .lua
@@ -196,7 +198,7 @@ pub struct MultiValue<'lua>(Vec<Value<'lua>>);
 impl<'lua> MultiValue<'lua> {
     /// Creates an empty `MultiValue` containing no values.
     #[inline]
-    pub fn new() -> MultiValue<'lua> {
+    pub const fn new() -> MultiValue<'lua> {
         MultiValue(Vec::new())
     }
 
@@ -237,7 +239,24 @@ impl<'a, 'lua> IntoIterator for &'a MultiValue<'lua> {
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
-        (&self.0).iter().rev()
+        self.0.iter().rev()
+    }
+}
+
+impl<'lua> Index<usize> for MultiValue<'lua> {
+    type Output = Value<'lua>;
+
+    #[inline]
+    fn index(&self, index: usize) -> &Self::Output {
+        if let Some(result) = self.get(index) {
+            result
+        } else {
+            panic!(
+                "index out of bounds: the len is {} but the index is {}",
+                self.len(),
+                index
+            )
+        }
     }
 }
 
@@ -255,19 +274,24 @@ impl<'lua> MultiValue<'lua> {
         v
     }
 
+    #[inline]
+    pub fn get(&self, index: usize) -> Option<&Value<'lua>> {
+        self.0.get(self.0.len() - index - 1)
+    }
+
     #[inline]
     pub(crate) fn reserve(&mut self, size: usize) {
         self.0.reserve(size);
     }
 
     #[inline]
-    pub(crate) fn push_front(&mut self, value: Value<'lua>) {
-        self.0.push(value);
+    pub fn pop_front(&mut self) -> Option<Value<'lua>> {
+        self.0.pop()
     }
 
     #[inline]
-    pub(crate) fn pop_front(&mut self) -> Option<Value<'lua>> {
-        self.0.pop()
+    pub fn push_front(&mut self, value: Value<'lua>) {
+        self.0.push(value);
     }
 
     #[inline]

tests/async.rs

@@ -174,6 +174,38 @@ async fn test_async_return_async_closure() -> Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "lua54")]
+#[tokio::test]
+async fn test_async_lua54_to_be_closed() -> Result<()> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    globals.set("close_count", 0)?;
+
+    let code = r#"
+        local t <close> = setmetatable({}, {
+            __close = function()
+                close_count = close_count + 1
+            end
+        })
+        error "test"
+    "#;
+    let f = lua.load(code).into_function()?;
+
+    // Test close using call_async
+    let _ = f.call_async::<_, ()>(()).await;
+    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+
+    // Don't close by default when awaiting async threads
+    let co = lua.create_thread(f.clone())?;
+    let _ = co.clone().into_async::<_, ()>(()).await;
+    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+    let _ = co.reset(f);
+    assert_eq!(globals.get::<_, usize>("close_count")?, 2);
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_thread_stream() -> Result<()> {
     let lua = Lua::new();
@@ -278,6 +310,28 @@ async fn test_async_table() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_async_thread_cache() -> Result<()> {
+    let options = LuaOptions::new().thread_cache_size(4);
+    let lua = Lua::new_with(StdLib::ALL_SAFE, options)?;
+
+    let error_f = lua.create_async_function(|_, ()| async move {
+        Delay::new(Duration::from_millis(10)).await;
+        Err::<(), _>(Error::RuntimeError("test".to_string()))
+    })?;
+
+    let sleep = lua.create_async_function(|_, n| async move {
+        Delay::new(Duration::from_millis(n)).await;
+        Ok(format!("elapsed:{}ms", n))
+    })?;
+
+    assert!(error_f.call_async::<_, ()>(()).await.is_err());
+    // Next call should use cached thread
+    assert_eq!(sleep.call_async::<_, String>(3).await?, "elapsed:3ms");
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_userdata() -> Result<()> {
     #[derive(Clone)]
@@ -372,6 +426,30 @@ async fn test_async_userdata() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_async_thread_error() -> Result<()> {
+    struct MyUserData;
+
+    impl UserData for MyUserData {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_meta_method("__tostring", |_, _this, ()| Ok("myuserdata error"))
+        }
+    }
+
+    let lua = Lua::new();
+    let result = lua
+        .load("function x(...) error(...) end x(...)")
+        .set_name("chunk")?
+        .call_async::<_, ()>(MyUserData)
+        .await;
+    assert!(
+        matches!(result, Err(Error::RuntimeError(cause)) if cause.contains("myuserdata error")),
+        "improper error traceback from dead thread"
+    );
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_scope() -> Result<()> {
     let ref lua = Lua::new();

tests/function.rs

@@ -42,11 +42,17 @@ fn test_bind() -> Result<()> {
     concat = concat.bind("foo")?;
     concat = concat.bind("bar")?;
     concat = concat.bind(("baz", "baf"))?;
+    assert_eq!(concat.call::<_, String>(())?, "foobarbazbaf");
     assert_eq!(
         concat.call::<_, String>(("hi", "wut"))?,
         "foobarbazbafhiwut"
     );
 
+    let mut concat2 = globals.get::<_, Function>("concat")?;
+    concat2 = concat2.bind(())?;
+    assert_eq!(concat2.call::<_, String>(())?, "");
+    assert_eq!(concat2.call::<_, String>(("ab", "cd"))?, "abcd");
+
     Ok(())
 }
 

tests/luau.rs

@@ -15,8 +15,11 @@ fn test_require() -> Result<()> {
     fs::write(
         temp_dir.path().join("module.luau"),
         r#"
-        counter = counter or 0
-        return counter + 1
+        counter = (counter or 0) + 1
+        return {
+            counter = counter,
+            error = function() error("test") end,
+        }
     "#,
     )?;
 
@@ -24,9 +27,12 @@ fn test_require() -> Result<()> {
     lua.load(
         r#"
         local module = require("module")
-        assert(module == 1)
+        assert(module.counter == 1)
         module = require("module")
-        assert(module == 1)
+        assert(module.counter == 1)
+
+        local ok, err = pcall(module.error)
+        assert(not ok and string.find(err, "module.luau") ~= nil)
     "#,
     )
     .exec()

tests/tests.rs

@@ -560,7 +560,12 @@ fn test_num_conversion() -> Result<()> {
     assert_eq!(lua.load("1.0").eval::<f64>()?, 1.0);
     #[cfg(any(feature = "lua54", feature = "lua53"))]
     assert_eq!(lua.load("1.0").eval::<String>()?, "1.0");
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
+    #[cfg(any(
+        feature = "lua52",
+        feature = "lua51",
+        feature = "luajit",
+        feature = "luau"
+    ))]
     assert_eq!(lua.load("1.0").eval::<String>()?, "1");
 
     assert_eq!(lua.load("1.5").eval::<i64>()?, 1);
@@ -1272,3 +1277,14 @@ fn test_luajit_cdata() {
         )
         .eval();
 }
+
+#[test]
+#[cfg(feature = "send")]
+fn test_send() {
+    let lua = Lua::new();
+    std::thread::spawn(move || {
+        let _lua = lua;
+    })
+    .join()
+    .unwrap();
+}

tests/userdata.rs

@@ -656,3 +656,44 @@ fn test_userdata_wrapped() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_userdata_proxy() -> Result<()> {
+    struct MyUserData(i64);
+
+    impl UserData for MyUserData {
+        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field_function_get("static_field", |_, _| Ok(123));
+            fields.add_field_method_get("n", |_, this| Ok(this.0));
+        }
+
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_function("new", |_, n| Ok(Self(n)));
+
+            methods.add_method("plus", |_, this, n: i64| Ok(this.0 + n));
+        }
+    }
+
+    let lua = Lua::new();
+    let globals = lua.globals();
+    globals.set("MyUserData", lua.create_proxy::<MyUserData>()?)?;
+
+    lua.load(
+        r#"
+        assert(MyUserData.static_field == 123)
+        local data = MyUserData.new(321)
+        assert(data.static_field == 123)
+        assert(data.n == 321)
+        assert(data:plus(1) == 322)
+
+        -- Error when accessing the proxy object fields and methods that require instance
+
+        local ok = pcall(function() return MyUserData.n end)
+        assert(not ok)
+
+        ok = pcall(function() return MyUserData:plus(1) end)
+        assert(not ok)
+    "#,
+    )
+    .exec()
+}