v0.9.0-rc.2

Prepare v0.9-rc.2 release

.github/workflows/main.yml

@@ -9,7 +9,7 @@ jobs:
       matrix:
         os: [ubuntu-22.04, macos-latest, windows-latest]
         rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
         include:
           - os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
@@ -104,7 +104,7 @@ jobs:
       matrix:
         os: [ubuntu-22.04, macos-latest, windows-latest]
         rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau, luau-jit, luau-vector4]
         include:
           - os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
@@ -140,7 +140,7 @@ jobs:
       matrix:
         os: [ubuntu-22.04]
         rust: [nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
         include:
           - os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
@@ -218,18 +218,18 @@ jobs:
       - run: cargo fmt -- --check
 
   clippy:
-    name: Clippy check
+    name: Clippy
     runs-on: ubuntu-22.04
     strategy:
       matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: nightly
           components: clippy
-      - uses: actions-rs/clippy-check@v1
+      - uses: giraffate/clippy-action@v1
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+          reporter: 'github-pr-review'
+          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"

.gitignore

@@ -4,3 +4,4 @@ Cargo.lock
 
 .vscode/
 .DS_Store
+.stignore

CHANGELOG.md

@@ -1,3 +1,43 @@
+## v0.9.0-rc.2
+
+- Added `#[derive(FromLua)]` macro to opt-in into `FromLua<T> where T: 'static + Clone` (userdata type).
+- Support vendored module mode for windows (raw-dylib linking, Rust 1.71+)
+- `module` and `vendored` features are now mutually exclusive
+- Use `C-unwind` ABI (Rust 1.71+)
+- Changed `AsChunk` trait to support capturing wrapped Lua types
+
+## v0.9.0-rc.1
+
+- `UserDataMethods::add_async_method()` takes `&T` instead of cloning `T`
+- Implemented `PartialEq<[T]>` for tables
+- Added Luau 4-dimensional vectors support (`luau-vector4` feature)
+- `Table::sequence_values()` iterator no longer uses any metamethods (`Table::raw_sequence_values()` is deprecated)
+- Added `Table:is_empty()` function that checks both hash and array parts
+- Refactored Debug interface
+- Re-exported `ffi` (`mlua-sys`) crate for easier writing of unsafe code
+- Refactored Lua 5.4 warnings interface
+- Take `&str` as function name in `TableExt` and `AnyUserDataExt` traits
+- Added module attribule `skip_memory_check` to improve performance
+- Added `AnyUserData::wrap()` to provide more easy way of creating _any_ userdata in Lua
+
+## v0.9.0-beta.3
+
+- Added `OwnedAnyUserData::take()`
+- Switch to `DeserializeOwned`
+- Overwrite error context when called multiple times
+- New feature flag `luau-jit` to enable (experimental) Luau codegen backend
+- Set `__name` field in userdata metatable
+- Added `Value::to_string()` method similar to `luaL_tolstring`
+- Lua 5.4.6
+- Application data container now allows to mutably and immutably borrow different types at the same time
+- Performance optimizations
+- Support getting and setting environment for Lua functions.
+- Added `UserDataFields::add_field()` method to add static fields to UserData
+
+Breaking changes:
+- Require environment to be a `Table` instead of `Value` in Chunks.
+- `AsChunk::env()` renamed to `AsChunk::environment()`
+
 ## v0.9.0-beta.2
 
 New features:

Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "mlua"
-version = "0.9.0-beta.2" # remember to update mlua_derive
+version = "0.9.0-rc.2" # remember to update mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
+rust-version = "1.71"
 edition = "2021"
 repository = "https://github.com/khvzak/mlua"
 documentation = "https://docs.rs/mlua"
@@ -32,39 +33,38 @@ lua51 = ["ffi/lua51"]
 luajit = ["ffi/luajit"]
 luajit52 = ["luajit", "ffi/luajit52"]
 luau = ["ffi/luau"]
+luau-jit = ["luau", "ffi/luau-codegen"]
+luau-vector4 = ["luau", "ffi/luau-vector4"]
 vendored = ["ffi/vendored"]
 module = ["mlua_derive", "ffi/module"]
-async = ["futures-core", "futures-task", "futures-util"]
+async = ["futures-util"]
 send = []
 serialize = ["serde", "erased-serde", "serde-value"]
 macros = ["mlua_derive/macros"]
 unstable = []
 
 [dependencies]
-mlua_derive = { version = "=0.9.0-beta.1", optional = true, path = "mlua_derive" }
+mlua_derive = { version = "=0.9.0-rc.2", optional = true, path = "mlua_derive" }
 bstr = { version = "1.0", features = ["std"], default_features = false }
 once_cell = { version = "1.0" }
 num-traits = { version = "0.2.14" }
 rustc-hash = "1.0"
-futures-core = { version = "0.3.5", optional = true }
-futures-task = { version = "0.3.5", optional = true }
-futures-util = { version = "0.3.5", optional = true }
+futures-util = { version = "0.3", optional = true, default-features = false, features = ["std"] }
 serde = { version = "1.0", optional = true }
 erased-serde = { version = "0.3", optional = true }
 serde-value = { version = "0.7", optional = true }
 parking_lot = { version = "0.12", optional = true }
 
-ffi = { package = "mlua-sys", version = "0.1.0", path = "mlua-sys" }
+ffi = { package = "mlua-sys", version = "0.3.0", path = "mlua-sys" }
 
 [dev-dependencies]
-rustyline = "11.0"
-criterion = { version = "0.4", features = ["html_reports", "async_tokio"] }
+rustyline = "12.0"
+criterion = { version = "0.5", features = ["async_tokio"] }
 trybuild = "1.0"
 futures = "0.3.5"
 hyper = { version = "0.14", features = ["client", "server"] }
 reqwest = { version = "0.11", features = ["json"] }
 tokio = { version = "1.0", features = ["full"] }
-futures-timer = "3.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 maplit = "1.0"

README.md

@@ -9,7 +9,7 @@
 [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.63+-brightgreen.svg?&logo=rust
+[MSRV]: https://img.shields.io/badge/rust-1.71+-brightgreen.svg?&logo=rust
 
 [Guided Tour] | [Benchmarks] | [FAQ]
 
@@ -20,6 +20,8 @@
 > **Note**
 >
 > Please see the [v0.8](https://github.com/khvzak/mlua/tree/v0.8) branch for the stable versions of `mlua` released to crates.io.
+>
+> v0.9 release notes can be found [here](docs/release_notes/v0.9.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.
@@ -45,6 +47,8 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 * `luajit`: activate [LuaJIT] support
 * `luajit52`: activate [LuaJIT] support with partial compatibility with Lua 5.2
 * `luau`: activate [Luau] support (auto vendored mode)
+* `luau-jit`: activate [Luau] support with experimental jit backend. This is unstable feature and not recommended to use.
+* `luau-vector4`: activate [Luau] support with 4-dimensional vector.
 * `vendored`: build static Lua(JIT) library from sources during `mlua` compilation using [lua-src] or [luajit-src] crates
 * `module`: enable module mode (building loadable `cdylib` library for Lua)
 * `async`: enable async/await support (any executor can be used, eg. [tokio] or [async-std])
@@ -96,12 +100,12 @@ You have to enable one of the features: `lua54`, `lua53`, `lua52`, `lua51`, `lua
 
 By default `mlua` uses `pkg-config` tool to find lua includes and libraries for the chosen Lua version.
 In most cases it works as desired, although sometimes could be more preferable to use a custom lua library.
-To achieve this, mlua supports `LUA_INC`, `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
+To achieve this, mlua supports `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
 `LUA_LINK` is optional and may be `dylib` (a dynamic library) or `static` (a static library, `.a` archive).
 
 An example how to use them:
 ``` sh
-my_project $ LUA_INC=$HOME/tmp/lua-5.2.4/src LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
+my_project $ LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
 ```
 
 `mlua` also supports vendored lua/luajit using the auxiliary crates [lua-src](https://crates.io/crates/lua-src) and
@@ -115,7 +119,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.8", features = ["lua54", "vendored"] }
+mlua = { version = "0.9.0-rc.2", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -150,7 +154,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.8", features = ["lua54", "vendored", "module"] }
+mlua = { version = "0.9.0-rc.2", features = ["lua54", "vendored", "module"] }
 ```
 
 `lib.rs` :
@@ -195,13 +199,11 @@ rustflags = [
 ]
 ```
 On Linux you can build modules normally with `cargo build --release`.
-Vendored and non-vendored builds are supported for these OS.
 
-On Windows `vendored` mode for modules is not supported since you need to link to a Lua dll.
-Easiest way is to use either MinGW64 (as part of [MSYS2](https://github.com/msys2/msys2) package) with `pkg-config` or
-MSVC with `LUA_INC` / `LUA_LIB` / `LUA_LIB_NAME` environment variables.
+On Windows the target module will be linked with `lua5x.dll` library (depending on your feature flags).
+Your main application should provide this library.
 
-More details about compiling and linking Lua modules can be found on the [Building Modules](http://lua-users.org/wiki/BuildingModules) page.
+Module builds don't require Lua lib or headers to be installed on the system.
 
 ### Publishing to luarocks.org
 

benches/benchmark.rs

@@ -264,17 +264,19 @@ fn call_userdata_method(c: &mut Criterion) {
 }
 
 fn call_async_userdata_method(c: &mut Criterion) {
-    #[derive(Clone, Copy)]
-    struct UserData(i64);
+    struct UserData(String);
+
     impl LuaUserData for UserData {
         fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_async_method("method", |_, this, ()| async move { Ok(this.0) });
+            methods.add_async_method("method", |_, this, ()| async move { Ok(this.0.clone()) });
         }
     }
 
     let options = LuaOptions::new().thread_pool_size(1024);
     let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
-    lua.globals().set("userdata", UserData(10)).unwrap();
+    lua.globals()
+        .set("userdata", UserData("hello".to_string()))
+        .unwrap();
 
     c.bench_function("call async [userdata method] 10", |b| {
         let rt = Runtime::new().unwrap();

docs/release_notes/v0.9.md

@@ -0,0 +1,364 @@
+## mlua v0.9 release notes
+
+The v0.9 version of mlua is a major release that includes a number of API changes and improvements. This release is a stepping stone towards the v1.0.
+This document highlights the most important changes. For a full list of changes, see the [CHANGELOG].
+
+[CHANGELOG]: https://github.com/khvzak/mlua/blob/master/CHANGELOG.md
+
+### New features
+
+#### 1. New Any UserData API
+
+This is a long awaited feature that allows to register in Lua foreign types that cannot implement `UserData` trait because of the Rust orphan rules.
+
+Now you can register any type that implements [`Any`] trait as a userdata type.
+
+Consider the following example:
+
+```rust
+lua.register_userdata_type::<std::string::String>(|reg| {
+    reg.add_method("len", |_, this, ()| Ok(this.len()));
+
+    reg.add_method_mut("push", |_, this, s: String| {
+        this.push_str(&s);
+        Ok(())
+    });
+
+    reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
+})?;
+
+let s = lua.create_any_userdata("hello".to_string())?;
+lua.load(chunk! {
+    print("s:len() is " .. $s:len())
+    $s:push(" world")
+    // Prints: hello, world
+    print($s)
+})
+.exec()?;
+```
+
+In this example we registered [`std::string::String`] as a userdata type with a set of methods and then created an instance of this type in Lua.
+
+It's _not_ required to register a type before using the `Lua::create_any_userdata()` method, instead an empty metatable will be created for you.
+You can also register the same type multiple times with different methods. Any previously created instances will share the old metatable, while new instances will have the new one.
+
+The new set of API is called `any_userdata` because it allows to register types that implements [`Any`] trait.
+
+[`std::string::String`]: https://doc.rust-lang.org/stable/std/string/struct.String.html
+[`Any`]: https://doc.rust-lang.org/stable/std/any/trait.Any.html
+
+#### 2. Scope support for the new any userdata types
+
+When you need to create non-static userdata instances in Lua, the usual way is use `Lua::scope()` helper to make them scoped. When out of scope, any scoped objects will be automatically
+dropped. The only downside of this approach is that every new instance will have a new metatable. This is not very fast if you need to create a lot of instances.
+
+With the new Any UserData API, you can place non-static references `&T` where `T: 'static` into a scope and they will share a single static metatable.
+
+```rust
+lua.register_userdata_type::<std::string::String>(|reg| {
+    reg.add_method_mut("replace", |_, this, (pat, to): (String, String)| {
+        *this = this.replace(&pat, &to);
+        Ok(())
+    });
+
+    reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
+})?;
+
+let mut s = "hello, world".to_string();
+
+lua.scope(|scope| {
+    // This userdata instance holds only a mutable reference to our string
+    let ud = scope.create_any_userdata_ref_mut(&mut s)?;
+    lua.load(chunk! {
+        $ud:replace("world", "user")
+    })
+    .exec()
+})?;
+
+// Prints: hello, user!
+println!("{s}!");
+```
+
+#### 3. Owned types (`unstable`)
+
+One of the common questions was how to embed a Lua type into Rust struct to use it later. It was non-trivial to do because of the `'lua` lifetime attached to every Lua value.
+
+In v0.9 mlua introduces "owned" types `OwnedTable`/`OwnedFunction`/`OwnedString`/`OwnedAnyUserData` that are `'static` (no lifetime attached).
+
+```rust
+let lua = Lua::new();
+
+struct MyStruct {
+    table: OwnedTable,
+    func: OwnedFunction,
+}
+
+let my_struct = MyStruct {
+    table: lua.globals().into_owned(),
+    func: lua
+        .create_function(|_, t: Table| Ok(format!("{t:#?}")))?
+        .into_owned(),
+};
+
+// It's safe to drop Lua!
+drop(lua);
+
+let result = my_struct.func.call::<_, String>(my_struct.table)?;
+println!("{result}");
+```
+
+Prior to v0.9, it was possible to do by creating a reference to the Lua value in registry using `Lua::create_registry_value()`
+and retrieving value later using `Lua::registry_value()` method.
+
+All owned handles hold a *strong* reference to the current Lua instance.
+Be warned, if you place them into a Lua type (eg. `UserData` or a Rust callback), it is *very easy*
+to accidentally cause reference cycles that would prevent destroying Lua instance.
+
+Please note this functionality is available under the `unstable` feature flag and not available when the `send` feature is enabled.
+
+#### New ffi module
+
+In v0.9 release the internal `ffi` module has been moved into the new [`mlua-sys`] crate and became available for public use.
+This crate provides unified Lua FFI API (targeting Lua 5.4) using a (limited) compatibility layer for older versions.
+
+mlua re-exports the `ffi` module aliasing the `mlua-sys` crate and provides (unsafe) functionality to work with raw Lua state:
+
+```rust
+unsafe {
+    unsafe extern "C-unwind" fn lua_add(state: *mut mlua::lua_State) -> i32 {
+        let a = mlua::ffi::luaL_checkinteger(state, 1);
+        let b = mlua::ffi::luaL_checkinteger(state, 2);
+        mlua::ffi::lua_pushinteger(state, a + b);
+        1
+    }
+
+    let add = lua.create_c_function(lua_add)?;
+    assert_eq!(add.call::<_, i32>((2, 3))?, 5);
+}
+```
+
+[`mlua-sys`]: https://crates.io/crates/mlua-sys
+
+#### Luau JIT support
+
+mlua brings support for the new experimental [Luau] JIT backend under the `luau-jit` feature flag. This backend is still under development and not yet ready for production use.
+
+To enable it, just call `lua.enable_jit(true)` before loading Lua code. mlua will automatically trigger JIT compilation for new Lua chunks.
+
+When calling this function with `false` argument, mlua will disable JIT compilation but any previously compiled chunks will remain JIT-compiled.
+
+[Luau]: https://luau-lang.org
+
+### Improvements
+
+#### 1. Better error reporting
+
+When calling a Rust function from Lua and passing wrong arguments, previous mlua versions reported a error message without any context or reference to the particular argument.
+
+In v0.9 it reports a error message with the argument index and expected type:
+
+```rust
+let func = lua.create_function(|_, _a: i32| Ok(()))?;
+lua.load(chunk! {
+    local ok, err = pcall($func, "not a number")
+    // Prints: bad argument #1: error converting Lua string to i32 (expected number or string coercible to number)
+    print(err)
+})
+.exec()?;
+```
+
+Similar changes have been made for userdata functions and methods:
+
+```rust
+lua.register_userdata_type::<&'static str>(|reg| {
+    reg.add_method("len", |_, this, ()| Ok(this.len()));
+})?;
+
+let s = lua.create_any_userdata("hello")?;
+lua.load(chunk! {
+    local ok, err = pcall($s.len, 123)
+    // Prints: bad argument `self` to `&str.len`: error converting Lua integer to userdata
+    print(err)
+})
+.exec()?;
+```
+
+#### 2. Error context
+
+Similar to the [`anyhow`] Error type, now it's possible to attach context to Lua errors:
+
+```rust
+let read = lua.create_function(|lua, path: String| {
+    let bytes = std::fs::read(&path)
+        .into_lua_err()
+        .context(format!("Failed to open `{path}`"))?;
+    Ok(lua.create_string(bytes))
+})?;
+
+lua.load(chunk! {
+    local ok, err = pcall($read, "/nonexistent")
+    print(err)
+})
+.exec()?;
+
+Prints:
+```text
+Failed to open /nonexistent
+No such file or directory (os error 2)
+stack traceback:
+...
+```
+
+[`anyhow`]: https://crates.io/crates/anyhow
+
+#### 4. New methods `Function::wrap`/`AnyUserData::wrap`
+
+Sometimes it's useful to have `IntoLua` trait implementation for a Rust function or type `T: Any` without needing to call `Lua::create_function()`/`Lua::create_any_userdata()` methods.
+Since v0.9 you can call the new methods `Function::wrap()`/`AnyUserData::wrap()` that allows to do this. They return an abstract type that `impl IntoLua`:
+
+```rust
+lua.globals().set("print_rust", Function::wrap(|_, s: String| Ok(println!("{}", s))))?;
+lua.globals().set("rust_ud", AnyUserData::wrap("hello"))?;
+```
+
+In addition there are also `Function::wrap_mut()`/`Function::wrap_async()` methods that allow to wrap mutable and async functions respectively.
+
+For a `T: 'UserData + 'static` the `IntoLua` trait is still always implemented.
+
+#### `UserDataRef` and `UserDataRefMut` type wrappers
+
+The new wrappers `UserDataRef` and `UserDataRefMut` are receivers for userdata type `T` and borrow underlying instance for the lifetime of the wrapper.
+
+```rust
+lua.globals()
+    .set("ud", AnyUserData::wrap("hello".to_string()))?;
+
+let mut ud_mut: UserDataRefMut<String> = lua.globals().get("ud")?;
+ud_mut.push_str(", Rust");
+drop(ud_mut);
+
+let ud_ref: UserDataRef<String> = lua.globals().get("ud")?;
+// Prints: hello, Rust
+println!("{}", *ud_ref);
+```
+
+In the previous mlua versions the same functionality can be achieved by receiving `AnyUserData` and calling `AnyUserData::borrow()`/`AnyUserData::borrow_mut()` methods.
+
+The new wrappers are identical to Rust [`Ref`]/[`RefMut`] types.
+
+[`Ref`]: https://doc.rust-lang.org/std/cell/struct.Ref.html
+[`RefMut`]: https://doc.rust-lang.org/std/cell/struct.RefMut.html
+
+#### New `AnyUserDataExt` trait
+
+Similar to the `TableExt` trait, the `AnyUserDataExt` provides a set of extra methods for the `AnyUserData` type.
+
+1) `AnyUserDataExt::get()/set()` to get/set a value by key from the userdata, assuming it has `__index` metamethod.
+
+2) `AnyUserDataExt::call()` to call the userdata as a function assuming it has `__call` metamethod.
+
+3) `AnyUserData::call_method(name, ...)` to call the userdata method, assuming it has `__index` metamethod and the associated function.
+
+#### Pretty formatting Lua values
+
+`mlua::Value` implements a new format `:#?` that allows to (recursively) pretty print Lua values:
+
+```rust
+println!("{:#?}", lua.globals());
+```
+
+Prints:
+```
+{
+  ["_G"] = table: 0x7fa2d0706260,
+  ["_VERSION"] = "Lua 5.4",
+  ["assert"] = function: 0x10451d11d,
+  ["collectgarbage"] = function: 0x10451d198,
+  ["coroutine"] = {
+    ["close"] = function: 0x10451e28f,
+    ...
+  },
+  ["dofile"] = function: 0x10451d37c,
+  ...
+}
+```
+
+In addition a new method `Value::to_string()` has been added to convert `Value` to a string (using `__tostring` metamethod if available).
+
+#### Environment for Lua functions
+
+Any Lua functions have an associated environment table that is used to resolve global variables. By default it sets to a Lua globals table.
+
+In the new release it's possible to get or update a function environment using `Function::environment()` or `Function::set_environment()` methods respectively.
+
+```rust
+let f = lua.load("return a").into_function()?;
+
+assert_eq!(f.environment(), Some(lua.globals()));
+
+lua.globals().set("a", 1)?;
+assert_eq!(f.call::<_, i32>(())?, 1);
+
+f.set_environment(lua.create_table_from([("a", "hello")])?)?;
+assert_eq!(f.call::<_, mlua::String>(())?, "hello");
+```
+
+#### Performance optimizations
+
+The new mlua version has a number of performance improvements. Please check the [benchmarks results] to see how mlua compares to rlua and rhai.
+
+[benchmarks results]: https://github.com/khvzak/script-bench-rs
+
+### Changes in `module` mode
+
+#### New attributes
+
+The `lua_module` macro now support the following attributes:
+
+- `name=...` - sets name of the module (defaults to the name of the function).
+
+Eg.:
+
+```rust
+#[mlua::lua_module(name = "alt_module")]
+fn my_module(lua: &Lua) -> LuaResult<LuaTable> {
+    lua.create_table()
+}
+```
+
+Under the hood a new function `luaopen_alt_module` will be created for the Lua module loader.
+
+- `skip_memory_check` - skip memory allocation checks for some operations.
+
+In module mode, mlua runs in unknown environment and cannot say are there any memory limits or not. As result, some operations that require memory allocation runs in
+protected mode. Setting this attribute will improve performance of such operations with risk of having uncaught exceptions and memory leaks.
+
+#### Improved Windows target
+
+In previous mlua versions, building a Lua module for Windows requires having Lua development libraries installed on the system.
+In contrast, on Linux and macOS, modules can be built without any external dependencies using the `-undefined=dynamic_lookup` linker flag.
+
+With Rust 1.71+ it's now possible to lift this restriction for Windows as well. You can build modules normally and they will be linked with
+`lua54.dll`/`lua53.dll`/`lua52.dll`/`lua51.dll` depending on the enabled Lua version.
+
+You still need to have the dll although, linked to application where the module will be loaded.
+
+### Breaking changes
+
+1) `ToLua`/`ToLuaMulti` traits have been renamed to `IntoLua`/`IntoLuaMulti` respectively (with the methods called `into_lua`/`into_lua_multi`).
+
+The main reason for this change is following the Rust self [convention](https://rust-lang.github.io/rust-clippy/master/index.html#/wrong_self_convention).
+
+2) Removed `FromLua` implementation for `T: UserData + Clone`.
+
+During the usage of mlua, it was found that this implementation is not very useful and prevents custom `FromLua` implementations for `T: UserData`.
+It should be a developer decision to opt-in `FromLua` for their `T` if needed rather than having enabled it unconditionally.
+
+To opt-in `FromLua` for `T: Clone` you can use a simple `#[derive(FromLua)]` macro (requires `feature = "macros"`):
+
+```rust
+#[derive(Clone, Copy, mlua::FromLua)]
+struct MyUserData(i32);
+```
+
+`T` is not required to implement `UserData` because of the new relaxed restrictions on userdata types.

examples/async_http_client.rs

@@ -3,14 +3,13 @@ use std::collections::HashMap;
 use hyper::body::{Body as HyperBody, HttpBody as _};
 use hyper::Client as HyperClient;
 
-use mlua::{chunk, AnyUserData, ExternalResult, Lua, Result, UserData, UserDataMethods};
+use mlua::{chunk, ExternalResult, Lua, Result, UserData, UserDataMethods};
 
 struct BodyReader(HyperBody);
 
 impl UserData for BodyReader {
     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_function("read", |lua, reader: AnyUserData| async move {
-            let mut reader = reader.borrow_mut::<Self>()?;
+        methods.add_async_method_mut("read", |lua, reader, ()| async move {
             if let Some(bytes) = reader.0.data().await {
                 let bytes = bytes.into_lua_err()?;
                 return Some(lua.create_string(&bytes)).transpose();

examples/async_tcp_server.rs

@@ -6,9 +6,7 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::task;
 
-use mlua::{
-    chunk, AnyUserData, Function, Lua, RegistryKey, String as LuaString, UserData, UserDataMethods,
-};
+use mlua::{chunk, Function, Lua, RegistryKey, String as LuaString, UserData, UserDataMethods};
 
 struct LuaTcpStream(TcpStream);
 
@@ -18,28 +16,19 @@ impl UserData for LuaTcpStream {
             Ok(this.0.peer_addr()?.to_string())
         });
 
-        methods.add_async_function(
-            "read",
-            |lua, (this, size): (AnyUserData, usize)| async move {
-                let mut this = this.borrow_mut::<Self>()?;
-                let mut buf = vec![0; size];
-                let n = this.0.read(&mut buf).await?;
-                buf.truncate(n);
-                lua.create_string(&buf)
-            },
-        );
+        methods.add_async_method_mut("read", |lua, this, size| async move {
+            let mut buf = vec![0; size];
+            let n = this.0.read(&mut buf).await?;
+            buf.truncate(n);
+            lua.create_string(&buf)
+        });
 
-        methods.add_async_function(
-            "write",
-            |_, (this, data): (AnyUserData, LuaString)| async move {
-                let mut this = this.borrow_mut::<Self>()?;
-                let n = this.0.write(&data.as_bytes()).await?;
-                Ok(n)
-            },
-        );
+        methods.add_async_method_mut("write", |_, this, data: LuaString| async move {
+            let n = this.0.write(&data.as_bytes()).await?;
+            Ok(n)
+        });
 
-        methods.add_async_function("close", |_, this: AnyUserData| async move {
-            let mut this = this.borrow_mut::<Self>()?;
+        methods.add_async_method_mut("close", |_, this, ()| async move {
             this.0.shutdown().await?;
             Ok(())
         });

examples/repl.rs

@@ -1,11 +1,11 @@
 //! This example shows a simple read-evaluate-print-loop (REPL).
 
 use mlua::{Error, Lua, MultiValue};
-use rustyline::Editor;
+use rustyline::DefaultEditor;
 
 fn main() {
     let lua = Lua::new();
-    let mut editor = Editor::<(), _>::new().expect("Failed to make rustyline editor");
+    let mut editor = DefaultEditor::new().expect("Failed to create editor");
 
     loop {
         let mut prompt = "> ";
@@ -24,7 +24,7 @@ fn main() {
                         "{}",
                         values
                             .iter()
-                            .map(|value| format!("{:?}", value))
+                            .map(|value| format!("{:#?}", value))
                             .collect::<Vec<_>>()
                             .join("\t")
                     );

mlua-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua-sys"
-version = "0.1.1"
+version = "0.3.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 edition = "2021"
 repository = "https://github.com/khvzak/mlua"
@@ -26,6 +26,8 @@ lua51 = []
 luajit = []
 luajit52 = ["luajit"]
 luau = ["luau0-src"]
+luau-codegen = ["luau"]
+luau-vector4 = ["luau"]
 vendored = ["lua-src", "luajit-src"]
 module = []
 
@@ -35,6 +37,6 @@ module = []
 cc = "1.0"
 cfg-if = "1.0"
 pkg-config = "0.3.17"
-lua-src = { version = ">= 544.0.0, < 550.0.0", optional = true }
-luajit-src = { version = ">= 210.4.0, < 220.0.0", optional = true }
-luau0-src = { version = "0.5.6", optional = true }
+lua-src = { version = ">= 546.0.0, < 546.1.0", optional = true }
+luajit-src = { version = ">= 210.4.6, < 210.6.0", optional = true }
+luau0-src = { version = "0.5.11", optional = true }

mlua-sys/build/find_normal.rs

@@ -2,92 +2,51 @@
 
 use std::env;
 use std::ops::Bound;
-use std::path::PathBuf;
 
-fn get_env_var(name: &str) -> String {
-    match env::var(name) {
-        Ok(val) => val,
-        Err(env::VarError::NotPresent) => String::new(),
-        Err(err) => panic!("cannot get {name}: {err}"),
-    }
-}
+pub fn probe_lua() {
+    let lib_dir = env::var("LUA_LIB").unwrap_or_default();
+    let lua_lib = env::var("LUA_LIB_NAME").unwrap_or_default();
 
-pub fn probe_lua() -> Option<PathBuf> {
-    let include_dir = get_env_var("LUA_INC");
-    let lib_dir = get_env_var("LUA_LIB");
-    let lua_lib = get_env_var("LUA_LIB_NAME");
-
-    println!("cargo:rerun-if-env-changed=LUA_INC");
     println!("cargo:rerun-if-env-changed=LUA_LIB");
     println!("cargo:rerun-if-env-changed=LUA_LIB_NAME");
     println!("cargo:rerun-if-env-changed=LUA_LINK");
 
-    let need_lua_lib = cfg!(any(not(feature = "module"), target_os = "windows"));
-
-    if !include_dir.is_empty() {
-        if need_lua_lib {
-            if lib_dir.is_empty() {
-                panic!("LUA_LIB is not set");
-            }
-            if lua_lib.is_empty() {
-                panic!("LUA_LIB_NAME is not set");
-            }
-
-            let mut link_lib = "";
-            if get_env_var("LUA_LINK") == "static" {
-                link_lib = "static=";
-            };
+    if !lua_lib.is_empty() {
+        if !lib_dir.is_empty() {
             println!("cargo:rustc-link-search=native={lib_dir}");
-            println!("cargo:rustc-link-lib={link_lib}{lua_lib}");
         }
-        return Some(PathBuf::from(include_dir));
+        let mut link_lib = "";
+        if env::var("LUA_LINK").as_deref() == Ok("static") {
+            link_lib = "static=";
+        };
+        println!("cargo:rustc-link-lib={link_lib}{lua_lib}");
+        return;
     }
 
     // Find using `pkg-config`
 
     #[cfg(feature = "lua54")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", "lua5.4", "5.4");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", Some("lua5.4"), "5.4");
     #[cfg(feature = "lua53")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", "lua5.3", "5.3");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", Some("lua5.3"), "5.3");
     #[cfg(feature = "lua52")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", "lua5.2", "5.2");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", Some("lua5.2"), "5.2");
     #[cfg(feature = "lua51")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", "lua5.1", "5.1");
-
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51"
-    ))]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included(incl_bound), Bound::Excluded(excl_bound)))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe(alt_probe);
-        }
-
-        lua.unwrap_or_else(|_| panic!("cannot find Lua {ver} using `pkg-config`"))
-            .include_paths
-            .get(0)
-            .cloned()
-    }
-
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", Some("lua5.1"), "5.1");
     #[cfg(feature = "luajit")]
-    {
-        let lua = pkg_config::Config::new()
-            .range_version((Bound::Included("2.0.4"), Bound::Unbounded))
-            .cargo_metadata(need_lua_lib)
-            .probe("luajit");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("2.0.4", "2.2", None, "JIT");
 
-        lua.expect("cannot find LuaJIT using `pkg-config`")
-            .include_paths
-            .get(0)
-            .cloned()
+    #[rustfmt::skip]
+    let mut lua = pkg_config::Config::new()
+        .range_version((Bound::Included(incl_bound), Bound::Excluded(excl_bound)))
+        .cargo_metadata(true)
+        .probe(if cfg!(feature = "luajit") { "luajit" } else { "lua" });
+
+    if lua.is_err() && alt_probe.is_some() {
+        lua = pkg_config::Config::new()
+            .cargo_metadata(true)
+            .probe(alt_probe.unwrap());
     }
+
+    lua.unwrap_or_else(|err| panic!("cannot find Lua{ver} using `pkg-config`: {err}"));
 }

mlua-sys/build/find_vendored.rs

@@ -1,28 +1,28 @@
 #![allow(dead_code)]
 
-use std::path::PathBuf;
-
-pub fn probe_lua() -> Option<PathBuf> {
+pub fn probe_lua() {
     #[cfg(feature = "lua54")]
     let artifacts = lua_src::Build::new().build(lua_src::Lua54);
+
     #[cfg(feature = "lua53")]
     let artifacts = lua_src::Build::new().build(lua_src::Lua53);
+
     #[cfg(feature = "lua52")]
     let artifacts = lua_src::Build::new().build(lua_src::Lua52);
+
     #[cfg(feature = "lua51")]
     let artifacts = lua_src::Build::new().build(lua_src::Lua51);
+
     #[cfg(feature = "luajit")]
-    let artifacts = {
-        let mut builder = luajit_src::Build::new();
-        if cfg!(feature = "luajit52") {
-            builder.lua52compat(true);
-        }
-        builder.build()
-    };
+    let artifacts = luajit_src::Build::new()
+        .lua52compat(cfg!(feature = "luajit52"))
+        .build();
+
     #[cfg(feature = "luau")]
-    let artifacts = luau0_src::Build::new().build();
+    let artifacts = luau0_src::Build::new()
+        .enable_codegen(cfg!(feature = "luau-codegen"))
+        .set_vector_size(if cfg!(feature = "luau-vector4") { 4 } else { 3 })
+        .build();
 
     artifacts.print_cargo_metadata();
-
-    Some(artifacts.include_dir().to_owned())
 }

mlua-sys/build/main_inner.rs

@@ -9,18 +9,25 @@ cfg_if::cfg_if! {
 }
 
 fn main() {
-    // We don't support "vendored module" mode on windows
-    #[cfg(all(feature = "vendored", feature = "module", target_os = "windows"))]
-    compile_error!(
-        "Vendored (static) builds are not supported for modules on Windows.\n"
-            + "Please, use `pkg-config` or custom mode to link to a Lua dll."
-    );
-
     #[cfg(all(feature = "luau", feature = "module"))]
-    compile_error!("Luau does not support module mode");
+    compile_error!("Luau does not support `module` mode");
 
-    #[cfg(any(not(feature = "module"), target_os = "windows"))]
-    find::probe_lua();
+    #[cfg(all(feature = "module", feature = "vendored"))]
+    compile_error!("`vendored` and `module` features are mutually exclusive");
 
     println!("cargo:rerun-if-changed=build");
+
+    #[cfg(windows)]
+    if 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");
+    }
+
+    #[cfg(not(feature = "module"))]
+    find::probe_lua();
 }

mlua-sys/src/lib.rs

@@ -26,14 +26,10 @@ pub use luau::*;
 #[doc(hidden)]
 pub const LUA_MAX_UPVALUES: c_int = 255;
 
-#[cfg(any(feature = "lua51", all(feature = "luajit", not(feature = "vendored"))))]
+#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[doc(hidden)]
 pub const LUA_MAX_UPVALUES: c_int = 60;
 
-#[cfg(all(feature = "luajit", feature = "vendored"))]
-#[doc(hidden)]
-pub const LUA_MAX_UPVALUES: c_int = 120;
-
 #[cfg(feature = "luau")]
 #[doc(hidden)]
 pub const LUA_MAX_UPVALUES: c_int = 200;
@@ -46,7 +42,7 @@ pub const LUA_TRACEBACK_STACK: c_int = 11;
 // The minimum alignment guaranteed by the architecture. This value is used to
 // add fast paths for low alignment values.
 // Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/common/alloc.rs
-#[cfg(all(any(
+#[cfg(any(
     target_arch = "x86",
     target_arch = "arm",
     target_arch = "mips",
@@ -58,10 +54,10 @@ pub const LUA_TRACEBACK_STACK: c_int = 11;
     target_arch = "hexagon",
     all(target_arch = "riscv32", not(target_os = "espidf")),
     all(target_arch = "xtensa", not(target_os = "espidf")),
-)))]
+))]
 #[doc(hidden)]
 pub const SYS_MIN_ALIGN: usize = 8;
-#[cfg(all(any(
+#[cfg(any(
     target_arch = "x86_64",
     target_arch = "aarch64",
     target_arch = "mips64",
@@ -69,14 +65,14 @@ pub const SYS_MIN_ALIGN: usize = 8;
     target_arch = "sparc64",
     target_arch = "riscv64",
     target_arch = "wasm64",
-)))]
+))]
 #[doc(hidden)]
 pub const SYS_MIN_ALIGN: usize = 16;
 // The allocator on the esp-idf platform guarentees 4 byte alignment.
-#[cfg(all(any(
+#[cfg(any(
     all(target_arch = "riscv32", target_os = "espidf"),
     all(target_arch = "xtensa", target_os = "espidf"),
-)))]
+))]
 #[doc(hidden)]
 pub const SYS_MIN_ALIGN: usize = 4;
 

mlua-sys/src/lua51/compat.rs

@@ -486,10 +486,10 @@ pub unsafe fn luaL_traceback(
     lua_concat(L, lua_gettop(L) - top);
 }
 
-pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
             LUA_TNIL => {
                 lua_pushliteral(L, "nil");
             }
@@ -503,7 +503,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                     lua_pushliteral(L, "true");
                 }
             }
-            _ => {
+            t => {
                 let tt = luaL_getmetafield(L, idx, cstr!("__name"));
                 let name = if tt == LUA_TSTRING {
                     lua_tostring(L, -1)
@@ -512,7 +512,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                 };
                 lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                 if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__name'
                 }
             }
         };

mlua-sys/src/lua51/lauxlib.rs

@@ -14,7 +14,8 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
     #[link_name = "luaL_getmetafield"]
     pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -56,7 +57,8 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 

mlua-sys/src/lua51/lua.rs

@@ -73,23 +73,23 @@ pub type lua_Integer = i32;
 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;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
 /// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // State manipulation
     //
@@ -97,9 +97,6 @@ extern "C" {
     pub fn lua_close(L: *mut lua_State);
     pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
 
-    #[cfg(all(feature = "luajit", feature = "vendored"))]
-    pub fn lua_resetthread(L: *mut lua_State, th: *mut lua_State);
-
     pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
 
     //
@@ -221,14 +218,16 @@ pub const LUA_GCSTEP: c_int = 5;
 pub const LUA_GCSETPAUSE: c_int = 6;
 pub const LUA_GCSETSTEPMUL: c_int = 7;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
 //
 // Miscellaneous functions
 //
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_error(L: *mut lua_State) -> !;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
@@ -351,9 +350,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;

mlua-sys/src/lua51/lualib.rs

@@ -20,7 +20,8 @@ pub const LUA_JITLIBNAME: &str = "jit";
 #[cfg(feature = "luajit")]
 pub const LUA_FFILIBNAME: &str = "ffi";
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaopen_base(L: *mut lua_State) -> c_int;
     pub fn luaopen_table(L: *mut lua_State) -> c_int;
     pub fn luaopen_io(L: *mut lua_State) -> c_int;

mlua-sys/src/lua52/compat.rs

@@ -205,10 +205,10 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
     }
 }
 
-pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
             LUA_TNIL => {
                 lua_pushliteral(L, "nil");
             }
@@ -222,7 +222,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                     lua_pushliteral(L, "true");
                 }
             }
-            _ => {
+            t => {
                 let tt = luaL_getmetafield(L, idx, cstr!("__name"));
                 let name = if tt == LUA_TSTRING {
                     lua_tostring(L, -1)
@@ -231,7 +231,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                 };
                 lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                 if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__name'
                 }
             }
         };

mlua-sys/src/lua52/lauxlib.rs

@@ -14,7 +14,8 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);
 
     #[link_name = "luaL_getmetafield"]
@@ -65,7 +66,8 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
@@ -78,7 +80,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
     luaL_loadfilex(L, f, ptr::null())
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_loadbufferx(
         L: *mut lua_State,
         buff: *const c_char,

mlua-sys/src/lua52/lua.rs

@@ -78,23 +78,23 @@ pub type lua_Integer = i64;
 pub type lua_Unsigned = c_uint;
 
 /// 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;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
 /// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // State manipulation
     //
@@ -155,20 +155,19 @@ pub const LUA_OPMOD: c_int = 4;
 pub const LUA_OPPOW: c_int = 5;
 pub const LUA_OPUNM: c_int = 6;
 
-extern "C" {
-    pub fn lua_arith(L: *mut lua_State, op: c_int);
-}
-
 pub const LUA_OPEQ: c_int = 0;
 pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
     pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
     pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Push functions (C -> stack)
     //
@@ -262,7 +261,8 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
     lua_pcallk(L, n, r, f, 0, None)
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Coroutine functions
     //
@@ -298,11 +298,13 @@ pub const LUA_GCISRUNNING: c_int = 9;
 pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Miscellaneous functions
     //
@@ -437,9 +439,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;

mlua-sys/src/lua52/lualib.rs

@@ -14,7 +14,8 @@ pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
 pub const LUA_LOADLIBNAME: &str = "package";
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaopen_base(L: *mut lua_State) -> c_int;
     pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
     pub fn luaopen_table(L: *mut lua_State) -> c_int;

mlua-sys/src/lua53/lauxlib.rs

@@ -20,12 +20,14 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
 
     pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
     pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
-    pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    #[link_name = "luaL_tolstring"]
+    pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
     pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
     pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
     pub fn luaL_optlstring(
@@ -66,7 +68,8 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
@@ -79,7 +82,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
     luaL_loadfilex(L, f, ptr::null())
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_loadbufferx(
         L: *mut lua_State,
         buff: *const c_char,
@@ -167,6 +171,11 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
     lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
 }
 
+#[inline(always)]
+pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+    luaL_tolstring_(L, lua::lua_absindex(L, idx), len)
+}
+
 // luaL_opt would be implemented here but it is undocumented, so it's omitted
 
 #[inline(always)]

mlua-sys/src/lua53/lua.rs

@@ -82,27 +82,27 @@ pub type lua_Unsigned = u64;
 pub type lua_KContext = isize;
 
 /// 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;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 /// Type for continuation functions
 pub type lua_KFunction =
-    unsafe extern "C" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
 /// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // State manipulation
     //
@@ -167,20 +167,19 @@ pub const LUA_OPSHR: c_int = 11;
 pub const LUA_OPUNM: c_int = 12;
 pub const LUA_OPBNOT: c_int = 13;
 
-extern "C" {
-    pub fn lua_arith(L: *mut lua_State, op: c_int);
-}
-
 pub const LUA_OPEQ: c_int = 0;
 pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
     pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
     pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Push functions (C -> stack)
     //
@@ -270,7 +269,8 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
     lua_pcallk(L, n, r, f, 0, None)
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Coroutine functions
     //
@@ -304,11 +304,13 @@ pub const LUA_GCSETPAUSE: c_int = 6;
 pub const LUA_GCSETSTEPMUL: c_int = 7;
 pub const LUA_GCISRUNNING: c_int = 9;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Miscellaneous functions
     //
@@ -461,9 +463,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;

mlua-sys/src/lua53/lualib.rs

@@ -15,7 +15,8 @@ pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
 pub const LUA_LOADLIBNAME: &str = "package";
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaopen_base(L: *mut lua_State) -> c_int;
     pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
     pub fn luaopen_table(L: *mut lua_State) -> c_int;

mlua-sys/src/lua54/lauxlib.rs

@@ -20,7 +20,8 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
 
     pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -66,7 +67,8 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
@@ -79,7 +81,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
     luaL_loadfilex(L, f, ptr::null())
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaL_loadbufferx(
         L: *mut lua_State,
         buff: *const c_char,

mlua-sys/src/lua54/lua.rs

@@ -81,38 +81,41 @@ pub type lua_Unsigned = u64;
 pub type lua_KContext = isize;
 
 /// 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;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 /// Type for continuation functions
 pub type lua_KFunction =
-    unsafe extern "C" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
 /// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
 /// Type for warning functions
 pub type lua_WarnFunction =
-    unsafe extern "C" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
+    unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // State manipulation
     //
     pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
     pub fn lua_close(L: *mut lua_State);
     pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+    // Deprecated in Lua 5.4.6
     pub fn lua_resetthread(L: *mut lua_State) -> c_int;
+    #[cfg(feature = "vendored")]
+    pub fn lua_closethread(L: *mut lua_State, from: *mut lua_State) -> c_int;
 
     pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
 
@@ -171,20 +174,19 @@ pub const LUA_OPSHR: c_int = 11;
 pub const LUA_OPUNM: c_int = 12;
 pub const LUA_OPBNOT: c_int = 13;
 
-extern "C" {
-    pub fn lua_arith(L: *mut lua_State, op: c_int);
-}
-
 pub const LUA_OPEQ: c_int = 0;
 pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
     pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
     pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Push functions (C -> stack)
     //
@@ -274,7 +276,8 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
     lua_pcallk(L, n, r, f, 0, None)
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Coroutine functions
     //
@@ -302,7 +305,8 @@ pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
 //
 // Warning-related functions
 //
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_setwarnf(L: *mut lua_State, f: Option<lua_WarnFunction>, ud: *mut c_void);
     pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
 }
@@ -322,11 +326,13 @@ pub const LUA_GCISRUNNING: c_int = 9;
 pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     //
     // Miscellaneous functions
     //
@@ -497,9 +503,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;

mlua-sys/src/lua54/lualib.rs

@@ -14,7 +14,8 @@ pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
 pub const LUA_LOADLIBNAME: &str = "package";
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
     pub fn luaopen_base(L: *mut lua_State) -> c_int;
     pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
     pub fn luaopen_table(L: *mut lua_State) -> c_int;

mlua-sys/src/luau/compat.rs

@@ -323,7 +323,7 @@ pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char)
 pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int {
     if luaL_newmetatable_(L, tname) != 0 {
         lua_pushstring(L, tname);
-        lua_setfield(L, -2, cstr!("__name"));
+        lua_setfield(L, -2, cstr!("__type"));
         1
     } else {
         0
@@ -341,7 +341,7 @@ pub unsafe fn luaL_loadbufferx(
         fn free(p: *mut c_void);
     }
 
-    let chunk_is_text = size == 0 || (*data as u8) >= b'\n';
+    let chunk_is_text = size == 0 || (*data as u8) >= b'\t';
     if !mode.is_null() {
         let modeb = CStr::from_ptr(mode).to_bytes();
         if !chunk_is_text && !modeb.contains(&b'b') {
@@ -436,10 +436,10 @@ pub unsafe fn luaL_traceback(
     lua_concat(L, lua_gettop(L) - top);
 }
 
-pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
             LUA_TNIL => {
                 lua_pushliteral(L, "nil");
             }
@@ -453,8 +453,8 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                     lua_pushliteral(L, "true");
                 }
             }
-            _ => {
-                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
+            t => {
+                let tt = luaL_getmetafield(L, idx, cstr!("__type"));
                 let name = if tt == LUA_TSTRING {
                     lua_tostring(L, -1)
                 } else {
@@ -462,7 +462,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                 };
                 lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                 if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__type'
                 }
             }
         };

mlua-sys/src/luau/lauxlib.rs

@@ -13,7 +13,7 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+extern "C-unwind" {
     pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
     #[link_name = "luaL_getmetafield"]
     pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;

mlua-sys/src/luau/lua.rs

@@ -69,22 +69,27 @@ pub type lua_Integer = c_int;
 pub type lua_Unsigned = c_uint;
 
 /// 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;
-pub type lua_Continuation = unsafe extern "C" fn(L: *mut lua_State, status: c_int) -> c_int;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
+pub type lua_Continuation = unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int) -> c_int;
 
 /// Type for userdata destructor functions.
-pub type lua_Udestructor = unsafe extern "C" fn(*mut c_void);
-pub type lua_Destructor = unsafe extern "C" fn(L: *mut lua_State, *mut c_void);
+pub type lua_Udestructor = unsafe extern "C-unwind" fn(*mut c_void);
+pub type lua_Destructor = unsafe extern "C-unwind" fn(L: *mut lua_State, *mut c_void);
 
 /// Type for memory-allocation functions.
-pub type lua_Alloc = unsafe extern "C" fn(
+pub type lua_Alloc = unsafe extern "C-unwind" fn(
     ud: *mut c_void,
     ptr: *mut c_void,
     osize: usize,
     nsize: usize,
 ) -> *mut c_void;
 
-extern "C" {
+/// Returns Luau release version (eg. `0.xxx`).
+pub const fn luau_version() -> Option<&'static str> {
+    option_env!("LUAU_VERSION")
+}
+
+extern "C-unwind" {
     //
     // State manipulation
     //
@@ -151,7 +156,10 @@ extern "C" {
     pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
     pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
     pub fn lua_pushunsigned(L: *mut lua_State, n: lua_Unsigned);
+    #[cfg(not(feature = "luau-vector4"))]
     pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float);
+    #[cfg(feature = "luau-vector4")]
+    pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float, w: c_float);
     #[link_name = "lua_pushlstring"]
     pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize);
     #[link_name = "lua_pushstring"]
@@ -243,14 +251,14 @@ pub const LUA_GCSETGOAL: c_int = 7;
 pub const LUA_GCSETSTEPMUL: c_int = 8;
 pub const LUA_GCSETSTEPSIZE: c_int = 9;
 
-extern "C" {
+extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
 //
 // Memory statistics
 //
-extern "C" {
+extern "C-unwind" {
     pub fn lua_setmemcat(L: *mut lua_State, category: c_int);
     pub fn lua_totalbytes(L: *mut lua_State, category: c_int) -> usize;
 }
@@ -258,7 +266,7 @@ extern "C" {
 //
 // Miscellaneous functions
 //
-extern "C" {
+extern "C-unwind" {
     pub fn lua_error(L: *mut lua_State) -> !;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_rawiter(L: *mut lua_State, idx: c_int, iter: c_int) -> c_int;
@@ -278,7 +286,7 @@ extern "C" {
 pub const LUA_NOREF: c_int = -1;
 pub const LUA_REFNIL: c_int = 0;
 
-extern "C" {
+extern "C-unwind" {
     pub fn lua_ref(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_unref(L: *mut lua_State, r#ref: c_int);
 }
@@ -415,9 +423,9 @@ pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
 const LUA_IDSIZE: usize = 256;
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-pub type lua_Coverage = unsafe extern "C" fn(
+pub type lua_Coverage = unsafe extern "C-unwind" fn(
     context: *mut c_void,
     function: *const c_char,
     linedefined: c_int,
@@ -426,7 +434,7 @@ pub type lua_Coverage = unsafe extern "C" fn(
     size: usize,
 );
 
-extern "C" {
+extern "C-unwind" {
     pub fn lua_stackdepth(L: *mut lua_State) -> c_int;
     pub fn lua_getinfo(
         L: *mut lua_State,
@@ -484,23 +492,23 @@ pub struct lua_Callbacks {
     pub userdata: *mut c_void,
 
     /// gets called at safepoints (loop back edges, call/ret, gc) if set
-    pub interrupt: Option<unsafe extern "C" fn(L: *mut lua_State, gc: c_int)>,
+    pub interrupt: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, gc: c_int)>,
     /// gets called when an unprotected error is raised (if longjmp is used)
-    pub panic: Option<unsafe extern "C" fn(L: *mut lua_State, errcode: c_int)>,
+    pub panic: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, errcode: c_int)>,
 
     /// gets called when L is created (LP == parent) or destroyed (LP == NULL)
-    pub userthread: Option<unsafe extern "C" fn(LP: *mut lua_State, L: *mut lua_State)>,
+    pub userthread: Option<unsafe extern "C-unwind" fn(LP: *mut lua_State, L: *mut lua_State)>,
     /// gets called when a string is created; returned atom can be retrieved via tostringatom
-    pub useratom: Option<unsafe extern "C" fn(s: *const c_char, l: usize) -> i16>,
+    pub useratom: Option<unsafe extern "C-unwind" fn(s: *const c_char, l: usize) -> i16>,
 
     /// gets called when BREAK instruction is encountered
-    pub debugbreak: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    pub debugbreak: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
     /// gets called after each instruction in single step mode
-    pub debugstep: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    pub debugstep: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
     /// gets called when thread execution is interrupted by break in another thread
-    pub debuginterrupt: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    pub debuginterrupt: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
     /// gets called when protected call results in an error
-    pub debugprotectederror: Option<unsafe extern "C" fn(L: *mut lua_State)>,
+    pub debugprotectederror: Option<unsafe extern "C-unwind" fn(L: *mut lua_State)>,
 }
 
 extern "C" {

mlua-sys/src/luau/luacode.rs

@@ -13,7 +13,7 @@ pub struct lua_CompileOptions {
     pub mutableGlobals: *mut *const c_char,
 }
 
-extern "C" {
+extern "C-unwind" {
     #[link_name = "luau_compile"]
     pub fn luau_compile_(
         source: *const c_char,
@@ -21,7 +21,9 @@ extern "C" {
         options: *mut lua_CompileOptions,
         outsize: *mut usize,
     ) -> *mut c_char;
+}
 
+extern "C" {
     fn free(p: *mut c_void);
 }
 

mlua-sys/src/luau/luacodegen.rs

@@ -0,0 +1,11 @@
+//! Contains definitions from `luacodegen.h`.
+
+use std::os::raw::c_int;
+
+use super::lua::lua_State;
+
+extern "C-unwind" {
+    pub fn luau_codegen_supported() -> c_int;
+    pub fn luau_codegen_create(state: *mut lua_State);
+    pub fn luau_codegen_compile(state: *mut lua_State, idx: c_int);
+}

mlua-sys/src/luau/lualib.rs

@@ -13,7 +13,7 @@ pub const LUA_UTF8LIBNAME: &str = "utf8";
 pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
 
-extern "C" {
+extern "C-unwind" {
     pub fn luaopen_base(L: *mut lua_State) -> c_int;
     pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
     pub fn luaopen_table(L: *mut lua_State) -> c_int;

mlua-sys/src/luau/mod.rs

@@ -4,10 +4,12 @@ pub use compat::*;
 pub use lauxlib::*;
 pub use lua::*;
 pub use luacode::*;
+pub use luacodegen::*;
 pub use lualib::*;
 
 pub mod compat;
 pub mod lauxlib;
 pub mod lua;
 pub mod luacode;
+pub mod luacodegen;
 pub mod lualib;

mlua_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua_derive"
-version = "0.9.0-beta.1"
+version = "0.9.0-rc.2"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 edition = "2021"
 description = "Procedural macros for the mlua crate."
@@ -19,6 +19,6 @@ quote = "1.0"
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 proc-macro-error = { version = "1.0", optional = true }
 syn = { version = "2.0", features = ["full"] }
-itertools = { version = "0.10", optional = true }
+itertools = { version = "0.11", optional = true }
 regex = { version = "1.4", optional = true }
 once_cell = { version = "1.0", optional = true }

mlua_derive/src/from_lua.rs

@@ -0,0 +1,32 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
+
+pub fn from_lua(input: TokenStream) -> TokenStream {
+    let DeriveInput {
+        ident, generics, ..
+    } = parse_macro_input!(input as DeriveInput);
+
+    let where_clause = match &generics.where_clause {
+        Some(where_clause) => quote! { #where_clause, Self: 'static + Clone },
+        None => quote! { where Self: 'static + Clone },
+    };
+    let ident_str = ident.to_string();
+
+    quote! {
+      impl #generics ::mlua::FromLua<'_> for #ident #generics #where_clause {
+        #[inline]
+        fn from_lua(value: ::mlua::Value<'_>, lua: &'_ ::mlua::Lua) -> ::mlua::Result<Self> {
+          match value {
+            ::mlua::Value::UserData(ud) => Ok(ud.borrow::<Self>()?.clone()),
+            _ => Err(::mlua::Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: #ident_str,
+                message: None,
+            }),
+          }
+        }
+      }
+    }
+    .into()
+}

mlua_derive/src/lib.rs

@@ -13,6 +13,7 @@ use {
 #[derive(Default)]
 struct ModuleAttributes {
     name: Option<Ident>,
+    skip_memory_check: bool,
 }
 
 impl ModuleAttributes {
@@ -26,6 +27,11 @@ impl ModuleAttributes {
                     return Err(meta.error("`name` attribute must have a value"));
                 }
             }
+        } else if meta.path.is_ident("skip_memory_check") {
+            if meta.value().is_ok() {
+                return Err(meta.error("`skip_memory_check` attribute have no values"));
+            }
+            self.skip_memory_check = true;
         } else {
             return Err(meta.error("unsupported module attribute"));
         }
@@ -45,6 +51,7 @@ pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
     let func_name = &func.sig.ident;
     let module_name = args.name.unwrap_or_else(|| func_name.clone());
     let ext_entrypoint_name = Ident::new(&format!("luaopen_{module_name}"), Span::call_site());
+    let skip_memory_check = args.skip_memory_check;
 
     let wrapped = quote! {
         ::mlua::require_module_feature!();
@@ -52,8 +59,12 @@ pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
         #func
 
         #[no_mangle]
-        unsafe extern "C" fn #ext_entrypoint_name(state: *mut ::mlua::lua_State) -> ::std::os::raw::c_int {
-            ::mlua::Lua::init_from_ptr(state)
+        unsafe extern "C-unwind" fn #ext_entrypoint_name(state: *mut ::mlua::lua_State) -> ::std::os::raw::c_int {
+            let lua = ::mlua::Lua::init_from_ptr(state);
+            if #skip_memory_check {
+                lua.skip_memory_check(true);
+            }
+            lua
                 .entrypoint1(#func_name)
                 .expect("cannot initialize module")
         }
@@ -84,26 +95,25 @@ pub fn chunk(input: TokenStream) -> TokenStream {
     });
 
     let wrapped_code = quote! {{
-        use ::mlua::{AsChunk, ChunkMode, Lua, Result, Value};
+        use ::mlua::{AsChunk, ChunkMode, Lua, Result, Table};
         use ::std::borrow::Cow;
+        use ::std::cell::Cell;
         use ::std::io::Result as IoResult;
-        use ::std::sync::Mutex;
+        use ::std::marker::PhantomData;
 
-        struct InnerChunk<F: for <'a> FnOnce(&'a Lua) -> Result<Value<'a>>>(Mutex<Option<F>>);
+        struct InnerChunk<'lua, F: FnOnce(&'lua Lua) -> Result<Table<'lua>>>(Cell<Option<F>>, PhantomData<&'lua ()>);
 
-        impl<F> AsChunk<'static> for InnerChunk<F>
+        impl<'lua, F> AsChunk<'lua, 'static> for InnerChunk<'lua, F>
         where
-            F: for <'a> FnOnce(&'a Lua) -> Result<Value<'a>>,
+            F: FnOnce(&'lua Lua) -> Result<Table<'lua>>,
         {
-            fn env<'lua>(&self, lua: &'lua Lua) -> Result<Value<'lua>> {
+            fn environment(&self, lua: &'lua Lua) -> Result<Option<Table<'lua>>> {
                 if #caps_len > 0 {
-                    if let Ok(mut make_env) = self.0.lock() {
-                        if let Some(make_env) = make_env.take() {
-                            return make_env(lua);
-                        }
+                    if let Some(make_env) = self.0.take() {
+                        return make_env(lua).map(Some);
                     }
                 }
-                Ok(Value::Nil)
+                Ok(None)
             }
 
             fn mode(&self) -> Option<ChunkMode> {
@@ -115,9 +125,9 @@ pub fn chunk(input: TokenStream) -> TokenStream {
             }
         }
 
-        fn annotate<F: for<'a> FnOnce(&'a Lua) -> Result<Value<'a>>>(f: F) -> F { f }
+        fn annotate<'a, F: FnOnce(&'a Lua) -> Result<Table<'a>>>(f: F) -> F { f }
 
-        let make_env = annotate(move |lua: &Lua| -> Result<Value> {
+        let make_env = annotate(move |lua: &Lua| -> Result<Table> {
             let globals = lua.globals();
             let env = lua.create_table()?;
             let meta = lua.create_table()?;
@@ -128,16 +138,24 @@ pub fn chunk(input: TokenStream) -> TokenStream {
             #(#caps)*
 
             env.set_metatable(Some(meta));
-            Ok(Value::Table(env))
+            Ok(env)
         });
 
-        InnerChunk(Mutex::new(Some(make_env)))
+        InnerChunk(Cell::new(Some(make_env)), PhantomData)
     }};
 
     wrapped_code.into()
 }
 
+#[cfg(feature = "macros")]
+#[proc_macro_derive(FromLua)]
+pub fn from_lua(input: TokenStream) -> TokenStream {
+    from_lua::from_lua(input)
+}
+
 #[cfg(feature = "macros")]
 mod chunk;
 #[cfg(feature = "macros")]
+mod from_lua;
+#[cfg(feature = "macros")]
 mod token;

src/chunk.rs

@@ -5,19 +5,17 @@ use std::io::Result as IoResult;
 use std::path::{Path, PathBuf};
 use std::string::String as StdString;
 
-use crate::error::{Error, Result};
+use crate::error::{Error, ErrorContext, Result};
 use crate::function::Function;
 use crate::lua::Lua;
-use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti, Value};
-
-#[cfg(feature = "async")]
-use {futures_core::future::LocalBoxFuture, futures_util::future};
+use crate::table::Table;
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti};
 
 /// Trait for types [loadable by Lua] and convertible to a [`Chunk`]
 ///
 /// [loadable by Lua]: https://www.lua.org/manual/5.4/manual.html#3.3.2
 /// [`Chunk`]: crate::Chunk
-pub trait AsChunk<'a> {
+pub trait AsChunk<'lua, 'a> {
     /// Returns optional chunk name
     fn name(&self) -> Option<StdString> {
         None
@@ -26,9 +24,9 @@ pub trait AsChunk<'a> {
     /// Returns optional chunk [environment]
     ///
     /// [environment]: https://www.lua.org/manual/5.4/manual.html#2.2
-    fn env<'lua>(&self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn environment(&self, lua: &'lua Lua) -> Result<Option<Table<'lua>>> {
         let _lua = lua; // suppress warning
-        Ok(Value::Nil)
+        Ok(None)
     }
 
     /// Returns optional chunk mode (text or binary)
@@ -40,43 +38,43 @@ pub trait AsChunk<'a> {
     fn source(self) -> IoResult<Cow<'a, [u8]>>;
 }
 
-impl<'a> AsChunk<'a> for &'a str {
+impl<'a> AsChunk<'_, 'a> for &'a str {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self.as_ref()))
     }
 }
 
-impl AsChunk<'static> for StdString {
+impl AsChunk<'_, 'static> for StdString {
     fn source(self) -> IoResult<Cow<'static, [u8]>> {
         Ok(Cow::Owned(self.into_bytes()))
     }
 }
 
-impl<'a> AsChunk<'a> for &'a StdString {
+impl<'a> AsChunk<'_, 'a> for &'a StdString {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self.as_bytes()))
     }
 }
 
-impl<'a> AsChunk<'a> for &'a [u8] {
+impl<'a> AsChunk<'_, 'a> for &'a [u8] {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self))
     }
 }
 
-impl AsChunk<'static> for Vec<u8> {
+impl AsChunk<'_, 'static> for Vec<u8> {
     fn source(self) -> IoResult<Cow<'static, [u8]>> {
         Ok(Cow::Owned(self))
     }
 }
 
-impl<'a> AsChunk<'a> for &'a Vec<u8> {
+impl<'a> AsChunk<'_, 'a> for &'a Vec<u8> {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self.as_ref()))
     }
 }
 
-impl AsChunk<'static> for &Path {
+impl AsChunk<'_, 'static> for &Path {
     fn name(&self) -> Option<StdString> {
         Some(format!("@{}", self.display()))
     }
@@ -86,7 +84,7 @@ impl AsChunk<'static> for &Path {
     }
 }
 
-impl AsChunk<'static> for PathBuf {
+impl AsChunk<'_, 'static> for PathBuf {
     fn name(&self) -> Option<StdString> {
         Some(format!("@{}", self.display()))
     }
@@ -103,7 +101,7 @@ impl AsChunk<'static> for PathBuf {
 pub struct Chunk<'lua, 'a> {
     pub(crate) lua: &'lua Lua,
     pub(crate) name: StdString,
-    pub(crate) env: Result<Value<'lua>>,
+    pub(crate) env: Result<Option<Table<'lua>>>,
     pub(crate) mode: Option<ChunkMode>,
     pub(crate) source: IoResult<Cow<'a, [u8]>>,
     #[cfg(feature = "luau")]
@@ -133,6 +131,14 @@ pub struct Compiler {
 #[cfg(any(feature = "luau", doc))]
 impl Default for Compiler {
     fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Compiler {
+    /// Creates Luau compiler instance with default options
+    pub const fn new() -> Self {
         // Defaults are taken from luacode.h
         Compiler {
             optimization_level: 1,
@@ -143,14 +149,6 @@ impl Default for Compiler {
             mutable_globals: Vec::new(),
         }
     }
-}
-
-#[cfg(any(feature = "luau", doc))]
-impl Compiler {
-    /// Creates Luau compiler instance with default options
-    pub fn new() -> Self {
-        Compiler::default()
-    }
 
     /// Sets Luau compiler optimization level.
     ///
@@ -158,7 +156,8 @@ impl Compiler {
     /// * 0 - no optimization
     /// * 1 - baseline optimization level that doesn't prevent debuggability (default)
     /// * 2 - includes optimizations that harm debuggability such as inlining
-    pub fn set_optimization_level(mut self, level: u8) -> Self {
+    #[must_use]
+    pub const fn set_optimization_level(mut self, level: u8) -> Self {
         self.optimization_level = level;
         self
     }
@@ -169,7 +168,8 @@ impl Compiler {
     /// * 0 - no debugging support
     /// * 1 - line info & function names only; sufficient for backtraces (default)
     /// * 2 - full debug info with local & upvalue names; necessary for debugger
-    pub fn set_debug_level(mut self, level: u8) -> Self {
+    #[must_use]
+    pub const fn set_debug_level(mut self, level: u8) -> Self {
         self.debug_level = level;
         self
     }
@@ -180,18 +180,21 @@ impl Compiler {
     /// * 0 - no code coverage support (default)
     /// * 1 - statement coverage
     /// * 2 - statement and expression coverage (verbose)
-    pub fn set_coverage_level(mut self, level: u8) -> Self {
+    #[must_use]
+    pub const fn set_coverage_level(mut self, level: u8) -> Self {
         self.coverage_level = level;
         self
     }
 
     #[doc(hidden)]
+    #[must_use]
     pub fn set_vector_lib(mut self, lib: Option<String>) -> Self {
         self.vector_lib = lib;
         self
     }
 
     #[doc(hidden)]
+    #[must_use]
     pub fn set_vector_ctor(mut self, ctor: Option<String>) -> Self {
         self.vector_ctor = ctor;
         self
@@ -200,6 +203,7 @@ impl Compiler {
     /// 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(mut self, globals: Vec<String>) -> Self {
         self.mutable_globals = globals;
         self
@@ -254,9 +258,9 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         self
     }
 
-    /// Sets the first upvalue (`_ENV`) of the loaded chunk to the given value.
+    /// Sets the environment of the loaded chunk to the given value.
     ///
-    /// Lua main chunks always have exactly one upvalue, and this upvalue is used as the `_ENV`
+    /// In Lua >=5.2 main chunks always have exactly one upvalue, and this upvalue is used as the `_ENV`
     /// variable inside the chunk. By default this value is set to the global environment.
     ///
     /// Calling this method changes the `_ENV` upvalue to the value provided, and variables inside
@@ -266,7 +270,10 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// necessary to populate the environment in order for scripts using custom environments to be
     /// useful.
     pub fn set_environment<V: IntoLua<'lua>>(mut self, env: V) -> Self {
-        self.env = env.into_lua(self.lua);
+        self.env = env
+            .into_lua(self.lua)
+            .and_then(|val| self.lua.unpack(val))
+            .context("bad environment value");
         self
     }
 
@@ -308,8 +315,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// [`exec`]: #method.exec
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn exec_async(self) -> LocalBoxFuture<'lua, Result<()>> {
-        self.call_async(())
+    pub async fn exec_async(self) -> Result<()> {
+        self.call_async(()).await
     }
 
     /// Evaluate the chunk as either an expression or block.
@@ -340,17 +347,16 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// [`eval`]: #method.eval
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn eval_async<'fut, R>(self) -> LocalBoxFuture<'fut, Result<R>>
+    pub async fn eval_async<R>(self) -> Result<R>
     where
-        'lua: 'fut,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
         if self.detect_mode() == ChunkMode::Binary {
-            self.call_async(())
+            self.call_async(()).await
         } else if let Ok(function) = self.to_expression() {
-            function.call_async(())
+            function.call_async(()).await
         } else {
-            self.call_async(())
+            self.call_async(()).await
         }
     }
 
@@ -370,16 +376,12 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// [`call`]: #method.call
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn call_async<'fut, A, R>(self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    pub async fn call_async<A, R>(self, args: A) -> Result<R>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
-        match self.into_function() {
-            Ok(func) => func.call_async(args),
-            Err(e) => Box::pin(future::err(e)),
-        }
+        self.into_function()?.call_async(args).await
     }
 
     /// Load this chunk into a regular `Function`.
@@ -414,7 +416,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
                     self.mode = Some(ChunkMode::Binary);
                 }
                 #[cfg(not(feature = "luau"))]
-                if let Ok(func) = self.lua.load_chunk(None, Value::Nil, None, source.as_ref()) {
+                if let Ok(func) = self.lua.load_chunk(None, None, None, source.as_ref()) {
                     let data = func.dump(false);
                     self.source = Ok(Cow::Owned(data));
                     self.mode = Some(ChunkMode::Binary);
@@ -454,7 +456,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
                     } else {
                         let mut cache = ChunksCache(HashMap::new());
                         cache.0.insert(text_source, binary_source.as_ref().to_vec());
-                        self.lua.set_app_data(cache);
+                        let _ = self.lua.try_set_app_data(cache);
                     }
                 }
             }
@@ -466,7 +468,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     fn to_expression(&self) -> Result<Function<'lua>> {
         // We assume that mode is Text
         let source = self.source.as_ref();
-        let source = source.map_err(|err| Error::RuntimeError(err.to_string()))?;
+        let source = source.map_err(Error::runtime)?;
         let source = Self::expression_source(source);
         // We don't need to compile source if no compiler options set
         #[cfg(feature = "luau")]
@@ -500,7 +502,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     }
 
     fn convert_name(name: String) -> Result<CString> {
-        CString::new(name).map_err(|err| Error::RuntimeError(format!("invalid name: {err}")))
+        CString::new(name).map_err(|err| Error::runtime(format!("invalid name: {err}")))
     }
 
     fn expression_source(source: &[u8]) -> Vec<u8> {

src/conversion.rs

@@ -9,7 +9,7 @@ use bstr::{BStr, BString};
 use num_traits::cast;
 
 use crate::error::{Error, Result};
-use crate::function::{Function, WrappedFunction};
+use crate::function::Function;
 use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
@@ -21,9 +21,6 @@ use crate::value::{FromLua, IntoLua, Nil, Value};
 #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
 use crate::{function::OwnedFunction, table::OwnedTable, userdata::OwnedAnyUserData};
 
-#[cfg(feature = "async")]
-use crate::function::WrappedAsyncFunction;
-
 impl<'lua> IntoLua<'lua> for Value<'lua> {
     #[inline]
     fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
@@ -52,7 +49,7 @@ impl<'lua> FromLua<'lua> for String<'lua> {
         lua.coerce_string(value)?
             .ok_or_else(|| Error::FromLuaConversionError {
                 from: ty,
-                to: "String",
+                to: "string",
                 message: Some("expected string or number".to_string()),
             })
     }
@@ -136,21 +133,6 @@ impl<'lua> FromLua<'lua> for OwnedFunction {
     }
 }
 
-impl<'lua> IntoLua<'lua> for WrappedFunction<'lua> {
-    #[inline]
-    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        lua.create_callback(self.0).map(Value::Function)
-    }
-}
-
-#[cfg(feature = "async")]
-impl<'lua> IntoLua<'lua> for WrappedAsyncFunction<'lua> {
-    #[inline]
-    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        lua.create_async_callback(self.0).map(Value::Function)
-    }
-}
-
 impl<'lua> IntoLua<'lua> for Thread<'lua> {
     #[inline]
     fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
@@ -211,7 +193,7 @@ impl<'lua> FromLua<'lua> for OwnedAnyUserData {
     }
 }
 
-impl<'lua, T: 'static + MaybeSend + UserData> IntoLua<'lua> for T {
+impl<'lua, T: UserData + MaybeSend + 'static> IntoLua<'lua> for T {
     #[inline]
     fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::UserData(lua.create_userdata(self)?))
@@ -244,7 +226,7 @@ impl<'lua> FromLua<'lua> for Error {
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Error> {
         match value {
             Value::Error(err) => Ok(err),
-            val => Ok(Error::RuntimeError(
+            val => Ok(Error::runtime(
                 lua.coerce_string(val)?
                     .and_then(|s| Some(s.to_str().ok()?.to_owned()))
                     .unwrap_or_else(|| "<unprintable error>".to_owned()),
@@ -292,6 +274,29 @@ impl<'lua> FromLua<'lua> for LightUserData {
     }
 }
 
+#[cfg(feature = "luau")]
+impl<'lua> IntoLua<'lua> for crate::types::Vector {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Vector(self))
+    }
+}
+
+#[cfg(feature = "luau")]
+impl<'lua> FromLua<'lua> for crate::types::Vector {
+    #[inline]
+    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+        match value {
+            Value::Vector(v) => Ok(v),
+            _ => Err(Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: "vector",
+                message: None,
+            }),
+        }
+    }
+}
+
 impl<'lua> IntoLua<'lua> for StdString {
     #[inline]
     fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
@@ -412,7 +417,7 @@ impl<'lua> FromLua<'lua> for BString {
             lua.coerce_string(value)?
                 .ok_or_else(|| Error::FromLuaConversionError {
                     from: ty,
-                    to: "String",
+                    to: "BString",
                     message: Some("expected string or number".to_string()),
                 })?
                 .as_bytes()
@@ -533,7 +538,7 @@ lua_convert_float!(f64);
 
 impl<'lua, T> IntoLua<'lua> for &[T]
 where
-    T: Clone + IntoLua<'lua>,
+    T: IntoLua<'lua> + Clone,
 {
     #[inline]
     fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
@@ -561,21 +566,22 @@ where
     fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
         match value {
             #[cfg(feature = "luau")]
-            Value::Vector(x, y, z) if N == 3 => Ok(mlua_expect!(
-                vec![
-                    T::from_lua(Value::Number(x as _), _lua)?,
-                    T::from_lua(Value::Number(y as _), _lua)?,
-                    T::from_lua(Value::Number(z as _), _lua)?,
-                ]
-                .try_into()
-                .map_err(|_| ()),
-                "cannot convert vector to array"
-            )),
+            #[rustfmt::skip]
+            Value::Vector(v) if N == crate::types::Vector::SIZE => unsafe {
+                use std::{mem, ptr};
+                let mut arr: [mem::MaybeUninit<T>; N] = mem::MaybeUninit::uninit().assume_init();
+                ptr::write(arr[0].as_mut_ptr() , T::from_lua(Value::Number(v.x() as _), _lua)?);
+                ptr::write(arr[1].as_mut_ptr(), T::from_lua(Value::Number(v.y() as _), _lua)?);
+                ptr::write(arr[2].as_mut_ptr(), T::from_lua(Value::Number(v.z() as _), _lua)?);
+                #[cfg(feature = "luau-vector4")]
+                ptr::write(arr[3].as_mut_ptr(), T::from_lua(Value::Number(v.w() as _), _lua)?);
+                Ok(mem::transmute_copy(&arr))
+            },
             Value::Table(table) => {
                 let vec = table.sequence_values().collect::<Result<Vec<_>>>()?;
                 vec.try_into()
                     .map_err(|vec: Vec<T>| Error::FromLuaConversionError {
-                        from: "Table",
+                        from: "table",
                         to: "Array",
                         message: Some(format!("expected table of length {}, got {}", N, vec.len())),
                     })
@@ -614,12 +620,6 @@ 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")]
-            Value::Vector(x, y, z) => Ok(vec![
-                T::from_lua(Value::Number(x as _), _lua)?,
-                T::from_lua(Value::Number(y as _), _lua)?,
-                T::from_lua(Value::Number(z as _), _lua)?,
-            ]),
             Value::Table(table) => table.sequence_values().collect(),
             _ => Err(Error::FromLuaConversionError {
                 from: value.type_name(),
@@ -691,7 +691,7 @@ impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
     #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         match value {
-            Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
+            Value::Table(table) if table.raw_len() > 0 => table.sequence_values().collect(),
             Value::Table(table) => table
                 .pairs::<T, Value<'lua>>()
                 .map(|res| res.map(|(k, _)| k))
@@ -718,7 +718,7 @@ 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(),
+            Value::Table(table) if table.raw_len() > 0 => table.sequence_values().collect(),
             Value::Table(table) => table
                 .pairs::<T, Value<'lua>>()
                 .map(|res| res.map(|(k, _)| k))

src/error.rs

@@ -47,11 +47,6 @@ pub enum Error {
     /// This error can only happen when Lua state was not created by us and does not have the
     /// custom allocator attached.
     MemoryLimitNotAvailable,
-    /// Main thread is not available.
-    ///
-    /// This error can only happen in Lua5.1/LuaJIT module mode, when module loaded within a coroutine.
-    /// These Lua versions does not have `LUA_RIDX_MAINTHREAD` registry key.
-    MainThreadNotAvailable,
     /// A mutable callback has triggered Lua code that has called the same mutable callback again.
     ///
     /// This is an error because a mutable callback can only be borrowed mutably once.
@@ -69,7 +64,7 @@ pub enum Error {
     /// called with a huge number of arguments, or a rust callback returns a huge number of return
     /// values.
     StackError,
-    /// Too many arguments to `Function::bind`
+    /// Too many arguments to `Function::bind`.
     BindError,
     /// Bad argument received from Lua (usually when calling a function).
     ///
@@ -130,7 +125,7 @@ pub enum Error {
     ///
     /// [`AnyUserData`]: crate::AnyUserData
     UserDataDestructed,
-    /// An [`AnyUserData`] immutable borrow failed because it is already borrowed mutably.
+    /// An [`AnyUserData`] immutable borrow failed.
     ///
     /// This error can occur when a method on a [`UserData`] type calls back into Lua, which then
     /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
@@ -139,7 +134,7 @@ pub enum Error {
     /// [`AnyUserData`]: crate::AnyUserData
     /// [`UserData`]: crate::UserData
     UserDataBorrowError,
-    /// An [`AnyUserData`] mutable borrow failed because it is already borrowed.
+    /// An [`AnyUserData`] mutable borrow failed.
     ///
     /// This error can occur when a method on a [`UserData`] type calls back into Lua, which then
     /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
@@ -226,9 +221,6 @@ impl fmt::Display for Error {
             Error::MemoryLimitNotAvailable => {
                 write!(fmt, "setting memory limit is not available")
             }
-            Error::MainThreadNotAvailable => {
-                write!(fmt, "main thread is not available in Lua 5.1")
-            }
             Error::RecursiveMutCallback => write!(fmt, "mutable callback called recursively"),
             Error::CallbackDestructed => write!(
                 fmt,
@@ -270,8 +262,8 @@ impl fmt::Display for Error {
             Error::CoroutineInactive => write!(fmt, "cannot resume inactive coroutine"),
             Error::UserDataTypeMismatch => write!(fmt, "userdata is not expected type"),
             Error::UserDataDestructed => write!(fmt, "userdata has been destructed"),
-            Error::UserDataBorrowError => write!(fmt, "userdata already mutably borrowed"),
-            Error::UserDataBorrowMutError => write!(fmt, "userdata already borrowed"),
+            Error::UserDataBorrowError => write!(fmt, "error borrowing userdata"),
+            Error::UserDataBorrowMutError => write!(fmt, "error mutably borrowing userdata"),
             Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {method} is restricted"),
             Error::MetaMethodTypeError { ref method, type_name, ref message } => {
                 write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
@@ -335,13 +327,24 @@ impl StdError for Error {
             // Given that we include source to fmt::Display implementation for `CallbackError`, this call returns nothing.
             Error::CallbackError { .. } => None,
             Error::ExternalError(ref err) => err.source(),
+            Error::WithContext { ref cause, .. } => match cause.as_ref() {
+                Error::ExternalError(err) => err.source(),
+                _ => None,
+            },
             _ => None,
         }
     }
 }
 
 impl Error {
+    /// Creates a new `RuntimeError` with the given message.
+    #[inline]
+    pub fn runtime<S: fmt::Display>(message: S) -> Self {
+        Error::RuntimeError(message.to_string())
+    }
+
     /// Wraps an external error object.
+    #[inline]
     pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Self {
         Error::ExternalError(err.into().into())
     }
@@ -353,6 +356,10 @@ impl Error {
     {
         match self {
             Error::ExternalError(err) => err.downcast_ref(),
+            Error::WithContext { cause, .. } => match cause.as_ref() {
+                Error::ExternalError(err) => err.downcast_ref(),
+                _ => None,
+            },
             _ => None,
         }
     }
@@ -379,6 +386,7 @@ impl Error {
     }
 }
 
+/// Trait for converting [`std::error::Error`] into Lua [`Error`].
 pub trait ExternalError {
     fn into_lua_err(self) -> Error;
 }
@@ -389,6 +397,7 @@ impl<E: Into<Box<dyn StdError + Send + Sync>>> ExternalError for E {
     }
 }
 
+/// Trait for converting [`std::result::Result`] into Lua [`Result`].
 pub trait ExternalResult<T> {
     fn into_lua_err(self) -> Result<T>;
 }
@@ -414,33 +423,35 @@ pub trait ErrorContext: Sealed {
 
 impl ErrorContext for Error {
     fn context<C: fmt::Display>(self, context: C) -> Self {
-        Error::WithContext {
-            context: context.to_string(),
-            cause: Arc::new(self),
+        let context = context.to_string();
+        match self {
+            Error::WithContext { cause, .. } => Error::WithContext { context, cause },
+            _ => Error::WithContext {
+                context,
+                cause: Arc::new(self),
+            },
         }
     }
 
     fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
-        Error::WithContext {
-            context: f(&self).to_string(),
-            cause: Arc::new(self),
+        let context = f(&self).to_string();
+        match self {
+            Error::WithContext { cause, .. } => Error::WithContext { context, cause },
+            _ => Error::WithContext {
+                context,
+                cause: Arc::new(self),
+            },
         }
     }
 }
 
 impl<T> ErrorContext for StdResult<T, Error> {
     fn context<C: fmt::Display>(self, context: C) -> Self {
-        self.map_err(|err| Error::WithContext {
-            context: context.to_string(),
-            cause: Arc::new(err),
-        })
+        self.map_err(|err| err.context(context))
     }
 
     fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
-        self.map_err(|err| Error::WithContext {
-            context: f(&err).to_string(),
-            cause: Arc::new(err),
-        })
+        self.map_err(|err| err.with_context(f))
     }
 }
 

src/function.rs

@@ -7,17 +7,18 @@ use std::slice;
 use crate::error::{Error, Result};
 use crate::lua::Lua;
 use crate::memory::MemoryState;
+use crate::table::Table;
 use crate::types::{Callback, LuaRef, MaybeSend};
 use crate::util::{
-    assert_stack, check_stack, error_traceback, pop_error, ptr_to_cstr_bytes, StackGuard,
+    assert_stack, check_stack, error_traceback, linenumber_to_usize, pop_error, ptr_to_lossy_str,
+    ptr_to_str, StackGuard,
 };
-use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti};
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
 #[cfg(feature = "async")]
 use {
     crate::types::AsyncCallback,
-    futures_core::future::{Future, LocalBoxFuture},
-    futures_util::{future, TryFutureExt},
+    futures_util::future::{self, Future},
 };
 
 /// Handle to an internal Lua function.
@@ -45,16 +46,29 @@ impl OwnedFunction {
     }
 }
 
+/// Contains information about a function.
+///
+/// Please refer to the [`Lua Debug Interface`] for more information.
+///
+/// [`Lua Debug Interface`]: https://www.lua.org/manual/5.4/manual.html#4.7
 #[derive(Clone, Debug)]
 pub struct FunctionInfo {
-    pub name: Option<Vec<u8>>,
-    pub name_what: Option<Vec<u8>>,
-    pub what: Option<Vec<u8>>,
-    pub source: Option<Vec<u8>>,
-    pub short_src: Option<Vec<u8>>,
-    pub line_defined: i32,
-    #[cfg(not(feature = "luau"))]
-    pub last_line_defined: i32,
+    /// A (reasonable) name of the function (`None` if the name cannot be found).
+    pub name: Option<String>,
+    /// Explains the `name` field (can be `global`/`local`/`method`/`field`/`upvalue`/etc).
+    ///
+    /// Always `None` for Luau.
+    pub name_what: Option<&'static str>,
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is the main part of a chunk.
+    pub what: &'static str,
+    /// Source of the chunk that created the function.
+    pub source: Option<String>,
+    /// A "printable" version of `source`, to be used in error messages.
+    pub short_src: Option<String>,
+    /// The line number where the definition of the function starts.
+    pub line_defined: Option<usize>,
+    /// The line number where the definition of the function ends (not set by Luau).
+    pub last_line_defined: Option<usize>,
 }
 
 /// Luau function coverage snapshot.
@@ -62,7 +76,7 @@ pub struct FunctionInfo {
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CoverageInfo {
-    pub function: Option<std::string::String>,
+    pub function: Option<String>,
     pub line_defined: i32,
     pub depth: i32,
     pub hits: Vec<i32>,
@@ -153,14 +167,13 @@ impl<'lua> Function<'lua> {
     ///
     /// ```
     /// use std::time::Duration;
-    /// use futures_timer::Delay;
     /// # use mlua::{Lua, Result};
     /// # #[tokio::main]
     /// # async fn main() -> Result<()> {
     /// # let lua = Lua::new();
     ///
     /// let sleep = lua.create_async_function(move |_lua, n: u64| async move {
-    ///     Delay::new(Duration::from_millis(n)).await;
+    ///     tokio::time::sleep(Duration::from_millis(n)).await;
     ///     Ok(())
     /// })?;
     ///
@@ -173,21 +186,18 @@ impl<'lua> Function<'lua> {
     /// [`AsyncThread`]: crate::AsyncThread
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    pub fn call_async<A, R>(&self, args: A) -> impl Future<Output = Result<R>> + 'lua
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
         let lua = self.0.lua;
-        match lua.create_recycled_thread(self) {
-            Ok(t) => {
-                let mut t = t.into_async(args);
-                t.set_recyclable(true);
-                Box::pin(t)
-            }
-            Err(e) => Box::pin(future::err(e)),
-        }
+        let thread_res = lua.create_recycled_thread(self).map(|th| {
+            let mut th = th.into_async(args);
+            th.set_recyclable(true);
+            th
+        });
+        async move { thread_res?.await }
     }
 
     /// Returns a function that, when called, calls `self`, passing `args` as the first set of
@@ -218,7 +228,7 @@ impl<'lua> Function<'lua> {
     /// # }
     /// ```
     pub fn bind<A: IntoLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
-        unsafe extern "C" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
+        unsafe extern "C-unwind" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
             let nargs = ffi::lua_gettop(state);
             let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(1)) as c_int;
             ffi::luaL_checkstack(state, nbinds, ptr::null());
@@ -271,10 +281,93 @@ impl<'lua> Function<'lua> {
             "#,
         )
         .try_cache()
-        .set_name("_mlua_bind")
+        .set_name("__mlua_bind")
         .call((self.clone(), args_wrapper))
     }
 
+    /// Returns the environment of the Lua function.
+    ///
+    /// By default Lua functions shares a global environment.
+    ///
+    /// This function always returns `None` for Rust/C functions.
+    pub fn environment(&self) -> Option<Table> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return None;
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            ffi::lua_getfenv(state, -1);
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                // Traverse upvalues until we find the _ENV one
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => break,
+                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => break,
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            if ffi::lua_type(state, -1) != ffi::LUA_TTABLE {
+                return None;
+            }
+            Some(Table(lua.pop_ref()))
+        }
+    }
+
+    /// Sets the environment of the Lua function.
+    ///
+    /// The environment is a table that is used as the global environment for the function.
+    /// Returns `true` if environment successfully changed, `false` otherwise.
+    ///
+    /// This function does nothing for Rust/C functions.
+    pub fn set_environment(&self, env: Table) -> Result<bool> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return Ok(false);
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            {
+                lua.push_ref(&env.0);
+                ffi::lua_setfenv(state, -2);
+            }
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => return Ok(false),
+                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => {
+                        ffi::lua_pop(state, 1);
+                        // Create an anonymous function with the new environment
+                        let f_with_env = lua
+                            .load("return _ENV")
+                            .set_environment(env)
+                            .try_cache()
+                            .into_function()?;
+                        lua.push_ref(&f_with_env.0);
+                        ffi::lua_upvaluejoin(state, -2, i, -1, 1);
+                        break;
+                    }
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            Ok(true)
+        }
+    }
+
     /// Returns information about the function.
     ///
     /// Corresponds to the `>Sn` what mask for [`lua_getinfo`] when applied to the function.
@@ -296,20 +389,25 @@ impl<'lua> Function<'lua> {
             mlua_assert!(res != 0, "lua_getinfo failed with `>Sn`");
 
             FunctionInfo {
-                name: ptr_to_cstr_bytes(ar.name).map(|s| s.to_vec()),
+                name: ptr_to_lossy_str(ar.name).map(|s| s.into_owned()),
                 #[cfg(not(feature = "luau"))]
-                name_what: ptr_to_cstr_bytes(ar.namewhat).map(|s| s.to_vec()),
+                name_what: match ptr_to_str(ar.namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
                 #[cfg(feature = "luau")]
                 name_what: None,
-                what: ptr_to_cstr_bytes(ar.what).map(|s| s.to_vec()),
-                source: ptr_to_cstr_bytes(ar.source).map(|s| s.to_vec()),
+                what: ptr_to_str(ar.what).unwrap_or("main"),
+                source: ptr_to_lossy_str(ar.source).map(|s| s.into_owned()),
                 #[cfg(not(feature = "luau"))]
-                short_src: ptr_to_cstr_bytes(ar.short_src.as_ptr()).map(|s| s.to_vec()),
+                short_src: ptr_to_lossy_str(ar.short_src.as_ptr()).map(|s| s.into_owned()),
                 #[cfg(feature = "luau")]
-                short_src: ptr_to_cstr_bytes(ar.short_src).map(|s| s.to_vec()),
-                line_defined: ar.linedefined,
+                short_src: ptr_to_lossy_str(ar.short_src).map(|s| s.into_owned()),
+                line_defined: linenumber_to_usize(ar.linedefined),
                 #[cfg(not(feature = "luau"))]
-                last_line_defined: ar.lastlinedefined,
+                last_line_defined: linenumber_to_usize(ar.lastlinedefined),
+                #[cfg(feature = "luau")]
+                last_line_defined: None,
             }
         }
     }
@@ -325,7 +423,7 @@ impl<'lua> Function<'lua> {
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn dump(&self, strip: bool) -> Vec<u8> {
-        unsafe extern "C" fn writer(
+        unsafe extern "C-unwind" fn writer(
             _state: *mut ffi::lua_State,
             buf: *const c_void,
             buf_len: usize,
@@ -363,7 +461,7 @@ impl<'lua> Function<'lua> {
     /// Requires `feature = "luau"`
     ///
     /// [`Compiler::set_coverage_level`]: crate::chunk::Compiler::set_coverage_level
-    #[cfg(any(feature = "luau", docsrs))]
+    #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn coverage<F>(&self, mut func: F)
     where
@@ -372,7 +470,7 @@ impl<'lua> Function<'lua> {
         use std::ffi::CStr;
         use std::os::raw::c_char;
 
-        unsafe extern "C" fn callback<F: FnMut(CoverageInfo)>(
+        unsafe extern "C-unwind" fn callback<F: FnMut(CoverageInfo)>(
             data: *mut c_void,
             function: *const c_char,
             line_defined: c_int,
@@ -443,12 +541,12 @@ impl OwnedFunction {
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     #[inline]
-    pub fn call_async<'lua, A, R>(&'lua self, args: A) -> LocalBoxFuture<'lua, Result<R>>
+    pub async fn call_async<'lua, A, R>(&'lua self, args: A) -> Result<R>
     where
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'lua,
     {
-        self.to_ref().call_async(args)
+        self.to_ref().call_async(args).await
     }
 }
 
@@ -503,11 +601,27 @@ impl<'lua> Function<'lua> {
                 Ok(args) => args,
                 Err(e) => return Box::pin(future::err(e)),
             };
-            Box::pin(func(lua, args).and_then(move |ret| future::ready(ret.into_lua_multi(lua))))
+            let fut = func(lua, args);
+            Box::pin(async move { fut.await?.into_lua_multi(lua) })
         }))
     }
 }
 
+impl<'lua> IntoLua<'lua> for WrappedFunction<'lua> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.create_callback(self.0).map(Value::Function)
+    }
+}
+
+#[cfg(feature = "async")]
+impl<'lua> IntoLua<'lua> for WrappedAsyncFunction<'lua> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.create_async_callback(self.0).map(Value::Function)
+    }
+}
+
 #[cfg(test)]
 mod assertions {
     use super::*;

src/hook.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::cell::UnsafeCell;
 #[cfg(not(feature = "luau"))]
 use std::ops::{BitOr, BitOrAssign};
@@ -6,7 +7,7 @@ use std::os::raw::c_int;
 use ffi::lua_Debug;
 
 use crate::lua::Lua;
-use crate::util::ptr_to_cstr_bytes;
+use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
 
 /// Contains information about currently executing Lua code.
 ///
@@ -78,9 +79,12 @@ impl<'lua> Debug<'lua> {
             );
 
             DebugNames {
-                name: ptr_to_cstr_bytes((*self.ar.get()).name),
+                name: ptr_to_lossy_str((*self.ar.get()).name),
                 #[cfg(not(feature = "luau"))]
-                name_what: ptr_to_cstr_bytes((*self.ar.get()).namewhat),
+                name_what: match ptr_to_str((*self.ar.get()).namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
                 #[cfg(feature = "luau")]
                 name_what: None,
             }
@@ -102,15 +106,17 @@ impl<'lua> Debug<'lua> {
             );
 
             DebugSource {
-                source: ptr_to_cstr_bytes((*self.ar.get()).source),
+                source: ptr_to_lossy_str((*self.ar.get()).source),
                 #[cfg(not(feature = "luau"))]
-                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src.as_ptr()),
+                short_src: ptr_to_lossy_str((*self.ar.get()).short_src.as_ptr()),
                 #[cfg(feature = "luau")]
-                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src),
-                line_defined: (*self.ar.get()).linedefined,
+                short_src: ptr_to_lossy_str((*self.ar.get()).short_src),
+                line_defined: linenumber_to_usize((*self.ar.get()).linedefined),
                 #[cfg(not(feature = "luau"))]
-                last_line_defined: (*self.ar.get()).lastlinedefined,
-                what: ptr_to_cstr_bytes((*self.ar.get()).what),
+                last_line_defined: linenumber_to_usize((*self.ar.get()).lastlinedefined),
+                #[cfg(feature = "luau")]
+                last_line_defined: None,
+                what: ptr_to_str((*self.ar.get()).what).unwrap_or("main"),
             }
         }
     }
@@ -210,18 +216,26 @@ pub enum DebugEvent {
 
 #[derive(Clone, Debug)]
 pub struct DebugNames<'a> {
-    pub name: Option<&'a [u8]>,
-    pub name_what: Option<&'a [u8]>,
+    /// A (reasonable) name of the function (`None` if the name cannot be found).
+    pub name: Option<Cow<'a, str>>,
+    /// Explains the `name` field (can be `global`/`local`/`method`/`field`/`upvalue`/etc).
+    ///
+    /// Always `None` for Luau.
+    pub name_what: Option<&'static str>,
 }
 
 #[derive(Clone, Debug)]
 pub struct DebugSource<'a> {
-    pub source: Option<&'a [u8]>,
-    pub short_src: Option<&'a [u8]>,
-    pub line_defined: i32,
-    #[cfg(not(feature = "luau"))]
-    pub last_line_defined: i32,
-    pub what: Option<&'a [u8]>,
+    /// Source of the chunk that created the function.
+    pub source: Option<Cow<'a, str>>,
+    /// A "printable" version of `source`, to be used in error messages.
+    pub short_src: Option<Cow<'a, str>>,
+    /// The line number where the definition of the function starts.
+    pub line_defined: Option<usize>,
+    /// The line number where the definition of the function ends (not set by Luau).
+    pub last_line_defined: Option<usize>,
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is the main part of a chunk.
+    pub what: &'static str,
 }
 
 #[derive(Copy, Clone, Debug)]

src/lib.rs

@@ -103,7 +103,7 @@ mod value;
 
 pub mod prelude;
 
-pub use ffi::{lua_CFunction, lua_State};
+pub use ffi::{self, lua_CFunction, lua_State};
 
 pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
 pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
@@ -116,13 +116,13 @@ pub use crate::stdlib::StdLib;
 pub use crate::string::String;
 pub use crate::table::{Table, TableExt, TablePairs, TableSequence};
 pub use crate::thread::{Thread, ThreadStatus};
-pub use crate::types::{Integer, LightUserData, Number, RegistryKey};
+pub use crate::types::{AppDataRef, AppDataRefMut, Integer, LightUserData, Number, RegistryKey};
 pub use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
     UserDataRef, UserDataRefMut,
 };
 pub use crate::userdata_ext::AnyUserDataExt;
-pub use crate::userdata_impl::UserDataRegistrar;
+pub use crate::userdata_impl::UserDataRegistry;
 pub use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, Value};
 
 #[cfg(not(feature = "luau"))]
@@ -130,7 +130,11 @@ pub use crate::hook::HookTriggers;
 
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-pub use crate::{chunk::Compiler, function::CoverageInfo, types::VmState};
+pub use crate::{
+    chunk::Compiler,
+    function::CoverageInfo,
+    types::{Vector, VmState},
+};
 
 #[cfg(feature = "async")]
 pub use crate::thread::AsyncThread;
@@ -145,7 +149,7 @@ pub use crate::serde::{
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 pub mod serde;
 
-#[cfg(any(feature = "mlua_derive"))]
+#[cfg(feature = "mlua_derive")]
 #[allow(unused_imports)]
 #[macro_use]
 extern crate mlua_derive;
@@ -208,10 +212,18 @@ pub use crate::{
 /// [`AsChunk`]: crate::AsChunk
 /// [`UserData`]: crate::UserData
 /// [`IntoLua`]: crate::IntoLua
-#[cfg(any(feature = "macros"))]
+#[cfg(feature = "macros")]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
 
+/// Derive [`FromLua`] for a Rust type.
+///
+/// Current implementation generate code that takes [`UserData`] value, borrow it (of the Rust type)
+/// and clone.
+#[cfg(feature = "macros")]
+#[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
+pub use mlua_derive::FromLua;
+
 /// Registers Lua module entrypoint.
 ///
 /// You can register multiple entrypoints as required.
@@ -231,7 +243,7 @@ pub use mlua_derive::chunk;
 ///
 /// You can also pass options to the attribute:
 ///
-/// name - name of the module, defaults to the name of the function
+/// * name - name of the module, defaults to the name of the function
 ///
 /// ```ignore
 /// #[mlua::lua_module(name = "alt_module")]
@@ -240,6 +252,20 @@ pub use mlua_derive::chunk;
 /// }
 /// ```
 ///
+/// * skip_memory_check - skip memory allocation checks for some operations.
+///
+/// In module mode, mlua runs in unknown environment and cannot say are there any memory
+/// limits or not. As result, some operations that require memory allocation runs in
+/// protected mode. Setting this attribute will improve performance of such operations
+/// with risk of having uncaught exceptions and memory leaks.
+///
+/// ```ignore
+/// #[mlua::lua_module(skip_memory_check)]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     ...
+/// }
+/// ```
+///
 #[cfg(any(feature = "module", docsrs))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;

src/luau.rs

@@ -24,7 +24,7 @@ impl Lua {
 
         // Set `_VERSION` global to include version number
         // The environment variable `LUAU_VERSION` set by the build script
-        if let Some(version) = option_env!("LUAU_VERSION") {
+        if let Some(version) = ffi::luau_version() {
             globals.raw_set("_VERSION", format!("Luau {version}"))?;
         }
 
@@ -32,7 +32,7 @@ impl Lua {
     }
 }
 
-unsafe extern "C" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
+unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
     let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
     let option = CStr::from_ptr(option);
     let arg = ffi::luaL_optinteger(state, 2, 0);
@@ -70,7 +70,7 @@ unsafe extern "C" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
 }
 
 fn lua_require(lua: &Lua, name: Option<StdString>) -> Result<Value> {
-    let name = name.ok_or_else(|| Error::RuntimeError("invalid module name".into()))?;
+    let name = name.ok_or_else(|| Error::runtime("invalid module name"))?;
 
     // Find module in the cache
     let state = lua.state();
@@ -101,7 +101,7 @@ fn lua_require(lua: &Lua, name: Option<StdString>) -> Result<Value> {
             break;
         }
     }
-    let source = source.ok_or_else(|| Error::RuntimeError(format!("cannot find '{name}'")))?;
+    let source = source.ok_or_else(|| Error::runtime(format!("cannot find '{name}'")))?;
 
     let value = lua
         .load(&source)
@@ -122,10 +122,16 @@ fn lua_require(lua: &Lua, name: Option<StdString>) -> Result<Value> {
 }
 
 // Luau vector datatype constructor
-unsafe extern "C" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
+unsafe extern "C-unwind" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
     let x = ffi::luaL_checknumber(state, 1) as c_float;
     let y = ffi::luaL_checknumber(state, 2) as c_float;
     let z = ffi::luaL_checknumber(state, 3) as c_float;
+    #[cfg(feature = "luau-vector4")]
+    let w = ffi::luaL_checknumber(state, 4) as c_float;
+
+    #[cfg(not(feature = "luau-vector4"))]
     ffi::lua_pushvector(state, x, y, z);
+    #[cfg(feature = "luau-vector4")]
+    ffi::lua_pushvector(state, x, y, z, w);
     1
 }

src/macros.rs

@@ -101,9 +101,15 @@ macro_rules! protect_lua {
     };
 
     ($state:expr, $nargs:expr, $nresults:expr, fn($state_inner:ident) $code:expr) => {{
-        unsafe extern "C" fn do_call($state_inner: *mut ffi::lua_State) -> ::std::os::raw::c_int {
+        use ::std::os::raw::c_int;
+        unsafe extern "C-unwind" fn do_call($state_inner: *mut ffi::lua_State) -> c_int {
             $code;
-            $nresults
+            let nresults = $nresults;
+            if nresults == ::ffi::LUA_MULTRET {
+                ffi::lua_gettop($state_inner)
+            } else {
+                nresults
+            }
         }
 
         crate::util::protect_lua_call($state, $nargs, do_call)

src/memory.rs

@@ -85,7 +85,7 @@ impl MemoryState {
     }
 }
 
-unsafe extern "C" fn allocator(
+unsafe extern "C-unwind" fn allocator(
     extra: *mut c_void,
     ptr: *mut c_void,
     osize: usize,

src/prelude.rs

@@ -13,7 +13,7 @@ pub use crate::{
     Thread as LuaThread, ThreadStatus as LuaThreadStatus, UserData as LuaUserData,
     UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
     UserDataMethods as LuaUserDataMethods, UserDataRef as LuaUserDataRef,
-    UserDataRefMut as LuaUserDataRefMut, UserDataRegistrar as LuaUserDataRegistrar,
+    UserDataRefMut as LuaUserDataRefMut, UserDataRegistry as LuaUserDataRegistry,
     Value as LuaValue,
 };
 
@@ -23,7 +23,7 @@ pub use crate::HookTriggers as LuaHookTriggers;
 
 #[cfg(feature = "luau")]
 #[doc(no_inline)]
-pub use crate::{CoverageInfo as LuaCoverageInfo, VmState as LuaVmState};
+pub use crate::{CoverageInfo as LuaCoverageInfo, Vector as LuaVector, VmState as LuaVmState};
 
 #[cfg(feature = "async")]
 #[doc(no_inline)]

src/scope.rs

@@ -2,7 +2,6 @@ use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::marker::PhantomData;
 use std::mem;
-use std::os::raw::c_int;
 
 #[cfg(feature = "serialize")]
 use serde::Serialize;
@@ -14,9 +13,10 @@ use crate::types::{Callback, CallbackUpvalue, LuaRef, MaybeSend};
 use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
 };
+use crate::userdata_impl::UserDataRegistry;
 use crate::util::{
-    assert_stack, check_stack, get_userdata, init_userdata_metatable, push_table, rawset_field,
-    take_userdata, StackGuard,
+    self, assert_stack, check_stack, get_userdata, init_userdata_metatable, push_table,
+    rawset_field, take_userdata, StackGuard,
 };
 use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Value};
 
@@ -24,7 +24,7 @@ use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Val
 use crate::userdata::USER_VALUE_MAXSLOT;
 
 #[cfg(feature = "async")]
-use futures_core::future::Future;
+use std::future::Future;
 
 /// Constructed by the [`Lua::scope`] method, allows temporarily creating Lua userdata and
 /// callbacks that are not required to be Send or 'static.
@@ -32,7 +32,10 @@ use futures_core::future::Future;
 /// See [`Lua::scope`] for more details.
 ///
 /// [`Lua::scope`]: crate::Lua.html::scope
-pub struct Scope<'lua, 'scope> {
+pub struct Scope<'lua, 'scope>
+where
+    'lua: 'scope,
+{
     lua: &'lua Lua,
     destructors: RefCell<Vec<(LuaRef<'lua>, DestructorCallback<'lua>)>>,
     _scope_invariant: PhantomData<Cell<&'scope ()>>,
@@ -236,7 +239,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             #[cfg(feature = "lua54")]
             for i in 1..=USER_VALUE_MAXSLOT {
                 ffi::lua_pushnil(state);
-                ffi::lua_setiuservalue(state, -2, i as c_int);
+                ffi::lua_setiuservalue(state, -2, i as _);
             }
             #[cfg(any(feature = "lua53", feature = "lua52", feature = "luau"))]
             {
@@ -365,7 +368,6 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             check_stack(state, 13)?;
 
             #[cfg(not(feature = "luau"))]
-            #[allow(clippy::let_and_return)]
             let ud_ptr = protect_lua!(state, 0, 1, |state| {
                 let ud = ffi::lua_newuserdata(state, mem::size_of::<UserDataCell<T>>());
 
@@ -380,20 +382,20 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             })?;
             #[cfg(feature = "luau")]
             let ud_ptr = {
-                crate::util::push_userdata(state, UserDataCell::new(data), true)?;
+                util::push_userdata(state, UserDataCell::new(data), true)?;
                 ffi::lua_touserdata(state, -1) as *const UserDataCell<T>
             };
 
             // 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(state, 0, meta_methods_nrec as c_int, true)?;
+            push_table(state, 0, meta_methods_nrec, true)?;
 
             for (k, m) in ud_methods.meta_methods {
                 lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
                 rawset_field(state, -2, MetaMethod::validate(&k)?)?;
             }
             for (k, f) in ud_fields.meta_fields {
-                lua.push_value(f(mem::transmute(lua))?)?;
+                lua.push_value(f(lua, MultiValue::new())?.pop_front().unwrap())?;
                 rawset_field(state, -2, MetaMethod::validate(&k)?)?;
             }
             let metatable_index = ffi::lua_absindex(state, -1);
@@ -401,7 +403,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(state, 0, field_getters_nrec as c_int, true)?;
+                push_table(state, 0, field_getters_nrec, true)?;
                 for (k, m) in ud_fields.field_getters {
                     lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
                     rawset_field(state, -2, &k)?;
@@ -412,7 +414,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(state, 0, field_setters_nrec as c_int, true)?;
+                push_table(state, 0, field_setters_nrec, true)?;
                 for (k, m) in ud_fields.field_setters {
                     lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
                     rawset_field(state, -2, &k)?;
@@ -424,7 +426,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(state, 0, methods_nrec as c_int, true)?;
+                push_table(state, 0, methods_nrec, true)?;
                 for (k, m) in ud_methods.methods {
                     lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
                     rawset_field(state, -2, &k)?;
@@ -432,12 +434,21 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                 methods_index = Some(ffi::lua_absindex(state, -1));
             }
 
-            init_userdata_metatable::<UserDataCell<T>>(
+            #[cfg(feature = "luau")]
+            let extra_init = None;
+            #[cfg(not(feature = "luau"))]
+            let extra_init: Option<fn(*mut ffi::lua_State) -> Result<()>> = Some(|state| {
+                ffi::lua_pushcfunction(state, util::userdata_destructor::<UserDataCell<T>>);
+                rawset_field(state, -2, "__gc")
+            });
+
+            init_userdata_metatable(
                 state,
                 metatable_index,
                 field_getters_index,
                 field_setters_index,
                 methods_index,
+                extra_init,
             )?;
 
             let count = field_getters_index.map(|_| 1).unwrap_or(0)
@@ -475,7 +486,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                 #[cfg(feature = "lua54")]
                 for i in 1..=USER_VALUE_MAXSLOT {
                     ffi::lua_pushnil(state);
-                    ffi::lua_setiuservalue(state, -2, i as c_int);
+                    ffi::lua_setiuservalue(state, -2, i as _);
                 }
                 #[cfg(any(feature = "lua53", feature = "lua52", feature = "luau"))]
                 {
@@ -607,12 +618,28 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     }
 
     #[cfg(feature = "async")]
-    fn add_async_method<M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
+    fn add_async_method<'s, M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
     where
-        T: Clone,
-        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 'lua,
+        MR: Future<Output = Result<R>> + 's,
+        R: IntoLuaMulti<'lua>,
+    {
+        // The panic should never happen as async non-static code wouldn't compile
+        // Non-static lifetime must be bounded to 'lua lifetime
+        panic!("asynchronous methods are not supported for non-static userdata")
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_method_mut<'s, M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
+    where
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>,
     {
         // The panic should never happen as async non-static code wouldn't compile
@@ -682,12 +709,28 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
     }
 
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
+    fn add_async_meta_method<'s, M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
     where
-        T: Clone,
-        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 'lua,
+        MR: Future<Output = Result<R>> + 's,
+        R: IntoLuaMulti<'lua>,
+    {
+        // The panic should never happen as async non-static code wouldn't compile
+        // Non-static lifetime must be bounded to 'lua lifetime
+        panic!("asynchronous meta methods are not supported for non-static userdata")
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method_mut<'s, M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
+    where
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>,
     {
         // The panic should never happen as async non-static code wouldn't compile
@@ -734,15 +777,16 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
 }
 
 struct NonStaticUserDataFields<'lua, T: UserData> {
+    fields: Vec<(String, Callback<'lua, 'static>)>,
     field_getters: Vec<(String, NonStaticMethod<'lua, T>)>,
     field_setters: Vec<(String, NonStaticMethod<'lua, T>)>,
-    #[allow(clippy::type_complexity)]
-    meta_fields: Vec<(String, Box<dyn Fn(&'lua Lua) -> Result<Value<'lua>>>)>,
+    meta_fields: Vec<(String, Callback<'lua, 'static>)>,
 }
 
 impl<'lua, T: UserData> Default for NonStaticUserDataFields<'lua, T> {
     fn default() -> NonStaticUserDataFields<'lua, T> {
         NonStaticUserDataFields {
+            fields: Vec::new(),
             field_getters: Vec::new(),
             field_setters: Vec::new(),
             meta_fields: Vec::new(),
@@ -751,6 +795,17 @@ impl<'lua, T: UserData> Default for NonStaticUserDataFields<'lua, T> {
 }
 
 impl<'lua, T: UserData> UserDataFields<'lua, T> for NonStaticUserDataFields<'lua, T> {
+    fn add_field<V>(&mut self, name: impl AsRef<str>, value: V)
+    where
+        V: IntoLua<'lua> + Clone + 'static,
+    {
+        let name = name.as_ref().to_string();
+        self.fields.push((
+            name,
+            Box::new(move |lua, _| value.clone().into_lua_multi(lua)),
+        ));
+    }
+
     fn add_field_method_get<M, R>(&mut self, name: impl AsRef<str>, method: M)
     where
         M: Fn(&'lua Lua, &T) -> Result<R> + MaybeSend + 'static,
@@ -796,30 +851,30 @@ impl<'lua, T: UserData> UserDataFields<'lua, T> for NonStaticUserDataFields<'lua
         self.field_setters.push((name.as_ref().into(), func));
     }
 
+    fn add_meta_field<V>(&mut self, name: impl AsRef<str>, value: V)
+    where
+        V: IntoLua<'lua> + Clone + 'static,
+    {
+        let name = name.as_ref().to_string();
+        let name2 = name.clone();
+        self.meta_fields.push((
+            name,
+            Box::new(move |lua, _| {
+                UserDataRegistry::<()>::check_meta_field(lua, &name2, value.clone())
+            }),
+        ));
+    }
+
     fn add_meta_field_with<F, R>(&mut self, name: impl AsRef<str>, f: F)
     where
         F: Fn(&'lua Lua) -> Result<R> + MaybeSend + 'static,
         R: IntoLua<'lua>,
     {
         let name = name.as_ref().to_string();
+        let name2 = name.clone();
         self.meta_fields.push((
-            name.clone(),
-            Box::new(move |lua| {
-                let value = f(lua)?.into_lua(lua)?;
-                if name == MetaMethod::Index || name == MetaMethod::NewIndex {
-                    match value {
-                        Value::Nil | Value::Table(_) | Value::Function(_) => {}
-                        _ => {
-                            return Err(Error::MetaMethodTypeError {
-                                method: name.clone(),
-                                type_name: value.type_name(),
-                                message: Some("expected nil, table or function".to_string()),
-                            })
-                        }
-                    }
-                }
-                Ok(value)
-            }),
+            name,
+            Box::new(move |lua, _| UserDataRegistry::<()>::check_meta_field(lua, &name2, f(lua)?)),
         ));
     }
 }

src/serde/de.rs

@@ -124,7 +124,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             #[allow(clippy::useless_conversion)]
             Value::Number(n) => visitor.visit_f64(n.into()),
             #[cfg(feature = "luau")]
-            Value::Vector(_, _, _) => self.deserialize_seq(visitor),
+            Value::Vector(_) => self.deserialize_seq(visitor),
             Value::String(s) => match s.to_str() {
                 Ok(s) => visitor.visit_str(s),
                 Err(_) => visitor.visit_bytes(s.as_bytes()),
@@ -223,9 +223,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     {
         match self.value {
             #[cfg(feature = "luau")]
-            Value::Vector(x, y, z) => {
+            Value::Vector(vec) => {
                 let mut deserializer = VecDeserializer {
-                    vec: [x, y, z],
+                    vec,
                     next: 0,
                     options: self.options,
                     visited: self.visited,
@@ -237,7 +237,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
 
                 let len = t.raw_len() as usize;
                 let mut deserializer = SeqDeserializer {
-                    seq: t.raw_sequence_values(),
+                    seq: t.sequence_values(),
                     options: self.options,
                     visited: self.visited,
                 };
@@ -412,7 +412,7 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
 
 #[cfg(feature = "luau")]
 struct VecDeserializer {
-    vec: [f32; 3],
+    vec: crate::types::Vector,
     next: usize,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
@@ -426,7 +426,7 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
     where
         T: de::DeserializeSeed<'de>,
     {
-        match self.vec.get(self.next) {
+        match self.vec.0.get(self.next) {
             Some(&n) => {
                 self.next += 1;
                 let visited = Rc::clone(&self.visited);
@@ -439,7 +439,7 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
     }
 
     fn size_hint(&self) -> Option<usize> {
-        Some(3)
+        Some(crate::types::Vector::SIZE)
     }
 }
 

src/serde/mod.rs

@@ -1,21 +1,19 @@
 //! (De)Serialization support using serde.
 
 use std::os::raw::c_void;
-use std::ptr;
 
-use serde::{Deserialize, Serialize};
+use serde::{de::DeserializeOwned, ser::Serialize};
 
 use crate::error::Result;
 use crate::lua::Lua;
 use crate::private::Sealed;
 use crate::table::Table;
-use crate::types::LightUserData;
 use crate::util::check_stack;
 use crate::value::Value;
 
 /// Trait for serializing/deserializing Lua values using Serde.
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
-pub trait LuaSerdeExt<'lua>: Sealed {
+pub trait LuaSerdeExt: Sealed {
     /// A special value (lightuserdata) to encode/decode optional (none) values.
     ///
     /// Requires `feature = "serialize"`
@@ -37,7 +35,7 @@ pub trait LuaSerdeExt<'lua>: Sealed {
     ///     Ok(())
     /// }
     /// ```
-    fn null(&'lua self) -> Value<'lua>;
+    fn null(&self) -> Value;
 
     /// A metatable attachable to a Lua table to systematically encode it as Array (instead of Map).
     /// As result, encoded Array will contain only sequence part of the table, with the same length
@@ -68,7 +66,7 @@ pub trait LuaSerdeExt<'lua>: Sealed {
     ///     Ok(())
     /// }
     /// ```
-    fn array_metatable(&'lua self) -> Table<'lua>;
+    fn array_metatable(&self) -> Table;
 
     /// Converts `T` into a [`Value`] instance.
     ///
@@ -101,7 +99,7 @@ pub trait LuaSerdeExt<'lua>: Sealed {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value<T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
+    fn to_value<'lua, T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
 
     /// Converts `T` into a [`Value`] instance with options.
     ///
@@ -126,7 +124,7 @@ pub trait LuaSerdeExt<'lua>: Sealed {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<'lua, T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
     where
         T: Serialize + ?Sized;
 
@@ -159,7 +157,7 @@ pub trait LuaSerdeExt<'lua>: Sealed {
     /// }
     /// ```
     #[allow(clippy::wrong_self_convention)]
-    fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> Result<T>;
+    fn from_value<T: DeserializeOwned>(&self, value: Value) -> Result<T>;
 
     /// Deserializes a [`Value`] into any serde deserializable object with options.
     ///
@@ -191,49 +189,46 @@ pub trait LuaSerdeExt<'lua>: Sealed {
     /// }
     /// ```
     #[allow(clippy::wrong_self_convention)]
-    fn from_value_with<T: Deserialize<'lua>>(
-        &'lua self,
-        value: Value<'lua>,
-        options: de::Options,
-    ) -> Result<T>;
+    fn from_value_with<T: DeserializeOwned>(&self, value: Value, options: de::Options)
+        -> Result<T>;
 }
 
-impl<'lua> LuaSerdeExt<'lua> for Lua {
-    fn null(&'lua self) -> Value<'lua> {
-        Value::LightUserData(LightUserData(ptr::null_mut()))
+impl LuaSerdeExt for Lua {
+    fn null(&self) -> Value {
+        Value::NULL
     }
 
-    fn array_metatable(&'lua self) -> Table<'lua> {
+    fn array_metatable(&self) -> Table {
         unsafe {
             push_array_metatable(self.ref_thread());
             Table(self.pop_ref_thread())
         }
     }
 
-    fn to_value<T>(&'lua self, t: &T) -> Result<Value<'lua>>
+    fn to_value<'lua, T>(&'lua self, t: &T) -> Result<Value<'lua>>
     where
         T: Serialize + ?Sized,
     {
         t.serialize(ser::Serializer::new(self))
     }
 
-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<'lua, T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
     where
         T: Serialize + ?Sized,
     {
         t.serialize(ser::Serializer::new_with_options(self, options))
     }
 
-    fn from_value<T>(&'lua self, value: Value<'lua>) -> Result<T>
+    fn from_value<T>(&self, value: Value) -> Result<T>
     where
-        T: Deserialize<'lua>,
+        T: DeserializeOwned,
     {
         T::deserialize(de::Deserializer::new(value))
     }
 
-    fn from_value_with<T>(&'lua self, value: Value<'lua>, options: de::Options) -> Result<T>
+    fn from_value_with<T>(&self, value: Value, options: de::Options) -> Result<T>
     where
-        T: Deserialize<'lua>,
+        T: DeserializeOwned,
     {
         T::deserialize(de::Deserializer::new_with_options(value, options))
     }

src/serde/ser.rs

@@ -1,5 +1,3 @@
-use std::os::raw::c_int;
-
 use serde::{ser, Serialize};
 
 use super::LuaSerdeExt;
@@ -7,8 +5,6 @@ use crate::error::{Error, Result};
 use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
-use crate::types::Integer;
-use crate::util::{check_stack, StackGuard};
 use crate::value::{IntoLua, Value};
 
 /// A struct for serializing Rust values into Lua values.
@@ -120,9 +116,9 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     // Associated types for keeping track of additional state while serializing
     // compound data structures like sequences and maps.
-    type SerializeSeq = SerializeVec<'lua>;
-    type SerializeTuple = SerializeVec<'lua>;
-    type SerializeTupleStruct = SerializeVec<'lua>;
+    type SerializeSeq = SerializeSeq<'lua>;
+    type SerializeTuple = SerializeSeq<'lua>;
+    type SerializeTupleStruct = SerializeSeq<'lua>;
     type SerializeTupleVariant = SerializeTupleVariant<'lua>;
     type SerializeMap = SerializeMap<'lua>;
     type SerializeStruct = SerializeMap<'lua>;
@@ -235,13 +231,11 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     #[inline]
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        let len = len.unwrap_or(0) as c_int;
-        let table = self.lua.create_table_with_capacity(len, 0)?;
+        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()));
         }
-        let options = self.options;
-        Ok(SerializeVec { table, options })
+        Ok(SerializeSeq::new(table, self.options))
     }
 
     #[inline]
@@ -252,9 +246,14 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     #[inline]
     fn serialize_tuple_struct(
         self,
-        _name: &'static str,
+        name: &'static str,
         len: usize,
     ) -> Result<Self::SerializeTupleStruct> {
+        #[cfg(feature = "luau")]
+        if name == "Vector" && len == crate::types::Vector::SIZE {
+            return Ok(SerializeSeq::new_vector(self.lua, self.options));
+        }
+        _ = name;
         self.serialize_seq(Some(len))
     }
 
@@ -275,10 +274,9 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     #[inline]
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
-        let len = len.unwrap_or(0) as c_int;
         Ok(SerializeMap {
             key: None,
-            table: self.lua.create_table_with_capacity(0, len)?,
+            table: self.lua.create_table_with_capacity(0, len.unwrap_or(0))?,
             options: self.options,
         })
     }
@@ -298,19 +296,47 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     ) -> Result<Self::SerializeStructVariant> {
         Ok(SerializeStructVariant {
             name: self.lua.create_string(variant)?,
-            table: self.lua.create_table_with_capacity(0, len as c_int)?,
+            table: self.lua.create_table_with_capacity(0, len)?,
             options: self.options,
         })
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeVec<'lua> {
-    table: Table<'lua>,
+pub struct SerializeSeq<'lua> {
+    lua: &'lua Lua,
+    #[cfg(feature = "luau")]
+    vector: Option<crate::types::Vector>,
+    table: Option<Table<'lua>>,
+    next: usize,
     options: Options,
 }
 
-impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
+impl<'lua> SerializeSeq<'lua> {
+    const fn new(table: Table<'lua>, options: Options) -> Self {
+        Self {
+            lua: table.0.lua,
+            #[cfg(feature = "luau")]
+            vector: None,
+            table: Some(table),
+            next: 0,
+            options,
+        }
+    }
+
+    #[cfg(feature = "luau")]
+    const fn new_vector(lua: &'lua Lua, options: Options) -> Self {
+        Self {
+            lua,
+            vector: Some(crate::types::Vector::zero()),
+            table: None,
+            next: 0,
+            options,
+        }
+    }
+}
+
+impl<'lua> ser::SerializeSeq for SerializeSeq<'lua> {
     type Ok = Value<'lua>;
     type Error = Error;
 
@@ -318,35 +344,19 @@ impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        let state = lua.state();
-        let value = lua.to_value_with(value, self.options)?;
-        unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 4)?;
-
-            lua.push_ref(&self.table.0);
-            lua.push_value(value)?;
-            if lua.unlikely_memory_error() {
-                let len = ffi::lua_rawlen(state, -2) as Integer;
-                ffi::lua_rawseti(state, -2, len + 1);
-                ffi::lua_pop(state, 1);
-                Ok(())
-            } else {
-                protect_lua!(state, 2, 0, fn(state) {
-                    let len = ffi::lua_rawlen(state, -2) as Integer;
-                    ffi::lua_rawseti(state, -2, len + 1);
-                })
-            }
-        }
+        let value = self.lua.to_value_with(value, self.options)?;
+        let table = self.table.as_ref().unwrap();
+        table.raw_seti(self.next + 1, value)?;
+        self.next += 1;
+        Ok(())
     }
 
     fn end(self) -> Result<Value<'lua>> {
-        Ok(Value::Table(self.table))
+        Ok(Value::Table(self.table.unwrap()))
     }
 }
 
-impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
+impl<'lua> ser::SerializeTuple for SerializeSeq<'lua> {
     type Ok = Value<'lua>;
     type Error = Error;
 
@@ -362,7 +372,7 @@ impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
     }
 }
 
-impl<'lua> ser::SerializeTupleStruct for SerializeVec<'lua> {
+impl<'lua> ser::SerializeTupleStruct for SerializeSeq<'lua> {
     type Ok = Value<'lua>;
     type Error = Error;
 
@@ -370,10 +380,22 @@ impl<'lua> ser::SerializeTupleStruct for SerializeVec<'lua> {
     where
         T: Serialize + ?Sized,
     {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector.as_mut() {
+            let value = self.lua.to_value_with(value, self.options)?;
+            let value = self.lua.unpack(value)?;
+            vector.0[self.next] = value;
+            self.next += 1;
+            return Ok(());
+        }
         ser::SerializeSeq::serialize_element(self, value)
     }
 
     fn end(self) -> Result<Value<'lua>> {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector {
+            return Ok(Value::Vector(vector));
+        }
         ser::SerializeSeq::end(self)
     }
 }
@@ -394,9 +416,7 @@ impl<'lua> ser::SerializeTupleVariant for SerializeTupleVariant<'lua> {
         T: Serialize + ?Sized,
     {
         let lua = self.table.0.lua;
-        let idx = self.table.raw_len() + 1;
-        self.table
-            .raw_insert(idx, lua.to_value_with(value, self.options)?)
+        self.table.raw_push(lua.to_value_with(value, self.options)?)
     }
 
     fn end(self) -> Result<Value<'lua>> {

src/string.rs

@@ -139,8 +139,7 @@ impl<'lua> String<'lua> {
     /// Typically this function is used only for hashing and debug information.
     #[inline]
     pub fn to_pointer(&self) -> *const c_void {
-        let ref_thread = self.0.lua.ref_thread();
-        unsafe { ffi::lua_topointer(ref_thread, self.0.index) }
+        self.0.to_pointer()
     }
 
     /// Convert this handle to owned version.

src/table.rs

@@ -18,7 +18,7 @@ use crate::util::{assert_stack, check_stack, StackGuard};
 use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Nil, Value};
 
 #[cfg(feature = "async")]
-use {futures_core::future::LocalBoxFuture, futures_util::future};
+use futures_util::future::{self, LocalBoxFuture};
 
 /// Handle to an internal Lua table.
 #[derive(Clone)]
@@ -45,7 +45,6 @@ impl OwnedTable {
     }
 }
 
-#[allow(clippy::len_without_is_empty)]
 impl<'lua> Table<'lua> {
     /// Sets a key-value pair in the table.
     ///
@@ -150,11 +149,15 @@ impl<'lua> Table<'lua> {
     }
 
     /// Checks whether the table contains a non-nil value for `key`.
+    ///
+    /// This might invoke the `__index` metamethod.
     pub fn contains_key<K: IntoLua<'lua>>(&self, key: K) -> Result<bool> {
         Ok(self.get::<_, Value>(key)? != Value::Nil)
     }
 
     /// Appends a value to the back of the table.
+    ///
+    /// This might invoke the `__len` and `__newindex` metamethods.
     pub fn push<V: IntoLua<'lua>>(&self, value: V) -> Result<()> {
         // Fast track
         if !self.has_metatable() {
@@ -179,6 +182,8 @@ impl<'lua> Table<'lua> {
     }
 
     /// Removes the last element from the table and returns it.
+    ///
+    /// This might invoke the `__len` and `__newindex` metamethods.
     pub fn pop<V: FromLua<'lua>>(&self) -> Result<V> {
         // Fast track
         if !self.has_metatable() {
@@ -314,7 +319,7 @@ impl<'lua> Table<'lua> {
 
         let size = self.raw_len();
         if idx < 1 || idx > size + 1 {
-            return Err(Error::RuntimeError("index out of bounds".to_string()));
+            return Err(Error::runtime("index out of bounds"));
         }
 
         let value = value.into_lua(lua)?;
@@ -402,7 +407,7 @@ impl<'lua> Table<'lua> {
             Value::Integer(idx) => {
                 let size = self.raw_len();
                 if idx < 1 || idx > size {
-                    return Err(Error::RuntimeError("index out of bounds".to_string()));
+                    return Err(Error::runtime("index out of bounds"));
                 }
                 unsafe {
                     let _sg = StackGuard::new(state);
@@ -492,6 +497,32 @@ impl<'lua> Table<'lua> {
         unsafe { ffi::lua_rawlen(ref_thread, self.0.index) as Integer }
     }
 
+    /// Returns `true` if the table is empty, without invoking metamethods.
+    ///
+    /// It checks both the array part and the hash part.
+    pub fn is_empty(&self) -> bool {
+        // Check array part
+        if self.raw_len() != 0 {
+            return false;
+        }
+
+        // Check hash part
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 4);
+
+            lua.push_ref(&self.0);
+            ffi::lua_pushnil(state);
+            if ffi::lua_next(state, -2) != 0 {
+                return false;
+            }
+        }
+
+        true
+    }
+
     /// Returns a reference to the metatable of this table, or `None` if no metatable is set.
     ///
     /// Unlike the `getmetatable` Lua function, this method ignores the `__metatable` field.
@@ -586,8 +617,7 @@ impl<'lua> Table<'lua> {
     /// Typically this function is used only for hashing and debug information.
     #[inline]
     pub fn to_pointer(&self) -> *const c_void {
-        let ref_thread = self.0.lua.ref_thread();
-        unsafe { ffi::lua_topointer(ref_thread, self.0.index) }
+        self.0.to_pointer()
     }
 
     /// Convert this handle to owned version.
@@ -641,12 +671,9 @@ impl<'lua> Table<'lua> {
 
     /// Consume this table and return an iterator over all values in the sequence part of the table.
     ///
-    /// The iterator will yield all values `t[1]`, `t[2]`, and so on, until a `nil` value is
-    /// encountered. This mirrors the behavior of Lua's `ipairs` function and will invoke the
-    /// `__index` metamethod according to the usual rules. However, the deprecated `__ipairs`
-    /// metatable will not be called.
-    ///
-    /// Just like [`pairs`], the values are wrapped in a [`Result`].
+    /// The iterator will yield all values `t[1]`, `t[2]` and so on, until a `nil` value is
+    /// encountered. This mirrors the behavior of Lua's `ipairs` function but does not invoke
+    /// any metamethods.
     ///
     /// # Note
     ///
@@ -685,28 +712,18 @@ impl<'lua> Table<'lua> {
             table: self.0,
             index: Some(1),
             len: None,
-            raw: false,
             _phantom: PhantomData,
         }
     }
 
-    /// Consume this table and return an iterator over all values in the sequence part of the table.
-    ///
-    /// Unlike the `sequence_values`, does not invoke `__index` metamethod when iterating.
-    ///
-    /// [`sequence_values`]: #method.sequence_values
+    #[doc(hidden)]
+    #[deprecated(since = "0.9.0", note = "use `sequence_values` instead")]
     pub fn raw_sequence_values<V: FromLua<'lua>>(self) -> TableSequence<'lua, V> {
-        TableSequence {
-            table: self.0,
-            index: Some(1),
-            len: None,
-            raw: true,
-            _phantom: PhantomData,
-        }
+        self.sequence_values()
     }
 
-    #[cfg(any(feature = "serialize"))]
-    pub(crate) fn raw_sequence_values_by_len<V: FromLua<'lua>>(
+    #[cfg(feature = "serialize")]
+    pub(crate) fn sequence_values_by_len<V: FromLua<'lua>>(
         self,
         len: Option<Integer>,
     ) -> TableSequence<'lua, V> {
@@ -715,11 +732,37 @@ impl<'lua> Table<'lua> {
             table: self.0,
             index: Some(1),
             len: Some(len),
-            raw: true,
             _phantom: PhantomData,
         }
     }
 
+    /// Sets element value at position `idx` without invoking metamethods.
+    #[allow(dead_code)]
+    pub(crate) fn raw_seti<V: IntoLua<'lua>>(&self, idx: usize, value: V) -> Result<()> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
+        let lua = self.0.lua;
+        let state = lua.state();
+        let value = value.into_lua(lua)?;
+
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 5)?;
+
+            lua.push_ref(&self.0);
+            lua.push_value(value)?;
+
+            let idx = idx.try_into().unwrap();
+            if lua.unlikely_memory_error() {
+                ffi::lua_rawseti(state, -2, idx);
+            } else {
+                protect_lua!(state, 2, 0, |state| ffi::lua_rawseti(state, -2, idx))?;
+            }
+            Ok(())
+        }
+    }
+
     #[cfg(feature = "serialize")]
     pub(crate) fn is_array(&self) -> bool {
         let lua = self.0.lua;
@@ -741,8 +784,7 @@ impl<'lua> Table<'lua> {
     #[inline(always)]
     pub(crate) fn check_readonly_write(&self) -> Result<()> {
         if self.is_readonly() {
-            let err = "attempt to modify a readonly table".to_string();
-            return Err(Error::RuntimeError(err));
+            return Err(Error::runtime("attempt to modify a readonly table"));
         }
         Ok(())
     }
@@ -797,6 +839,56 @@ impl<'lua> AsRef<Table<'lua>> for Table<'lua> {
     }
 }
 
+impl<'lua, T> PartialEq<[T]> for Table<'lua>
+where
+    T: IntoLua<'lua> + Clone,
+{
+    fn eq(&self, other: &[T]) -> bool {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 4);
+
+            lua.push_ref(&self.0);
+
+            let len = ffi::lua_rawlen(state, -1);
+            for i in 0..len {
+                ffi::lua_rawgeti(state, -1, (i + 1) as _);
+                let val = lua.pop_value();
+                if val == Nil {
+                    return i == other.len();
+                }
+                match other.get(i).map(|v| v.clone().into_lua(lua)) {
+                    Some(Ok(other_val)) if val == other_val => continue,
+                    _ => return false,
+                }
+            }
+        }
+        true
+    }
+}
+
+impl<'lua, T> PartialEq<&[T]> for Table<'lua>
+where
+    T: IntoLua<'lua> + Clone,
+{
+    #[inline]
+    fn eq(&self, other: &&[T]) -> bool {
+        self == *other
+    }
+}
+
+impl<'lua, T, const N: usize> PartialEq<[T; N]> for Table<'lua>
+where
+    T: IntoLua<'lua> + Clone,
+{
+    #[inline]
+    fn eq(&self, other: &[T; N]) -> bool {
+        self == &other[..]
+    }
+}
+
 /// An extension trait for `Table`s that provides a variety of convenient functionality.
 pub trait TableExt<'lua>: Sealed {
     /// Calls the table as function assuming it has `__call` metamethod.
@@ -812,11 +904,10 @@ pub trait TableExt<'lua>: Sealed {
     /// The metamethod is called with the table as its first argument, followed by the passed arguments.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async<A, R>(&self, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut;
+        R: FromLuaMulti<'lua> + 'lua;
 
     /// Gets the function associated to `key` from the table and executes it,
     /// passing the table itself along with `args` as function arguments.
@@ -825,9 +916,8 @@ pub trait TableExt<'lua>: Sealed {
     /// `table.get::<_, Function>(key)?.call((table.clone(), arg1, ..., argN))`
     ///
     /// This might invoke the `__index` metamethod.
-    fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
+    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
     where
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
@@ -838,9 +928,8 @@ pub trait TableExt<'lua>: Sealed {
     /// `table.get::<_, Function>(key)?.call(args)`
     ///
     /// This might invoke the `__index` metamethod.
-    fn call_function<K, A, R>(&self, key: K, args: A) -> Result<R>
+    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
     where
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
@@ -852,12 +941,10 @@ pub trait TableExt<'lua>: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_method<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_method<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut;
+        R: FromLuaMulti<'lua> + 'lua;
 
     /// Gets the function associated to `key` from the table and asynchronously executes it,
     /// passing `args` as function arguments and returning Future.
@@ -867,16 +954,10 @@ pub trait TableExt<'lua>: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_function<'fut, K, A, R>(
-        &self,
-        key: K,
-        args: A,
-    ) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_function<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut;
+        R: FromLuaMulti<'lua> + 'lua;
 }
 
 impl<'lua> TableExt<'lua> for Table<'lua> {
@@ -890,43 +971,43 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
     }
 
     #[cfg(feature = "async")]
-    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async<A, R>(&self, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
-        Function(self.0.clone()).call_async(args)
+        let args = match args.into_lua_multi(self.0.lua) {
+            Ok(args) => args,
+            Err(e) => return Box::pin(future::err(e)),
+        };
+        let func = Function(self.0.clone());
+        Box::pin(async move { func.call_async(args).await })
     }
 
-    fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
+    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
     where
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         let lua = self.0.lua;
         let mut args = args.into_lua_multi(lua)?;
         args.push_front(Value::Table(self.clone()));
-        self.get::<_, Function>(key)?.call(args)
+        self.get::<_, Function>(name)?.call(args)
     }
 
-    fn call_function<K, A, R>(&self, key: K, args: A) -> Result<R>
+    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
     where
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
-        self.get::<_, Function>(key)?.call(args)
+        self.get::<_, Function>(name)?.call(args)
     }
 
     #[cfg(feature = "async")]
-    fn call_async_method<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_method<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
         let lua = self.0.lua;
         let mut args = match args.into_lua_multi(lua) {
@@ -934,19 +1015,22 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
             Err(e) => return Box::pin(future::err(e)),
         };
         args.push_front(Value::Table(self.clone()));
-        self.call_async_function(key, args)
+        self.call_async_function(name, args)
     }
 
     #[cfg(feature = "async")]
-    fn call_async_function<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_function<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
-        K: IntoLua<'lua>,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
-        match self.get::<_, Function>(key) {
-            Ok(func) => func.call_async(args),
+        let lua = self.0.lua;
+        let args = match args.into_lua_multi(lua) {
+            Ok(args) => args,
+            Err(e) => return Box::pin(future::err(e)),
+        };
+        match self.get::<_, Function>(name) {
+            Ok(func) => Box::pin(async move { func.call_async(args).await }),
             Err(e) => Box::pin(future::err(e)),
         }
     }
@@ -975,7 +1059,7 @@ impl<'lua> Serialize for Table<'lua> {
             let len = self.raw_len() as usize;
             if len > 0 || self.is_array() {
                 let mut seq = serializer.serialize_seq(Some(len))?;
-                for v in self.clone().raw_sequence_values_by_len::<Value>(None) {
+                for v in self.clone().sequence_values_by_len::<Value>(None) {
                     let v = v.map_err(serde::ser::Error::custom)?;
                     seq.serialize_element(&v)?;
                 }
@@ -1065,7 +1149,6 @@ pub struct TableSequence<'lua, V> {
     table: LuaRef<'lua>,
     index: Option<Integer>,
     len: Option<Integer>,
-    raw: bool,
     _phantom: PhantomData<V>,
 }
 
@@ -1082,15 +1165,10 @@ where
 
             let res = (|| unsafe {
                 let _sg = StackGuard::new(state);
-                check_stack(state, 1 + if self.raw { 0 } else { 3 })?;
+                check_stack(state, 1)?;
 
                 lua.push_ref(&self.table);
-                let res = if self.raw {
-                    ffi::lua_rawgeti(state, -1, index)
-                } else {
-                    protect_lua!(state, 1, 1, |state| ffi::lua_geti(state, -1, index))?
-                };
-                match res {
+                match ffi::lua_rawgeti(state, -1, index) {
                     ffi::LUA_TNIL if index > self.len.unwrap_or(0) => Ok(None),
                     _ => Ok(Some((index, lua.pop_value()))),
                 }

src/thread.rs

@@ -8,13 +8,6 @@ use crate::types::LuaRef;
 use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
 use crate::value::{FromLuaMulti, IntoLuaMulti};
 
-#[cfg(any(
-    feature = "lua54",
-    all(feature = "luajit", feature = "vendored"),
-    feature = "luau",
-))]
-use crate::function::Function;
-
 #[cfg(not(feature = "luau"))]
 use crate::{
     hook::{Debug, HookTriggers},
@@ -27,8 +20,9 @@ use {
         lua::ASYNC_POLL_PENDING,
         value::{MultiValue, Value},
     },
-    futures_core::{future::Future, stream::Stream},
+    futures_util::stream::Stream,
     std::{
+        future::Future,
         marker::PhantomData,
         pin::Pin,
         ptr::NonNull,
@@ -59,14 +53,14 @@ pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
 ///
 /// Requires `feature = "async"`
 ///
-/// [`Future`]: futures_core::future::Future
-/// [`Stream`]: futures_core::stream::Stream
+/// [`Future`]: std::future::Future
+/// [`Stream`]: futures_util::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AsyncThread<'lua, R> {
     thread: Thread<'lua>,
-    args0: Option<Result<MultiValue<'lua>>>,
+    init_args: Option<Result<MultiValue<'lua>>>,
     ret: PhantomData<R>,
     recycle: bool,
 }
@@ -208,21 +202,17 @@ impl<'lua> Thread<'lua> {
     /// Returns a error in case of either the original error that stopped the thread or errors
     /// in closing methods.
     ///
-    /// In [LuaJIT] and Luau: resets to the initial state of a newly created Lua thread.
+    /// In Luau: resets to the initial state of a newly created Lua thread.
     /// Lua threads in arbitrary states (like yielded or errored) can be reset properly.
     ///
     /// Sets a Lua function for the thread afterwards.
     ///
-    /// Requires `feature = "lua54"` OR `feature = "luajit,vendored"` OR `feature = "luau"`
+    /// Requires `feature = "lua54"` OR `feature = "luau"`.
     ///
-    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_resetthread
-    /// [LuaJIT]: https://github.com/openresty/luajit2#lua_resetthread
-    #[cfg(any(
-        feature = "lua54",
-        all(feature = "luajit", feature = "vendored"),
-        feature = "luau",
-    ))]
-    pub fn reset(&self, func: Function<'lua>) -> Result<()> {
+    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_closethread
+    #[cfg(any(feature = "lua54", feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn reset(&self, func: crate::function::Function<'lua>) -> Result<()> {
         let lua = self.0.lua;
         let state = lua.state();
         unsafe {
@@ -232,14 +222,14 @@ impl<'lua> Thread<'lua> {
             lua.push_ref(&self.0);
             let thread_state = ffi::lua_tothread(state, -1);
 
-            #[cfg(feature = "lua54")]
+            #[cfg(all(feature = "lua54", not(feature = "vendored")))]
             let status = ffi::lua_resetthread(thread_state);
+            #[cfg(all(feature = "lua54", feature = "vendored"))]
+            let status = ffi::lua_closethread(thread_state, state);
             #[cfg(feature = "lua54")]
             if status != ffi::LUA_OK {
                 return Err(pop_error(thread_state, status));
             }
-            #[cfg(all(feature = "luajit", feature = "vendored"))]
-            ffi::lua_resetthread(state, thread_state);
             #[cfg(feature = "luau")]
             ffi::lua_resetthread(thread_state);
 
@@ -248,8 +238,8 @@ impl<'lua> Thread<'lua> {
 
             #[cfg(feature = "luau")]
             {
-                // Inherit `LUA_GLOBALSINDEX` from the caller
-                ffi::lua_xpush(state, thread_state, ffi::LUA_GLOBALSINDEX);
+                // Inherit `LUA_GLOBALSINDEX` from the main thread
+                ffi::lua_xpush(lua.main_state(), thread_state, ffi::LUA_GLOBALSINDEX);
                 ffi::lua_replace(thread_state, ffi::LUA_GLOBALSINDEX);
             }
 
@@ -269,8 +259,8 @@ impl<'lua> Thread<'lua> {
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`Future`]: futures_core::future::Future
-    /// [`Stream`]: futures_core::stream::Stream
+    /// [`Future`]: std::future::Future
+    /// [`Stream`]: futures_util::stream::Stream
     /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
     ///
     /// # Examples
@@ -312,7 +302,7 @@ impl<'lua> Thread<'lua> {
         let args = args.into_lua_multi(self.0.lua);
         AsyncThread {
             thread: self,
-            args0: Some(args),
+            init_args: Some(args),
             ret: PhantomData,
             recycle: false,
         }
@@ -357,11 +347,8 @@ impl<'lua> Thread<'lua> {
         let state = lua.state();
         unsafe {
             let thread = ffi::lua_tothread(lua.ref_thread(), self.0.index);
-            check_stack(thread, 1)?;
+            check_stack(thread, 3)?;
             check_stack(state, 3)?;
-            // Inherit `LUA_GLOBALSINDEX` from the caller
-            ffi::lua_xpush(state, thread, ffi::LUA_GLOBALSINDEX);
-            ffi::lua_replace(thread, ffi::LUA_GLOBALSINDEX);
             protect_lua!(state, 0, 0, |_| ffi::luaL_sandboxthread(thread))
         }
     }
@@ -382,11 +369,7 @@ impl<'lua, R> AsyncThread<'lua, R> {
 }
 
 #[cfg(feature = "async")]
-#[cfg(any(
-    feature = "lua54",
-    all(feature = "luajit", feature = "vendored"),
-    feature = "luau",
-))]
+#[cfg(any(feature = "lua54", feature = "luau"))]
 impl<'lua, R> Drop for AsyncThread<'lua, R> {
     fn drop(&mut self) {
         if self.recycle {
@@ -397,7 +380,10 @@ impl<'lua, R> Drop for AsyncThread<'lua, R> {
                     #[cfg(feature = "lua54")]
                     if self.thread.status() == ThreadStatus::Error {
                         let thread_state = ffi::lua_tothread(lua.ref_thread(), self.thread.0.index);
+                        #[cfg(not(feature = "vendored"))]
                         ffi::lua_resetthread(thread_state);
+                        #[cfg(feature = "vendored")]
+                        ffi::lua_closethread(thread_state, lua.state());
                     }
                 }
             }
@@ -424,7 +410,7 @@ where
 
         // This is safe as we are not moving the whole struct
         let this = unsafe { self.get_unchecked_mut() };
-        let ret: MultiValue = if let Some(args) = this.args0.take() {
+        let ret: MultiValue = if let Some(args) = this.init_args.take() {
             this.thread.resume(args?)?
         } else {
             this.thread.resume(())?
@@ -458,7 +444,7 @@ where
 
         // This is safe as we are not moving the whole struct
         let this = unsafe { self.get_unchecked_mut() };
-        let ret: MultiValue = if let Some(args) = this.args0.take() {
+        let ret: MultiValue = if let Some(args) = this.init_args.take() {
             this.thread.resume(args?)?
         } else {
             this.thread.resume(())?

src/types.rs

@@ -1,26 +1,30 @@
-use std::cell::UnsafeCell;
+use std::any::{Any, TypeId};
+use std::cell::{Cell, Ref, RefCell, RefMut, UnsafeCell};
 use std::hash::{Hash, Hasher};
+use std::ops::{Deref, DerefMut};
 use std::os::raw::{c_int, c_void};
+use std::result::Result as StdResult;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::{fmt, mem, ptr};
 
-#[cfg(feature = "lua54")]
-use std::ffi::CStr;
+use rustc_hash::FxHashMap;
 
 #[cfg(feature = "async")]
-use futures_core::future::LocalBoxFuture;
+use futures_util::future::LocalBoxFuture;
 
 use crate::error::Result;
 #[cfg(not(feature = "luau"))]
 use crate::hook::Debug;
 use crate::lua::{ExtraData, Lua};
-use crate::util::{assert_stack, StackGuard};
 use crate::value::MultiValue;
 
 #[cfg(feature = "unstable")]
 use {crate::lua::LuaInner, std::marker::PhantomData};
 
+#[cfg(all(feature = "luau", feature = "serialize"))]
+use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
+
 /// Type of Lua integer numbers.
 pub type Integer = ffi::lua_Integer;
 /// Type of Lua floating point numbers.
@@ -71,10 +75,10 @@ pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState> + Send>;
 pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState>>;
 
 #[cfg(all(feature = "send", feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()> + Send>;
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;
 
 #[cfg(all(not(feature = "send"), feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()>>;
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()>>;
 
 #[cfg(feature = "send")]
 pub trait MaybeSend: Send {}
@@ -86,6 +90,92 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}
 
+/// A Luau vector type.
+///
+/// By default vectors are 3-dimensional, but can be 4-dimensional
+/// if the `luau-vector4` feature is enabled.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
+pub struct Vector(pub(crate) [f32; Self::SIZE]);
+
+#[cfg(any(feature = "luau", doc))]
+impl fmt::Display for Vector {
+    #[rustfmt::skip]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[cfg(not(feature = "luau-vector4"))]
+        return write!(f, "vector({}, {}, {})", self.x(), self.y(), self.z());
+        #[cfg(feature = "luau-vector4")]
+        return write!(f, "vector({}, {}, {}, {})", self.x(), self.y(), self.z(), self.w());
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Vector {
+    pub(crate) const SIZE: usize = if cfg!(feature = "luau-vector4") { 4 } else { 3 };
+
+    /// Creates a new vector.
+    #[cfg(not(feature = "luau-vector4"))]
+    pub const fn new(x: f32, y: f32, z: f32) -> Self {
+        Self([x, y, z])
+    }
+
+    /// Creates a new vector.
+    #[cfg(feature = "luau-vector4")]
+    pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
+        Self([x, y, z, w])
+    }
+
+    /// Creates a new vector with all components set to `0.0`.
+    #[doc(hidden)]
+    pub const fn zero() -> Self {
+        Self([0.0; Self::SIZE])
+    }
+
+    /// Returns 1st component of the vector.
+    pub const fn x(&self) -> f32 {
+        self.0[0]
+    }
+
+    /// Returns 2nd component of the vector.
+    pub const fn y(&self) -> f32 {
+        self.0[1]
+    }
+
+    /// Returns 3rd component of the vector.
+    pub const fn z(&self) -> f32 {
+        self.0[2]
+    }
+
+    /// Returns 4th component of the vector.
+    #[cfg(any(feature = "luau-vector4", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau-vector4")))]
+    pub const fn w(&self) -> f32 {
+        self.0[3]
+    }
+}
+
+#[cfg(all(feature = "luau", feature = "serialize"))]
+impl Serialize for Vector {
+    fn serialize<S: Serializer>(&self, serializer: S) -> StdResult<S::Ok, S::Error> {
+        let mut ts = serializer.serialize_tuple_struct("Vector", Self::SIZE)?;
+        ts.serialize_field(&self.x())?;
+        ts.serialize_field(&self.y())?;
+        ts.serialize_field(&self.z())?;
+        #[cfg(feature = "luau-vector4")]
+        ts.serialize_field(&self.w())?;
+        ts.end()
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl PartialEq<[f32; Self::SIZE]> for Vector {
+    #[inline]
+    fn eq(&self, other: &[f32; Self::SIZE]) -> bool {
+        self.0 == *other
+    }
+}
+
 pub(crate) struct DestructedUserdata;
 
 /// An auto generated key into the Lua registry.
@@ -97,14 +187,14 @@ pub(crate) struct DestructedUserdata;
 /// Be warned, If you place this into Lua via a [`UserData`] type or a rust callback, it is *very
 /// easy* to accidentally cause reference cycles that the Lua garbage collector cannot resolve.
 /// Instead of placing a [`RegistryKey`] into a [`UserData`] type, prefer instead to use
-/// [`AnyUserData::set_user_value`] / [`AnyUserData::get_user_value`].
+/// [`AnyUserData::set_user_value`] / [`AnyUserData::user_value`].
 ///
 /// [`UserData`]: crate::UserData
 /// [`RegistryKey`]: crate::RegistryKey
 /// [`Lua::remove_registry_value`]: crate::Lua::remove_registry_value
 /// [`Lua::expire_registry_values`]: crate::Lua::expire_registry_values
 /// [`AnyUserData::set_user_value`]: crate::AnyUserData::set_user_value
-/// [`AnyUserData::get_user_value`]: crate::AnyUserData::get_user_value
+/// [`AnyUserData::user_value`]: crate::AnyUserData::user_value
 pub struct RegistryKey {
     pub(crate) registry_id: c_int,
     pub(crate) is_nil: AtomicBool,
@@ -194,6 +284,11 @@ impl<'lua> LuaRef<'lua> {
         }
     }
 
+    #[inline]
+    pub(crate) fn to_pointer(&self) -> *const c_void {
+        unsafe { ffi::lua_topointer(self.lua.ref_thread(), self.index) }
+    }
+
     #[cfg(feature = "unstable")]
     #[inline]
     pub(crate) fn into_owned(self) -> LuaOwnedRef {
@@ -206,7 +301,7 @@ impl<'lua> LuaRef<'lua> {
 
 impl<'lua> fmt::Debug for LuaRef<'lua> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Ref({})", self.index)
+        write!(f, "Ref({:p})", self.to_pointer())
     }
 }
 
@@ -226,15 +321,12 @@ impl<'lua> Drop for LuaRef<'lua> {
 
 impl<'lua> PartialEq for LuaRef<'lua> {
     fn eq(&self, other: &Self) -> bool {
-        let lua = self.lua;
-        let state = lua.state();
-        unsafe {
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 2);
-            lua.push_ref(self);
-            lua.push_ref(other);
-            ffi::lua_rawequal(state, -1, -2) == 1
-        }
+        let ref_thread = self.lua.ref_thread();
+        assert!(
+            ref_thread == other.lua.ref_thread(),
+            "Lua instance passed Value created from a different main Lua state"
+        );
+        unsafe { ffi::lua_rawequal(ref_thread, self.index, other.index) == 1 }
     }
 }
 
@@ -248,7 +340,7 @@ pub(crate) struct LuaOwnedRef {
 #[cfg(feature = "unstable")]
 impl fmt::Debug for LuaOwnedRef {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "OwnedRef({})", self.index)
+        write!(f, "OwnedRef({:p})", self.to_ref().to_pointer())
     }
 }
 
@@ -286,6 +378,150 @@ impl LuaOwnedRef {
     }
 }
 
+#[derive(Debug, Default)]
+pub(crate) struct AppData {
+    #[cfg(not(feature = "send"))]
+    container: UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any>>>>,
+    #[cfg(feature = "send")]
+    container: UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any + Send>>>>,
+    borrow: Cell<usize>,
+}
+
+impl AppData {
+    #[track_caller]
+    pub(crate) fn insert<T: MaybeSend + 'static>(&self, data: T) -> Option<T> {
+        match self.try_insert(data) {
+            Ok(data) => data,
+            Err(_) => panic!("cannot mutably borrow app data container"),
+        }
+    }
+
+    pub(crate) fn try_insert<T: MaybeSend + 'static>(&self, data: T) -> StdResult<Option<T>, T> {
+        if self.borrow.get() != 0 {
+            return Err(data);
+        }
+        // SAFETY: we checked that there are no other references to the container
+        Ok(unsafe { &mut *self.container.get() }
+            .insert(TypeId::of::<T>(), RefCell::new(Box::new(data)))
+            .and_then(|data| data.into_inner().downcast::<T>().ok().map(|data| *data)))
+    }
+
+    #[track_caller]
+    pub(crate) fn borrow<T: 'static>(&self) -> Option<AppDataRef<T>> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())?
+            .borrow();
+        self.borrow.set(self.borrow.get() + 1);
+        Some(AppDataRef {
+            data: Ref::filter_map(data, |data| data.downcast_ref()).ok()?,
+            borrow: &self.borrow,
+        })
+    }
+
+    #[track_caller]
+    pub(crate) fn borrow_mut<T: 'static>(&self) -> Option<AppDataRefMut<T>> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())?
+            .borrow_mut();
+        self.borrow.set(self.borrow.get() + 1);
+        Some(AppDataRefMut {
+            data: RefMut::filter_map(data, |data| data.downcast_mut()).ok()?,
+            borrow: &self.borrow,
+        })
+    }
+
+    #[track_caller]
+    pub(crate) fn remove<T: 'static>(&self) -> Option<T> {
+        if self.borrow.get() != 0 {
+            panic!("cannot mutably borrow app data container");
+        }
+        // SAFETY: we checked that there are no other references to the container
+        unsafe { &mut *self.container.get() }
+            .remove(&TypeId::of::<T>())?
+            .into_inner()
+            .downcast::<T>()
+            .ok()
+            .map(|data| *data)
+    }
+}
+
+/// A wrapper type for an immutably borrowed value from an app data container.
+///
+/// This type is similar to [`Ref`].
+pub struct AppDataRef<'a, T: ?Sized + 'a> {
+    data: Ref<'a, T>,
+    borrow: &'a Cell<usize>,
+}
+
+impl<T: ?Sized> Drop for AppDataRef<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRef<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+/// A wrapper type for a mutably borrowed value from an app data container.
+///
+/// This type is similar to [`RefMut`].
+pub struct AppDataRefMut<'a, T: ?Sized + 'a> {
+    data: RefMut<'a, T>,
+    borrow: &'a Cell<usize>,
+}
+
+impl<T: ?Sized> Drop for AppDataRefMut<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRefMut<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized> DerefMut for AppDataRefMut<'_, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
 #[cfg(test)]
 mod assertions {
     use super::*;

src/userdata.rs

@@ -1,5 +1,6 @@
 use std::any::{type_name, TypeId};
 use std::cell::{Ref, RefCell, RefMut};
+use std::ffi::CStr;
 use std::fmt;
 use std::hash::Hash;
 use std::mem;
@@ -19,13 +20,12 @@ use {
 use crate::error::{Error, Result};
 use crate::function::Function;
 use crate::lua::Lua;
+use crate::string::String;
 use crate::table::{Table, TablePairs};
-use crate::types::{Callback, LuaRef, MaybeSend};
+use crate::types::{LuaRef, MaybeSend};
 use crate::util::{check_stack, get_userdata, take_userdata, StackGuard};
 use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
-
-#[cfg(feature = "async")]
-use crate::types::AsyncCallback;
+use crate::UserDataRegistry;
 
 #[cfg(feature = "lua54")]
 pub(crate) const USER_VALUE_MAXSLOT: usize = 8;
@@ -37,6 +37,7 @@ pub(crate) const USER_VALUE_MAXSLOT: usize = 8;
 ///
 /// [`UserData`]: crate::UserData
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
 pub enum MetaMethod {
     /// The `+` operator.
     Add,
@@ -139,8 +140,14 @@ pub enum MetaMethod {
     /// Requires `feature = "lua54"`
     ///
     /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#3.3.8
-    #[cfg(any(feature = "lua54"))]
+    #[cfg(feature = "lua54")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "lua54")))]
     Close,
+    /// The `__name`/`__type` metafield.
+    ///
+    /// This is not a function, but it's value can be used by `tostring` and `typeof` built-in functions.
+    #[doc(hidden)]
+    Type,
 }
 
 impl PartialEq<MetaMethod> for &str {
@@ -149,7 +156,7 @@ impl PartialEq<MetaMethod> for &str {
     }
 }
 
-impl PartialEq<MetaMethod> for String {
+impl PartialEq<MetaMethod> for StdString {
     fn eq(&self, other: &MetaMethod) -> bool {
         self == other.name()
     }
@@ -212,6 +219,19 @@ impl MetaMethod {
 
             #[cfg(feature = "lua54")]
             MetaMethod::Close => "__close",
+
+            #[rustfmt::skip]
+            MetaMethod::Type => if cfg!(feature = "luau") { "__type" } else { "__name" },
+        }
+    }
+
+    pub(crate) const fn as_cstr(self) -> &'static CStr {
+        match self {
+            #[rustfmt::skip]
+            MetaMethod::Type => unsafe {
+                CStr::from_bytes_with_nul_unchecked(if cfg!(feature = "luau") { b"__type\0" } else { b"__name\0" })
+            },
+            _ => unreachable!(),
         }
     }
 
@@ -259,8 +279,7 @@ pub trait UserDataMethods<'lua, T> {
         A: FromLuaMulti<'lua>,
         R: IntoLuaMulti<'lua>;
 
-    /// Add an async method which accepts a `T` as the first parameter and returns Future.
-    /// The passed `T` is cloned from the original value.
+    /// Add an async method which accepts a `&T` as the first parameter and returns Future.
     ///
     /// Refer to [`add_method`] for more information about the implementation.
     ///
@@ -269,12 +288,31 @@ pub trait UserDataMethods<'lua, T> {
     /// [`add_method`]: #method.add_method
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_method<M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    fn add_async_method<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        T: Clone,
-        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 'lua,
+        MR: Future<Output = Result<R>> + 's,
+        R: IntoLuaMulti<'lua>;
+
+    /// Add an async method which accepts a `&mut T` as the first parameter and returns Future.
+    ///
+    /// Refer to [`add_method`] for more information about the implementation.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`add_method`]: #method.add_method
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn add_async_method_mut<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    where
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>;
 
     /// Add a regular method as a function which accepts generic arguments, the first argument will
@@ -349,8 +387,7 @@ pub trait UserDataMethods<'lua, T> {
         A: FromLuaMulti<'lua>,
         R: IntoLuaMulti<'lua>;
 
-    /// Add an async metamethod which accepts a `T` as the first parameter and returns Future.
-    /// The passed `T` is cloned from the original value.
+    /// Add an async metamethod which accepts a `&T` as the first parameter and returns Future.
     ///
     /// This is an async version of [`add_meta_method`].
     ///
@@ -359,12 +396,31 @@ pub trait UserDataMethods<'lua, T> {
     /// [`add_meta_method`]: #method.add_meta_method
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    fn add_async_meta_method<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        T: Clone,
-        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 'lua,
+        MR: Future<Output = Result<R>> + 's,
+        R: IntoLuaMulti<'lua>;
+
+    /// Add an async metamethod which accepts a `&mut T` as the first parameter and returns Future.
+    ///
+    /// This is an async version of [`add_meta_method_mut`].
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`add_meta_method_mut`]: #method.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<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    where
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>;
 
     /// Add a metamethod which accepts generic arguments.
@@ -410,24 +466,26 @@ pub trait UserDataMethods<'lua, T> {
     //
 
     #[doc(hidden)]
-    fn add_callback(&mut self, _name: String, _callback: Callback<'lua, 'static>) {}
-
-    #[doc(hidden)]
-    #[cfg(feature = "async")]
-    fn add_async_callback(&mut self, _name: String, _callback: AsyncCallback<'lua, 'static>) {}
-
-    #[doc(hidden)]
-    fn add_meta_callback(&mut self, _name: String, _callback: Callback<'lua, 'static>) {}
-
-    #[doc(hidden)]
-    #[cfg(feature = "async")]
-    fn add_async_meta_callback(&mut self, _name: String, _callback: AsyncCallback<'lua, 'static>) {}
+    fn append_methods_from<S>(&mut self, _other: UserDataRegistry<'lua, S>) {}
 }
 
 /// Field registry for [`UserData`] implementors.
 ///
 /// [`UserData`]: crate::UserData
 pub trait UserDataFields<'lua, T> {
+    /// Add a static field to the `UserData`.
+    ///
+    /// Static fields are implemented by updating the `__index` metamethod and returning the
+    /// accessed field. This allows them to be used with the expected `userdata.field` syntax.
+    ///
+    /// Static fields are usually shared between all instances of the `UserData` of the same type.
+    ///
+    /// 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 AsRef<str>, value: V)
+    where
+        V: IntoLua<'lua> + Clone + 'static;
+
     /// Add a regular field getter as a method which accepts a `&T` as the parameter.
     ///
     /// Regular field getters are implemented by overriding the `__index` metamethod and returning the
@@ -476,9 +534,21 @@ pub trait UserDataFields<'lua, T> {
         F: FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua<'lua>;
 
-    /// Add a metamethod value computed from `f`.
+    /// Add a metatable field.
     ///
-    /// This will initialize the metamethod value from `f` on `UserData` creation.
+    /// This will initialize the metatable field with `value` on `UserData` creation.
+    ///
+    /// # Note
+    ///
+    /// `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 AsRef<str>, value: V)
+    where
+        V: IntoLua<'lua> + Clone + 'static;
+
+    /// Add a metatable field computed from `f`.
+    ///
+    /// This will initialize the metatable field from `f` on `UserData` creation.
     ///
     /// # Note
     ///
@@ -494,10 +564,7 @@ pub trait UserDataFields<'lua, T> {
     //
 
     #[doc(hidden)]
-    fn add_field_getter(&mut self, _name: String, _callback: Callback<'lua, 'static>) {}
-
-    #[doc(hidden)]
-    fn add_field_setter(&mut self, _name: String, _callback: Callback<'lua, 'static>) {}
+    fn append_fields_from<S>(&mut self, _other: UserDataRegistry<'lua, S>) {}
 }
 
 /// Trait for custom userdata types.
@@ -707,19 +774,6 @@ impl<T> Deref for UserDataVariant<T> {
     }
 }
 
-#[cfg(feature = "serialize")]
-struct UserDataSerializeError;
-
-#[cfg(feature = "serialize")]
-impl Serialize for UserDataSerializeError {
-    fn serialize<S>(&self, _serializer: S) -> StdResult<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        Err(ser::Error::custom("cannot serialize <userdata>"))
-    }
-}
-
 /// Handle to an internal Lua userdata for any type that implements [`UserData`].
 ///
 /// Similar to `std::any::Any`, this provides an interface for dynamic type checking via the [`is`]
@@ -815,11 +869,11 @@ impl<'lua> AnyUserData<'lua> {
 
     /// Sets an associated value to this `AnyUserData`.
     ///
-    /// The value may be any Lua value whatsoever, and can be retrieved with [`get_user_value`].
+    /// The value may be any Lua value whatsoever, and can be retrieved with [`user_value`].
     ///
     /// This is the same as calling [`set_nth_user_value`] with `n` set to 1.
     ///
-    /// [`get_user_value`]: #method.get_user_value
+    /// [`user_value`]: #method.user_value
     /// [`set_nth_user_value`]: #method.set_nth_user_value
     #[inline]
     pub fn set_user_value<V: IntoLua<'lua>>(&self, v: V) -> Result<()> {
@@ -828,30 +882,34 @@ impl<'lua> AnyUserData<'lua> {
 
     /// Returns an associated value set by [`set_user_value`].
     ///
-    /// This is the same as calling [`get_nth_user_value`] with `n` set to 1.
+    /// This is the same as calling [`nth_user_value`] with `n` set to 1.
     ///
     /// [`set_user_value`]: #method.set_user_value
-    /// [`get_nth_user_value`]: #method.get_nth_user_value
+    /// [`nth_user_value`]: #method.nth_user_value
     #[inline]
+    pub fn user_value<V: FromLua<'lua>>(&self) -> Result<V> {
+        self.nth_user_value(1)
+    }
+
+    #[doc(hidden)]
+    #[deprecated(since = "0.9.0", note = "please use `user_value` instead")]
     pub fn get_user_value<V: FromLua<'lua>>(&self) -> Result<V> {
-        self.get_nth_user_value(1)
+        self.nth_user_value(1)
     }
 
     /// Sets an associated `n`th value to this `AnyUserData`.
     ///
-    /// The value may be any Lua value whatsoever, and can be retrieved with [`get_nth_user_value`].
+    /// The value may be any Lua value whatsoever, and can be retrieved with [`nth_user_value`].
     /// `n` starts from 1 and can be up to 65535.
     ///
     /// This is supported for all Lua versions.
     /// In Lua 5.4 first 7 elements are stored in a most efficient way.
     /// For other Lua versions this functionality is provided using a wrapping table.
     ///
-    /// [`get_nth_user_value`]: #method.get_nth_user_value
+    /// [`nth_user_value`]: #method.nth_user_value
     pub fn set_nth_user_value<V: IntoLua<'lua>>(&self, n: usize, v: V) -> Result<()> {
         if n < 1 || n > u16::MAX as usize {
-            return Err(Error::RuntimeError(
-                "user value index out of bounds".to_string(),
-            ));
+            return Err(Error::runtime("user value index out of bounds"));
         }
 
         let lua = self.0.lua;
@@ -902,11 +960,9 @@ impl<'lua> AnyUserData<'lua> {
     /// For other Lua versions this functionality is provided using a wrapping table.
     ///
     /// [`set_nth_user_value`]: #method.set_nth_user_value
-    pub fn get_nth_user_value<V: FromLua<'lua>>(&self, n: usize) -> Result<V> {
+    pub fn nth_user_value<V: FromLua<'lua>>(&self, n: usize) -> Result<V> {
         if n < 1 || n > u16::MAX as usize {
-            return Err(Error::RuntimeError(
-                "user value index out of bounds".to_string(),
-            ));
+            return Err(Error::runtime("user value index out of bounds"));
         }
 
         let lua = self.0.lua;
@@ -939,18 +995,20 @@ impl<'lua> AnyUserData<'lua> {
         }
     }
 
+    #[doc(hidden)]
+    #[deprecated(since = "0.9.0", note = "please use `nth_user_value` instead")]
+    pub fn get_nth_user_value<V: FromLua<'lua>>(&self, n: usize) -> Result<V> {
+        self.nth_user_value(n)
+    }
+
     /// Sets an associated value to this `AnyUserData` by name.
     ///
-    /// The value can be retrieved with [`get_named_user_value`].
+    /// The value can be retrieved with [`named_user_value`].
     ///
-    /// [`get_named_user_value`]: #method.get_named_user_value
-    pub fn set_named_user_value<V>(&self, name: impl AsRef<str>, v: V) -> Result<()>
-    where
-        V: IntoLua<'lua>,
-    {
+    /// [`named_user_value`]: #method.named_user_value
+    pub fn set_named_user_value<V: IntoLua<'lua>>(&self, name: &str, v: V) -> Result<()> {
         let lua = self.0.lua;
         let state = lua.state();
-        let name = name.as_ref();
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 5)?;
@@ -983,13 +1041,9 @@ impl<'lua> AnyUserData<'lua> {
     /// Returns an associated value by name set by [`set_named_user_value`].
     ///
     /// [`set_named_user_value`]: #method.set_named_user_value
-    pub fn get_named_user_value<V>(&self, name: impl AsRef<str>) -> Result<V>
-    where
-        V: FromLua<'lua>,
-    {
+    pub fn named_user_value<V: FromLua<'lua>>(&self, name: &str) -> Result<V> {
         let lua = self.0.lua;
         let state = lua.state();
-        let name = name.as_ref();
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 4)?;
@@ -1010,6 +1064,12 @@ impl<'lua> AnyUserData<'lua> {
         }
     }
 
+    #[doc(hidden)]
+    #[deprecated(since = "0.9.0", note = "please use `named_user_value` instead")]
+    pub fn get_named_user_value<V: FromLua<'lua>>(&self, name: &str) -> Result<V> {
+        self.named_user_value(name)
+    }
+
     /// Returns a metatable of this `UserData`.
     ///
     /// Returned [`UserDataMetatable`] object wraps the original metatable and
@@ -1044,6 +1104,35 @@ impl<'lua> AnyUserData<'lua> {
         OwnedAnyUserData(self.0.into_owned())
     }
 
+    #[inline(always)]
+    pub(crate) fn type_id(&self) -> Result<Option<TypeId>> {
+        unsafe { self.0.lua.get_userdata_type_id(&self.0) }
+    }
+
+    /// Returns a type name of this `UserData` (from a metatable field).
+    pub(crate) fn type_name(&self) -> Result<Option<StdString>> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 3)?;
+
+            lua.push_userdata_ref(&self.0)?;
+            let protect = !lua.unlikely_memory_error();
+            let name_type = if protect {
+                protect_lua!(state, 1, 1, |state| {
+                    ffi::luaL_getmetafield(state, -1, MetaMethod::Type.as_cstr().as_ptr())
+                })?
+            } else {
+                ffi::luaL_getmetafield(state, -1, MetaMethod::Type.as_cstr().as_ptr())
+            };
+            match name_type {
+                ffi::LUA_TSTRING => Ok(Some(String(lua.pop_ref()).to_str()?.to_owned())),
+                _ => Ok(None),
+            }
+        }
+    }
+
     pub(crate) fn equals<T: AsRef<Self>>(&self, other: T) -> Result<bool> {
         let other = other.as_ref();
         // Uses lua_rawequal() under the hood
@@ -1069,15 +1158,11 @@ impl<'lua> AnyUserData<'lua> {
     #[cfg(feature = "serialize")]
     pub(crate) fn is_serializable(&self) -> bool {
         let lua = self.0.lua;
-        let state = lua.state();
         let is_serializable = || unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 2)?;
-
             // Userdata can be unregistered or destructed
-            lua.push_userdata_ref(&self.0)?;
+            let _ = lua.get_userdata_type_id(&self.0)?;
 
-            let ud = &*get_userdata::<UserDataCell<()>>(state, -1);
+            let ud = &*get_userdata::<UserDataCell<()>>(lua.ref_thread(), self.0.index);
             match &*ud.0.try_borrow().map_err(|_| Error::UserDataBorrowError)? {
                 UserDataVariant::Serializable(_) => Result::Ok(true),
                 _ => Result::Ok(false),
@@ -1092,15 +1177,12 @@ impl<'lua> AnyUserData<'lua> {
         F: FnOnce(&'a UserDataCell<T>) -> Result<R>,
     {
         let lua = self.0.lua;
-        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 2)?;
-
-            let type_id = lua.push_userdata_ref(&self.0)?;
+            let type_id = lua.get_userdata_type_id(&self.0)?;
             match type_id {
                 Some(type_id) if type_id == TypeId::of::<T>() => {
-                    func(&*get_userdata::<UserDataCell<T>>(state, -1))
+                    let ref_thread = lua.ref_thread();
+                    func(&*get_userdata::<UserDataCell<T>>(ref_thread, self.0.index))
                 }
                 _ => Err(Error::UserDataTypeMismatch),
             }
@@ -1152,6 +1234,14 @@ impl OwnedAnyUserData {
         // Reattach lifetime to &self
         Ok(unsafe { mem::transmute::<RefMut<T>, RefMut<T>>(t) })
     }
+
+    /// Takes the value out of this userdata.
+    ///
+    /// This is a shortcut for [`AnyUserData::take()`]
+    #[inline]
+    pub fn take<T: 'static>(&self) -> Result<T> {
+        self.to_ref().take()
+    }
 }
 
 /// Handle to a `UserData` metatable.
@@ -1211,7 +1301,7 @@ impl<'lua, V> Iterator for UserDataMetatablePairs<'lua, V>
 where
     V: FromLua<'lua>,
 {
-    type Item = Result<(String, V)>;
+    type Item = Result<(StdString, V)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -1235,19 +1325,17 @@ impl<'lua> Serialize for AnyUserData<'lua> {
         S: Serializer,
     {
         let lua = self.0.lua;
-        let state = lua.state();
         let data = unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 3).map_err(ser::Error::custom)?;
-
-            lua.push_userdata_ref(&self.0).map_err(ser::Error::custom)?;
-            let ud = &*get_userdata::<UserDataCell<()>>(state, -1);
+            let _ = lua
+                .get_userdata_type_id(&self.0)
+                .map_err(ser::Error::custom)?;
+            let ud = &*get_userdata::<UserDataCell<()>>(lua.ref_thread(), self.0.index);
             ud.0.try_borrow()
                 .map_err(|_| ser::Error::custom(Error::UserDataBorrowError))?
         };
         match &*data {
             UserDataVariant::Serializable(ser) => ser.serialize(serializer),
-            _ => UserDataSerializeError.serialize(serializer),
+            _ => Err(ser::Error::custom("cannot serialize <userdata>")),
         }
     }
 }
@@ -1302,6 +1390,27 @@ impl<'lua, T: 'static> UserDataRefMut<'lua, T> {
     }
 }
 
+pub(crate) struct WrappedUserdata<F: for<'lua> FnOnce(&'lua Lua) -> Result<AnyUserData<'lua>>>(F);
+
+impl<'lua> AnyUserData<'lua> {
+    /// Wraps any Rust type, returning an opaque type that implements [`IntoLua`] trait.
+    ///
+    /// This function uses [`Lua::create_any_userdata()`] under the hood.
+    pub fn wrap<T: MaybeSend + 'static>(data: T) -> impl IntoLua<'lua> {
+        WrappedUserdata(move |lua| lua.create_any_userdata(data))
+    }
+}
+
+impl<'lua, F> IntoLua<'lua> for WrappedUserdata<F>
+where
+    F: for<'l> FnOnce(&'l Lua) -> Result<AnyUserData<'l>>,
+{
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        (self.0)(lua).map(Value::UserData)
+    }
+}
+
+#[inline]
 fn try_value_to_userdata<T>(value: Value) -> Result<AnyUserData> {
     match value {
         Value::UserData(ud) => Ok(ud),

src/userdata_ext.rs

@@ -4,7 +4,7 @@ use crate::userdata::{AnyUserData, MetaMethod};
 use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
 #[cfg(feature = "async")]
-use {futures_core::future::LocalBoxFuture, futures_util::future};
+use futures_util::future::{self, LocalBoxFuture};
 
 /// An extension trait for [`AnyUserData`] that provides a variety of convenient functionality.
 pub trait AnyUserDataExt<'lua>: Sealed {
@@ -27,15 +27,14 @@ pub trait AnyUserDataExt<'lua>: Sealed {
     /// The metamethod is called with the userdata as its first argument, followed by the passed arguments.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async<A, R>(&self, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut;
+        R: FromLuaMulti<'lua> + 'lua;
 
     /// Calls the userdata method, assuming it has `__index` metamethod
     /// and a function associated to `name`.
-    fn call_method<A, R>(&self, name: impl AsRef<str>, args: A) -> Result<R>
+    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
     where
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
@@ -48,15 +47,10 @@ pub trait AnyUserDataExt<'lua>: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_method<'fut, A, R>(
-        &self,
-        name: impl AsRef<str>,
-        args: A,
-    ) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_method<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut;
+        R: FromLuaMulti<'lua> + 'lua;
 
     /// Gets the function associated to `key` from the table and executes it,
     /// passing `args` as function arguments.
@@ -65,7 +59,7 @@ pub trait AnyUserDataExt<'lua>: Sealed {
     /// `table.get::<_, Function>(key)?.call(args)`
     ///
     /// This might invoke the `__index` metamethod.
-    fn call_function<A, R>(&self, name: impl AsRef<str>, args: A) -> Result<R>
+    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
     where
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
@@ -78,15 +72,10 @@ pub trait AnyUserDataExt<'lua>: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_function<'fut, A, R>(
-        &self,
-        name: impl AsRef<str>,
-        args: A,
-    ) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_function<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut;
+        R: FromLuaMulti<'lua> + 'lua;
 }
 
 impl<'lua> AnyUserDataExt<'lua> for AnyUserData<'lua> {
@@ -95,9 +84,7 @@ impl<'lua> AnyUserDataExt<'lua> for AnyUserData<'lua> {
         match metatable.get::<Value>(MetaMethod::Index)? {
             Value::Table(table) => table.raw_get(key),
             Value::Function(func) => func.call((self.clone(), key)),
-            _ => Err(Error::RuntimeError(
-                "attempt to index a userdata value".to_string(),
-            )),
+            _ => Err(Error::runtime("attempt to index a userdata value")),
         }
     }
 
@@ -106,9 +93,7 @@ impl<'lua> AnyUserDataExt<'lua> for AnyUserData<'lua> {
         match metatable.get::<Value>(MetaMethod::NewIndex)? {
             Value::Table(table) => table.raw_set(key, value),
             Value::Function(func) => func.call((self.clone(), key, value)),
-            _ => Err(Error::RuntimeError(
-                "attempt to index a userdata value".to_string(),
-            )),
+            _ => Err(Error::runtime("attempt to index a userdata value")),
         }
     }
 
@@ -120,33 +105,37 @@ impl<'lua> AnyUserDataExt<'lua> for AnyUserData<'lua> {
         let metatable = self.get_metatable()?;
         match metatable.get::<Value>(MetaMethod::Call)? {
             Value::Function(func) => func.call((self.clone(), args)),
-            _ => Err(Error::RuntimeError(
-                "attempt to call a userdata value".to_string(),
-            )),
+            _ => Err(Error::runtime("attempt to call a userdata value")),
         }
     }
 
     #[cfg(feature = "async")]
-    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async<A, R>(&self, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
         let metatable = match self.get_metatable() {
             Ok(metatable) => metatable,
             Err(err) => return Box::pin(future::err(err)),
         };
         match metatable.get::<Value>(MetaMethod::Call) {
-            Ok(Value::Function(func)) => func.call_async((self.clone(), args)),
-            Ok(_) => Box::pin(future::err(Error::RuntimeError(
-                "attempt to call a userdata value".to_string(),
+            Ok(Value::Function(func)) => {
+                let mut args = match args.into_lua_multi(self.0.lua) {
+                    Ok(args) => args,
+                    Err(e) => return Box::pin(future::err(e)),
+                };
+                args.push_front(Value::UserData(self.clone()));
+                Box::pin(async move { func.call_async(args).await })
+            }
+            Ok(_) => Box::pin(future::err(Error::runtime(
+                "attempt to call a userdata value",
             ))),
             Err(err) => Box::pin(future::err(err)),
         }
     }
 
-    fn call_method<A, R>(&self, name: impl AsRef<str>, args: A) -> Result<R>
+    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
     where
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
@@ -155,50 +144,46 @@ impl<'lua> AnyUserDataExt<'lua> for AnyUserData<'lua> {
     }
 
     #[cfg(feature = "async")]
-    fn call_async_method<'fut, A, R>(
-        &self,
-        name: impl AsRef<str>,
-        args: A,
-    ) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_method<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
         self.call_async_function(name, (self.clone(), args))
     }
 
-    fn call_function<A, R>(&self, name: impl AsRef<str>, args: A) -> Result<R>
+    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
     where
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
-        match self.get(name.as_ref())? {
+        match self.get(name)? {
             Value::Function(func) => func.call(args),
-            val => Err(Error::RuntimeError(format!(
-                "attempt to call a {} value",
-                val.type_name()
-            ))),
+            val => {
+                let msg = format!("attempt to call a {} value", val.type_name());
+                Err(Error::runtime(msg))
+            }
         }
     }
 
     #[cfg(feature = "async")]
-    fn call_async_function<'fut, A, R>(
-        &self,
-        name: impl AsRef<str>,
-        args: A,
-    ) -> LocalBoxFuture<'fut, Result<R>>
+    fn call_async_function<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
     where
-        'lua: 'fut,
         A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti<'lua> + 'lua,
     {
-        match self.get(name.as_ref()) {
-            Ok(Value::Function(func)) => func.call_async(args),
-            Ok(val) => Box::pin(future::err(Error::RuntimeError(format!(
-                "attempt to call a {} value",
-                val.type_name()
-            )))),
+        match self.get(name) {
+            Ok(Value::Function(func)) => {
+                let args = match args.into_lua_multi(self.0.lua) {
+                    Ok(args) => args,
+                    Err(e) => return Box::pin(future::err(e)),
+                };
+                Box::pin(async move { func.call_async(args).await })
+            }
+            Ok(val) => {
+                let msg = format!("attempt to call a {} value", val.type_name());
+                Box::pin(future::err(Error::runtime(msg)))
+            }
             Err(err) => Box::pin(future::err(err)),
         }
     }

src/userdata_impl.rs

@@ -1,6 +1,9 @@
-use std::any::{self, TypeId};
+#![allow(clippy::await_holding_refcell_ref, clippy::await_holding_lock)]
+
+use std::any::TypeId;
 use std::cell::{Ref, RefCell, RefMut};
 use std::marker::PhantomData;
+use std::os::raw::c_int;
 use std::string::String as StdString;
 use std::sync::{Arc, Mutex, RwLock};
 
@@ -10,8 +13,8 @@ use crate::types::{Callback, MaybeSend};
 use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
 };
-use crate::util::{check_stack, get_userdata, StackGuard};
-use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
+use crate::util::{get_userdata, short_type_name};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Value};
 
 #[cfg(not(feature = "send"))]
 use std::rc::Rc;
@@ -23,15 +26,13 @@ use {
     std::future::Future,
 };
 
-pub struct UserDataRegistrar<'lua, T: 'static> {
+/// Handle to registry for userdata methods and metamethods.
+pub struct UserDataRegistry<'lua, T: 'static> {
     // Fields
+    pub(crate) fields: Vec<(String, Callback<'lua, 'static>)>,
     pub(crate) field_getters: Vec<(String, Callback<'lua, 'static>)>,
     pub(crate) field_setters: Vec<(String, Callback<'lua, 'static>)>,
-    #[allow(clippy::type_complexity)]
-    pub(crate) meta_fields: Vec<(
-        String,
-        Box<dyn Fn(&'lua Lua) -> Result<Value<'lua>> + 'static>,
-    )>,
+    pub(crate) meta_fields: Vec<(String, Callback<'lua, 'static>)>,
 
     // Methods
     pub(crate) methods: Vec<(String, Callback<'lua, 'static>)>,
@@ -44,9 +45,10 @@ pub struct UserDataRegistrar<'lua, T: 'static> {
     _type: PhantomData<T>,
 }
 
-impl<'lua, T: 'static> UserDataRegistrar<'lua, T> {
+impl<'lua, T: 'static> UserDataRegistry<'lua, T> {
     pub(crate) const fn new() -> Self {
-        UserDataRegistrar {
+        UserDataRegistry {
+            fields: Vec::new(),
             field_getters: Vec::new(),
             field_setters: Vec::new(),
             meta_fields: Vec::new(),
@@ -77,62 +79,63 @@ impl<'lua, T: 'static> UserDataRegistrar<'lua, T> {
         }
 
         Box::new(move |lua, mut args| {
-            let front = args.pop_front();
+            let front = args
+                .pop_front()
+                .ok_or_else(|| Error::from_lua_conversion("missing argument", "userdata", None));
+            let front = try_self_arg!(front);
             let call = |ud| {
                 // Self was at index 1, so we pass 2 here
                 let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
                 method(lua, ud, args)?.into_lua_multi(lua)
             };
 
-            if let Some(front) = front {
-                let state = lua.state();
-                let userdata = try_self_arg!(AnyUserData::from_lua(front, lua));
-                unsafe {
-                    let _sg = StackGuard::new(state);
-                    check_stack(state, 2)?;
-
-                    let type_id = try_self_arg!(lua.push_userdata_ref(&userdata.0));
-                    match type_id {
-                        Some(id) if id == TypeId::of::<T>() => {
-                            let ud = try_self_arg!(get_userdata_ref::<T>(state));
-                            call(&ud)
-                        }
-                        #[cfg(not(feature = "send"))]
-                        Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                            let ud = try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(state));
-                            let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
-                            call(&ud)
-                        }
-                        Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                            let ud = try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(state));
-                            let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
-                            call(&ud)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                            let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(state);
-                            let ud = try_self_arg!(ud);
-                            let ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
-                            call(&ud)
-                        }
-                        Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                            let ud = try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(state));
-                            let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
-                            call(&ud)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                            let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(state);
-                            let ud = try_self_arg!(ud);
-                            let ud = try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
-                            call(&ud)
-                        }
-                        _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
-                    }
-                }
-            } else {
-                let err = Error::from_lua_conversion("missing argument", "userdata", None);
-                Err(Error::bad_self_argument(&name, err))
+            let userdata = try_self_arg!(AnyUserData::from_lua(front, lua));
+            let (ref_thread, index) = (lua.ref_thread(), userdata.0.index);
+            match try_self_arg!(userdata.type_id()) {
+                Some(id) if id == TypeId::of::<T>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_ref::<T>(ref_thread, index));
+                    call(&ud)
+                },
+                #[cfg(not(feature = "send"))]
+                Some(id) if id == TypeId::of::<Rc<T>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_ref::<Rc<T>>(ref_thread, index));
+                    call(&ud)
+                },
+                #[cfg(not(feature = "send"))]
+                Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(ref_thread, index));
+                    let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
+                    call(&ud)
+                },
+                Some(id) if id == TypeId::of::<Arc<T>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_ref::<Arc<T>>(ref_thread, index));
+                    call(&ud)
+                },
+                Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(ref_thread, index));
+                    let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
+                    call(&ud)
+                },
+                #[cfg(feature = "parking_lot")]
+                Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => unsafe {
+                    let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(ref_thread, index);
+                    let ud = try_self_arg!(ud);
+                    let ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
+                    call(&ud)
+                },
+                Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(ref_thread, index));
+                    let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
+                    call(&ud)
+                },
+                #[cfg(feature = "parking_lot")]
+                Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => unsafe {
+                    let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(ref_thread, index);
+                    let ud = try_self_arg!(ud);
+                    let ud = try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
+                    call(&ud)
+                },
+                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
             }
         })
     }
@@ -158,158 +161,258 @@ impl<'lua, T: 'static> UserDataRegistrar<'lua, T> {
             let mut method = method
                 .try_borrow_mut()
                 .map_err(|_| Error::RecursiveMutCallback)?;
-            let front = args.pop_front();
+            let front = args
+                .pop_front()
+                .ok_or_else(|| Error::from_lua_conversion("missing argument", "userdata", None));
+            let front = try_self_arg!(front);
             let call = |ud| {
                 // Self was at index 1, so we pass 2 here
                 let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
                 method(lua, ud, args)?.into_lua_multi(lua)
             };
 
-            if let Some(front) = front {
-                let state = lua.state();
-                let userdata = try_self_arg!(AnyUserData::from_lua(front, lua));
-                unsafe {
-                    let _sg = StackGuard::new(state);
-                    check_stack(state, 2)?;
-
-                    let type_id = try_self_arg!(lua.push_userdata_ref(&userdata.0));
-                    match type_id {
-                        Some(id) if id == TypeId::of::<T>() => {
-                            let mut ud = try_self_arg!(get_userdata_mut::<T>(state));
-                            call(&mut ud)
-                        }
-                        #[cfg(not(feature = "send"))]
-                        Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                            let ud = try_self_arg!(get_userdata_mut::<Rc<RefCell<T>>>(state));
-                            let mut ud =
-                                try_self_arg!(ud.try_borrow_mut(), Error::UserDataBorrowMutError);
-                            call(&mut ud)
-                        }
-                        Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                            let ud = try_self_arg!(get_userdata_mut::<Arc<Mutex<T>>>(state));
-                            let mut ud =
-                                try_self_arg!(ud.try_lock(), Error::UserDataBorrowMutError);
-                            call(&mut ud)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                            let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(state);
-                            let ud = try_self_arg!(ud);
-                            let mut ud =
-                                try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowMutError));
-                            call(&mut ud)
-                        }
-                        Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                            let ud = try_self_arg!(get_userdata_mut::<Arc<RwLock<T>>>(state));
-                            let mut ud =
-                                try_self_arg!(ud.try_write(), Error::UserDataBorrowMutError);
-                            call(&mut ud)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                            let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(state);
-                            let ud = try_self_arg!(ud);
-                            let mut ud =
-                                try_self_arg!(ud.try_write().ok_or(Error::UserDataBorrowMutError));
-                            call(&mut ud)
-                        }
-                        _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
-                    }
-                }
-            } else {
-                let err = Error::from_lua_conversion("missing argument", "userdata", None);
-                Err(Error::bad_self_argument(&name, err))
+            let userdata = try_self_arg!(AnyUserData::from_lua(front, lua));
+            let (ref_thread, index) = (lua.ref_thread(), userdata.0.index);
+            match try_self_arg!(userdata.type_id()) {
+                Some(id) if id == TypeId::of::<T>() => unsafe {
+                    let mut ud = try_self_arg!(get_userdata_mut::<T>(ref_thread, index));
+                    call(&mut ud)
+                },
+                #[cfg(not(feature = "send"))]
+                Some(id) if id == TypeId::of::<Rc<T>>() => Err(Error::UserDataBorrowMutError),
+                #[cfg(not(feature = "send"))]
+                Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_mut::<Rc<RefCell<T>>>(ref_thread, index));
+                    let mut ud = try_self_arg!(ud.try_borrow_mut(), Error::UserDataBorrowMutError);
+                    call(&mut ud)
+                },
+                Some(id) if id == TypeId::of::<Arc<T>>() => Err(Error::UserDataBorrowMutError),
+                Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_mut::<Arc<Mutex<T>>>(ref_thread, index));
+                    let mut ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowMutError);
+                    call(&mut ud)
+                },
+                #[cfg(feature = "parking_lot")]
+                Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => unsafe {
+                    let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(ref_thread, index);
+                    let ud = try_self_arg!(ud);
+                    let mut ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowMutError));
+                    call(&mut ud)
+                },
+                Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => unsafe {
+                    let ud = try_self_arg!(get_userdata_mut::<Arc<RwLock<T>>>(ref_thread, index));
+                    let mut ud = try_self_arg!(ud.try_write(), Error::UserDataBorrowMutError);
+                    call(&mut ud)
+                },
+                #[cfg(feature = "parking_lot")]
+                Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => unsafe {
+                    let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(ref_thread, index);
+                    let ud = try_self_arg!(ud);
+                    let mut ud = try_self_arg!(ud.try_write().ok_or(Error::UserDataBorrowMutError));
+                    call(&mut ud)
+                },
+                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
             }
         })
     }
 
     #[cfg(feature = "async")]
-    fn box_async_method<M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'lua, 'static>
+    fn box_async_method<'s, M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'lua, 'static>
     where
-        T: Clone,
-        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 'lua,
+        MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>,
     {
         let name = get_function_name::<T>(name);
-        macro_rules! try_self_arg {
-            ($res:expr) => {
-                $res.map_err(|err| Error::bad_self_argument(&name, err))?
-            };
-            ($res:expr, $err:expr) => {
-                $res.map_err(|_| Error::bad_self_argument(&name, $err))?
-            };
-        }
+        let method = Arc::new(method);
 
         Box::new(move |lua, mut args| {
-            let front = args.pop_front();
-            let call = |ud| {
-                // Self was at index 1, so we pass 2 here
-                let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
-                Ok(method(lua, ud, args))
-            };
-
-            let fut_res = || {
-                if let Some(front) = front {
-                    let state = lua.state();
-                    let userdata = AnyUserData::from_lua(front, lua)?;
-                    unsafe {
-                        let _sg = StackGuard::new(state);
-                        check_stack(state, 2)?;
-
-                        let type_id = try_self_arg!(lua.push_userdata_ref(&userdata.0));
-                        match type_id {
-                            Some(id) if id == TypeId::of::<T>() => {
-                                let ud = get_userdata_ref::<T>(state)?;
-                                call(ud.clone())
-                            }
-                            #[cfg(not(feature = "send"))]
-                            Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                                let ud = try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(state));
-                                let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
-                                call(ud.clone())
-                            }
-                            Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                                let ud = try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(state));
-                                let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
-                                call(ud.clone())
-                            }
-                            #[cfg(feature = "parking_lot")]
-                            Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                                let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(state);
-                                let ud = try_self_arg!(ud);
-                                let ud =
-                                    try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
-                                call(ud.clone())
-                            }
-                            Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                                let ud = try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(state));
-                                let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
-                                call(ud.clone())
-                            }
-                            #[cfg(feature = "parking_lot")]
-                            Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                                let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(state);
-                                let ud = try_self_arg!(ud);
-                                let ud =
-                                    try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
-                                call(ud.clone())
-                            }
-                            _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
-                        }
-                    }
-                } else {
-                    let err = Error::from_lua_conversion("missing argument", "userdata", None);
-                    Err(Error::bad_self_argument(&name, err))
-                }
-            };
-            match fut_res() {
-                Ok(fut) => {
-                    Box::pin(fut.and_then(move |ret| future::ready(ret.into_lua_multi(lua))))
-                }
-                Err(e) => Box::pin(future::err(e)),
+            let name = name.clone();
+            let method = method.clone();
+            macro_rules! try_self_arg {
+                ($res:expr) => {
+                    $res.map_err(|err| Error::bad_self_argument(&name, err))?
+                };
+                ($res:expr, $err:expr) => {
+                    $res.map_err(|_| Error::bad_self_argument(&name, $err))?
+                };
             }
+
+            Box::pin(async move {
+                let front = args.pop_front().ok_or_else(|| {
+                    Error::from_lua_conversion("missing argument", "userdata", None)
+                });
+                let front = try_self_arg!(front);
+                let userdata: AnyUserData = try_self_arg!(AnyUserData::from_lua(front, lua));
+                let (ref_thread, index) = (lua.ref_thread(), userdata.0.index);
+                match try_self_arg!(userdata.type_id()) {
+                    Some(id) if id == TypeId::of::<T>() => unsafe {
+                        let ud = try_self_arg!(get_userdata_ref::<T>(ref_thread, index));
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        // Self was at index 1, so we pass 2 here
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(not(feature = "send"))]
+                    Some(id) if id == TypeId::of::<Rc<T>>() => unsafe {
+                        let ud = try_self_arg!(get_userdata_ref::<Rc<T>>(ref_thread, index));
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(not(feature = "send"))]
+                    Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => unsafe {
+                        let ud =
+                            try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(ref_thread, index));
+                        let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    Some(id) if id == TypeId::of::<Arc<T>>() => unsafe {
+                        let ud = try_self_arg!(get_userdata_ref::<Arc<T>>(ref_thread, index));
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => unsafe {
+                        let ud =
+                            try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(ref_thread, index));
+                        let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(feature = "parking_lot")]
+                    Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => unsafe {
+                        let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(ref_thread, index);
+                        let ud = try_self_arg!(ud);
+                        let ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => unsafe {
+                        let ud =
+                            try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(ref_thread, index));
+                        let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(feature = "parking_lot")]
+                    Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => unsafe {
+                        let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(ref_thread, index);
+                        let ud = try_self_arg!(ud);
+                        let ud = try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
+                        let ud = std::mem::transmute::<&T, &T>(&ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
+                }
+            })
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_method_mut<'s, M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'lua, 'static>
+    where
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 's,
+        R: IntoLuaMulti<'lua>,
+    {
+        let name = get_function_name::<T>(name);
+        let method = Arc::new(method);
+
+        Box::new(move |lua, mut args| {
+            let name = name.clone();
+            let method = method.clone();
+            macro_rules! try_self_arg {
+                ($res:expr) => {
+                    $res.map_err(|err| Error::bad_self_argument(&name, err))?
+                };
+                ($res:expr, $err:expr) => {
+                    $res.map_err(|_| Error::bad_self_argument(&name, $err))?
+                };
+            }
+
+            Box::pin(async move {
+                let front = args.pop_front().ok_or_else(|| {
+                    Error::from_lua_conversion("missing argument", "userdata", None)
+                });
+                let front = try_self_arg!(front);
+                let userdata: AnyUserData = try_self_arg!(AnyUserData::from_lua(front, lua));
+                let (ref_thread, index) = (lua.ref_thread(), userdata.0.index);
+                match try_self_arg!(userdata.type_id()) {
+                    Some(id) if id == TypeId::of::<T>() => unsafe {
+                        let mut ud = try_self_arg!(get_userdata_mut::<T>(ref_thread, index));
+                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
+                        // Self was at index 1, so we pass 2 here
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(not(feature = "send"))]
+                    Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
+                        Err(Error::UserDataBorrowMutError)
+                    }
+                    #[cfg(not(feature = "send"))]
+                    Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => unsafe {
+                        let ud =
+                            try_self_arg!(get_userdata_mut::<Rc<RefCell<T>>>(ref_thread, index));
+                        let mut ud =
+                            try_self_arg!(ud.try_borrow_mut(), Error::UserDataBorrowMutError);
+                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(not(feature = "send"))]
+                    Some(id) if id == TypeId::of::<Arc<T>>() => Err(Error::UserDataBorrowMutError),
+                    Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => unsafe {
+                        let ud =
+                            try_self_arg!(get_userdata_mut::<Arc<Mutex<T>>>(ref_thread, index));
+                        let mut ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowMutError);
+                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(feature = "parking_lot")]
+                    Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => unsafe {
+                        let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(ref_thread, index);
+                        let ud = try_self_arg!(ud);
+                        let mut ud =
+                            try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowMutError));
+                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => unsafe {
+                        let ud =
+                            try_self_arg!(get_userdata_mut::<Arc<RwLock<T>>>(ref_thread, index));
+                        let mut ud = try_self_arg!(ud.try_write(), Error::UserDataBorrowMutError);
+                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    #[cfg(feature = "parking_lot")]
+                    Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => unsafe {
+                        let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(ref_thread, index);
+                        let ud = try_self_arg!(ud);
+                        let mut ud =
+                            try_self_arg!(ud.try_write().ok_or(Error::UserDataBorrowMutError));
+                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
+                        let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                        method(lua, ud, args).await?.into_lua_multi(lua)
+                    },
+                    _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
+                }
+            })
         })
     }
 
@@ -360,15 +463,49 @@ impl<'lua, T: 'static> UserDataRegistrar<'lua, T> {
             )
         })
     }
+
+    pub(crate) fn check_meta_field<V>(
+        lua: &'lua Lua,
+        name: &str,
+        value: V,
+    ) -> Result<MultiValue<'lua>>
+    where
+        V: IntoLua<'lua>,
+    {
+        let value = value.into_lua(lua)?;
+        if name == MetaMethod::Index || name == MetaMethod::NewIndex {
+            match value {
+                Value::Nil | Value::Table(_) | Value::Function(_) => {}
+                _ => {
+                    return Err(Error::MetaMethodTypeError {
+                        method: name.to_string(),
+                        type_name: value.type_name(),
+                        message: Some("expected nil, table or function".to_string()),
+                    })
+                }
+            }
+        }
+        value.into_lua_multi(lua)
+    }
 }
 
 // Returns function name for the type `T`, without the module path
-fn get_function_name<T: 'static>(name: &str) -> StdString {
-    let type_name = any::type_name::<T>().rsplit("::").next().unwrap();
-    format!("{type_name}.{name}",)
+fn get_function_name<T>(name: &str) -> StdString {
+    format!("{}.{name}", short_type_name::<T>())
 }
 
-impl<'lua, T: 'static> UserDataFields<'lua, T> for UserDataRegistrar<'lua, T> {
+impl<'lua, T: 'static> UserDataFields<'lua, T> for UserDataRegistry<'lua, T> {
+    fn add_field<V>(&mut self, name: impl AsRef<str>, value: V)
+    where
+        V: IntoLua<'lua> + Clone + 'static,
+    {
+        let name = name.as_ref().to_string();
+        self.fields.push((
+            name,
+            Box::new(move |lua, _| value.clone().into_lua_multi(lua)),
+        ));
+    }
+
     fn add_field_method_get<M, R>(&mut self, name: impl AsRef<str>, method: M)
     where
         M: Fn(&'lua Lua, &T) -> Result<R> + MaybeSend + 'static,
@@ -409,45 +546,42 @@ impl<'lua, T: 'static> UserDataFields<'lua, T> for UserDataRegistrar<'lua, T> {
         self.field_setters.push((name.into(), func));
     }
 
+    fn add_meta_field<V>(&mut self, name: impl AsRef<str>, value: V)
+    where
+        V: IntoLua<'lua> + Clone + 'static,
+    {
+        let name = name.as_ref().to_string();
+        let name2 = name.clone();
+        self.meta_fields.push((
+            name,
+            Box::new(move |lua, _| Self::check_meta_field(lua, &name2, value.clone())),
+        ));
+    }
+
     fn add_meta_field_with<F, R>(&mut self, name: impl AsRef<str>, f: F)
     where
         F: Fn(&'lua Lua) -> Result<R> + MaybeSend + 'static,
         R: IntoLua<'lua>,
     {
         let name = name.as_ref().to_string();
+        let name2 = name.clone();
         self.meta_fields.push((
-            name.clone(),
-            Box::new(move |lua| {
-                let value = f(lua)?.into_lua(lua)?;
-                if name == MetaMethod::Index || name == MetaMethod::NewIndex {
-                    match value {
-                        Value::Nil | Value::Table(_) | Value::Function(_) => {}
-                        _ => {
-                            return Err(Error::MetaMethodTypeError {
-                                method: name.clone(),
-                                type_name: value.type_name(),
-                                message: Some("expected nil, table or function".to_string()),
-                            })
-                        }
-                    }
-                }
-                Ok(value)
-            }),
+            name,
+            Box::new(move |lua, _| Self::check_meta_field(lua, &name2, f(lua)?)),
         ));
     }
 
     // Below are internal methods
 
-    fn add_field_getter(&mut self, name: String, callback: Callback<'lua, 'static>) {
-        self.field_getters.push((name, callback));
-    }
-
-    fn add_field_setter(&mut self, name: String, callback: Callback<'lua, 'static>) {
-        self.field_setters.push((name, callback));
+    fn append_fields_from<S>(&mut self, other: UserDataRegistry<'lua, S>) {
+        self.fields.extend(other.fields);
+        self.field_getters.extend(other.field_getters);
+        self.field_setters.extend(other.field_setters);
+        self.meta_fields.extend(other.meta_fields);
     }
 }
 
-impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistrar<'lua, T> {
+impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistry<'lua, T> {
     fn add_method<M, A, R>(&mut self, name: impl AsRef<str>, method: M)
     where
         M: Fn(&'lua Lua, &T, A) -> Result<R> + MaybeSend + 'static,
@@ -471,12 +605,13 @@ impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistrar<'lua, T> {
     }
 
     #[cfg(feature = "async")]
-    fn add_async_method<M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    fn add_async_method<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        T: Clone,
-        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 'lua,
+        MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>,
     {
         let name = name.as_ref();
@@ -484,6 +619,21 @@ impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistrar<'lua, T> {
             .push((name.into(), Self::box_async_method(name, method)));
     }
 
+    #[cfg(feature = "async")]
+    fn add_async_method_mut<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    where
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 's,
+        R: IntoLuaMulti<'lua>,
+    {
+        let name = name.as_ref();
+        self.async_methods
+            .push((name.into(), Self::box_async_method_mut(name, method)));
+    }
+
     fn add_function<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
     where
         F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
@@ -542,12 +692,13 @@ impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistrar<'lua, T> {
     }
 
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    fn add_async_meta_method<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        T: Clone,
-        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 'lua,
+        MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>,
     {
         let name = name.as_ref();
@@ -555,6 +706,21 @@ impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistrar<'lua, T> {
             .push((name.into(), Self::box_async_method(name, method)));
     }
 
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method_mut<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    where
+        'lua: 's,
+        T: 'static,
+        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 's,
+        R: IntoLuaMulti<'lua>,
+    {
+        let name = name.as_ref();
+        self.async_meta_methods
+            .push((name.into(), Self::box_async_method_mut(name, method)));
+    }
+
     fn add_meta_function<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
     where
         F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
@@ -592,73 +758,53 @@ impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistrar<'lua, T> {
 
     // Below are internal methods used in generated code
 
-    fn add_callback(&mut self, name: String, callback: Callback<'lua, 'static>) {
-        self.methods.push((name, callback));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_callback(&mut self, name: String, callback: AsyncCallback<'lua, 'static>) {
-        self.async_methods.push((name, callback));
-    }
-
-    fn add_meta_callback(&mut self, name: String, callback: Callback<'lua, 'static>) {
-        self.meta_methods.push((name, callback));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_meta_callback(&mut self, meta: String, callback: AsyncCallback<'lua, 'static>) {
-        self.async_meta_methods.push((meta, callback))
+    fn append_methods_from<S>(&mut self, other: UserDataRegistry<'lua, S>) {
+        self.methods.extend(other.methods);
+        #[cfg(feature = "async")]
+        self.async_methods.extend(other.async_methods);
+        self.meta_methods.extend(other.meta_methods);
+        #[cfg(feature = "async")]
+        self.async_meta_methods.extend(other.async_meta_methods);
     }
 }
 
 #[inline]
-unsafe fn get_userdata_ref<'a, T>(state: *mut ffi::lua_State) -> Result<Ref<'a, T>> {
-    (*get_userdata::<UserDataCell<T>>(state, -1)).try_borrow()
+unsafe fn get_userdata_ref<'a, T>(state: *mut ffi::lua_State, index: c_int) -> Result<Ref<'a, T>> {
+    (*get_userdata::<UserDataCell<T>>(state, index)).try_borrow()
 }
 
 #[inline]
-unsafe fn get_userdata_mut<'a, T>(state: *mut ffi::lua_State) -> Result<RefMut<'a, T>> {
-    (*get_userdata::<UserDataCell<T>>(state, -1)).try_borrow_mut()
+unsafe fn get_userdata_mut<'a, T>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+) -> Result<RefMut<'a, T>> {
+    (*get_userdata::<UserDataCell<T>>(state, index)).try_borrow_mut()
 }
 
 macro_rules! lua_userdata_impl {
     ($type:ty) => {
         impl<T: UserData + 'static> UserData for $type {
             fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
-                let mut orig_fields = UserDataRegistrar::new();
+                let mut orig_fields = UserDataRegistry::new();
                 T::add_fields(&mut orig_fields);
-                for (name, callback) in orig_fields.field_getters {
-                    fields.add_field_getter(name, callback);
-                }
-                for (name, callback) in orig_fields.field_setters {
-                    fields.add_field_setter(name, callback);
-                }
+                fields.append_fields_from(orig_fields);
             }
 
             fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-                let mut orig_methods = UserDataRegistrar::new();
+                let mut orig_methods = UserDataRegistry::new();
                 T::add_methods(&mut orig_methods);
-                for (name, callback) in orig_methods.methods {
-                    methods.add_callback(name, callback);
-                }
-                #[cfg(feature = "async")]
-                for (name, callback) in orig_methods.async_methods {
-                    methods.add_async_callback(name, callback);
-                }
-                for (meta, callback) in orig_methods.meta_methods {
-                    methods.add_meta_callback(meta, callback);
-                }
-                #[cfg(feature = "async")]
-                for (meta, callback) in orig_methods.async_meta_methods {
-                    methods.add_async_meta_callback(meta, callback);
-                }
+                methods.append_methods_from(orig_methods);
             }
         }
     };
 }
 
+#[cfg(not(feature = "send"))]
+lua_userdata_impl!(Rc<T>);
 #[cfg(not(feature = "send"))]
 lua_userdata_impl!(Rc<RefCell<T>>);
+
+lua_userdata_impl!(Arc<T>);
 lua_userdata_impl!(Arc<Mutex<T>>);
 lua_userdata_impl!(Arc<RwLock<T>>);
 #[cfg(feature = "parking_lot")]

src/util/mod.rs

@@ -1,11 +1,12 @@
 use std::any::{Any, TypeId};
+use std::borrow::Cow;
 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;
-use std::{mem, ptr, slice};
+use std::{mem, ptr, slice, str};
 
 use once_cell::sync::Lazy;
 use rustc_hash::FxHashMap;
@@ -13,6 +14,8 @@ use rustc_hash::FxHashMap;
 use crate::error::{Error, Result};
 use crate::memory::MemoryState;
 
+pub(crate) use short_names::short_type_name;
+
 static METATABLE_CACHE: Lazy<FxHashMap<TypeId, u8>> = Lazy::new(|| {
     let mut map = FxHashMap::with_capacity_and_hasher(32, Default::default());
     crate::lua::init_metatable_cache(&mut map);
@@ -85,7 +88,7 @@ impl Drop for StackGuard {
 pub unsafe fn protect_lua_call(
     state: *mut ffi::lua_State,
     nargs: c_int,
-    f: unsafe extern "C" fn(*mut ffi::lua_State) -> c_int,
+    f: unsafe extern "C-unwind" fn(*mut ffi::lua_State) -> c_int,
 ) -> Result<()> {
     let stack_start = ffi::lua_gettop(state) - nargs;
 
@@ -130,7 +133,7 @@ where
         nresults: c_int,
     }
 
-    unsafe extern "C" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
+    unsafe extern "C-unwind" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
     where
         F: Fn(*mut ffi::lua_State) -> R,
         R: Copy,
@@ -249,10 +252,12 @@ pub unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect: bool) -
 #[inline]
 pub unsafe fn push_table(
     state: *mut ffi::lua_State,
-    narr: c_int,
-    nrec: c_int,
+    narr: usize,
+    nrec: usize,
     protect: bool,
 ) -> 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 {
         protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
     } else {
@@ -290,7 +295,7 @@ pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool)
 #[cfg(feature = "luau")]
 #[inline]
 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) {
+    unsafe extern "C-unwind" fn destructor<T>(ud: *mut c_void) {
         ptr::drop_in_place(ud as *mut T);
     }
 
@@ -395,14 +400,17 @@ pub unsafe fn get_gc_userdata<T: Any>(
     ud
 }
 
-unsafe extern "C" fn lua_error_impl(state: *mut ffi::lua_State) -> c_int {
+unsafe extern "C-unwind" fn lua_error_impl(state: *mut ffi::lua_State) -> c_int {
     ffi::lua_error(state);
 }
 
-unsafe extern "C" fn lua_isfunction_impl(state: *mut ffi::lua_State) -> c_int {
-    let t = ffi::lua_type(state, -1);
-    ffi::lua_pop(state, 1);
-    ffi::lua_pushboolean(state, (t == ffi::LUA_TFUNCTION) as c_int);
+unsafe extern "C-unwind" fn lua_isfunction_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_pushboolean(state, ffi::lua_isfunction(state, -1));
+    1
+}
+
+unsafe extern "C-unwind" fn lua_istable_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_pushboolean(state, ffi::lua_istable(state, -1));
     1
 }
 
@@ -416,14 +424,19 @@ unsafe fn init_userdata_metatable_index(state: *mut ffi::lua_State) -> Result<()
     // Create and cache `__index` generator
     let code = cstr!(
         r#"
-            local error, isfunction = ...
+            local error, isfunction, istable = ...
             return function (__index, field_getters, methods)
-                -- Fastpath to return methods table for index access
-                if __index == nil and field_getters == nil then
-                    return methods
+                -- Common case: has field getters and index is a table
+                if field_getters ~= nil and methods == nil and istable(__index) then
+                    return function (self, key)
+                        local field_getter = field_getters[key]
+                        if field_getter ~= nil then
+                            return field_getter(self)
+                        end
+                        return __index[key]
+                    end
                 end
 
-                -- Alternatively return a function for index access
                 return function (self, key)
                     if field_getters ~= nil then
                         local field_getter = field_getters[key]
@@ -458,7 +471,13 @@ unsafe fn init_userdata_metatable_index(state: *mut ffi::lua_State) -> Result<()
         }
         ffi::lua_pushcfunction(state, lua_error_impl);
         ffi::lua_pushcfunction(state, lua_isfunction_impl);
-        ffi::lua_call(state, 2, 1);
+        ffi::lua_pushcfunction(state, lua_istable_impl);
+        ffi::lua_call(state, 3, 1);
+
+        #[cfg(feature = "luau-jit")]
+        if ffi::luau_codegen_supported() != 0 {
+            ffi::luau_codegen_compile(state, -1);
+        }
 
         // Store in the registry
         ffi::lua_pushvalue(state, -1);
@@ -508,6 +527,11 @@ pub unsafe fn init_userdata_metatable_newindex(state: *mut ffi::lua_State) -> Re
         ffi::lua_pushcfunction(state, lua_isfunction_impl);
         ffi::lua_call(state, 2, 1);
 
+        #[cfg(feature = "luau-jit")]
+        if ffi::luau_codegen_supported() != 0 {
+            ffi::luau_codegen_compile(state, -1);
+        }
+
         // Store in the registry
         ffi::lua_pushvalue(state, -1);
         ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, newindex_key);
@@ -522,12 +546,13 @@ pub unsafe fn init_userdata_metatable_newindex(state: *mut ffi::lua_State) -> Re
 // captured `__index` if no matches found.
 // The same is also applicable for `__newindex` metamethod and `field_setters` table.
 // Internally uses 9 stack spaces and does not call checkstack.
-pub unsafe fn init_userdata_metatable<T>(
+pub unsafe fn init_userdata_metatable(
     state: *mut ffi::lua_State,
     metatable: c_int,
     field_getters: Option<c_int>,
     field_setters: Option<c_int>,
     methods: Option<c_int>,
+    extra_init: Option<fn(*mut ffi::lua_State) -> Result<()>>,
 ) -> Result<()> {
     ffi::lua_pushvalue(state, metatable);
 
@@ -574,10 +599,9 @@ pub unsafe fn init_userdata_metatable<T>(
         rawset_field(state, -2, "__newindex")?;
     }
 
-    #[cfg(not(feature = "luau"))]
-    {
-        ffi::lua_pushcfunction(state, userdata_destructor::<T>);
-        rawset_field(state, -2, "__gc")?;
+    // Additional initialization
+    if let Some(extra_init) = extra_init {
+        extra_init(state)?;
     }
 
     ffi::lua_pushboolean(state, 0);
@@ -589,7 +613,7 @@ pub unsafe fn init_userdata_metatable<T>(
 }
 
 #[cfg(not(feature = "luau"))]
-pub unsafe extern "C" fn userdata_destructor<T>(state: *mut ffi::lua_State) -> c_int {
+pub unsafe extern "C-unwind" fn userdata_destructor<T>(state: *mut ffi::lua_State) -> c_int {
     // It's probably NOT a good idea to catch Rust panics in finalizer
     // Lua 5.4 ignores it, other versions generates `LUA_ERRGCMM` without calling message handler
     take_userdata::<T>(state);
@@ -634,8 +658,6 @@ where
         Ok(Err(err)) => {
             ffi::lua_settop(state, 1);
 
-            let wrapped_error = ud as *mut WrappedFailure;
-
             // Build `CallbackError` with traceback
             let traceback = if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
                 ffi::luaL_traceback(state, state, ptr::null(), 0);
@@ -646,10 +668,8 @@ where
                 "<not enough stack space for traceback>".to_string()
             };
             let cause = Arc::new(err);
-            ptr::write(
-                wrapped_error,
-                WrappedFailure::Error(Error::CallbackError { traceback, cause }),
-            );
+            let wrapped_error = WrappedFailure::Error(Error::CallbackError { traceback, cause });
+            ptr::write(ud, wrapped_error);
             get_gc_metatable::<WrappedFailure>(state);
             ffi::lua_setmetatable(state, -2);
 
@@ -657,7 +677,7 @@ where
         }
         Err(p) => {
             ffi::lua_settop(state, 1);
-            ptr::write(ud as *mut WrappedFailure, WrappedFailure::Panic(Some(p)));
+            ptr::write(ud, WrappedFailure::Panic(Some(p)));
             get_gc_metatable::<WrappedFailure>(state);
             ffi::lua_setmetatable(state, -2);
             ffi::lua_error(state)
@@ -665,7 +685,7 @@ where
     }
 }
 
-pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
+pub unsafe extern "C-unwind" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
     // Luau calls error handler for memory allocation errors, skip it
     // See https://github.com/Roblox/luau/issues/880
     #[cfg(feature = "luau")]
@@ -705,7 +725,7 @@ pub unsafe fn error_traceback_thread(state: *mut ffi::lua_State, thread: *mut ff
 }
 
 // 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 {
+pub unsafe extern "C-unwind" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
     ffi::luaL_checkstack(state, 2, ptr::null());
 
     let top = ffi::lua_gettop(state);
@@ -731,8 +751,8 @@ pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
 }
 
 // A variant of `xpcall` that does not allow Lua to catch Rust panics from `callback_error`.
-pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
-    unsafe extern "C" fn xpcall_msgh(state: *mut ffi::lua_State) -> c_int {
+pub unsafe extern "C-unwind" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
+    unsafe extern "C-unwind" fn xpcall_msgh(state: *mut ffi::lua_State) -> c_int {
         ffi::luaL_checkstack(state, 2, ptr::null());
 
         if let Some(WrappedFailure::Panic(_)) =
@@ -846,7 +866,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
 
     // Create error and panic metatables
 
-    unsafe extern "C" fn error_tostring(state: *mut ffi::lua_State) -> c_int {
+    unsafe extern "C-unwind" fn error_tostring(state: *mut ffi::lua_State) -> c_int {
         callback_error(state, |_| {
             check_stack(state, 3)?;
 
@@ -904,7 +924,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
 
     // Create destructed userdata metatable
 
-    unsafe extern "C" fn destructed_error(state: *mut ffi::lua_State) -> c_int {
+    unsafe extern "C-unwind" fn destructed_error(state: *mut ffi::lua_State) -> c_int {
         callback_error(state, |_| Err(Error::CallbackDestructed))
     }
 
@@ -987,7 +1007,7 @@ impl WrappedFailure {
         let size = mem::size_of::<WrappedFailure>();
         #[cfg(feature = "luau")]
         let ud = {
-            unsafe extern "C" fn destructor(p: *mut c_void) {
+            unsafe extern "C-unwind" fn destructor(p: *mut c_void) {
                 ptr::drop_in_place(p as *mut WrappedFailure);
             }
             ffi::lua_newuserdatadtor(state, size, destructor) as *mut Self
@@ -1023,7 +1043,10 @@ pub(crate) unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> Stri
             let v = ffi::lua_tovector(state, index);
             mlua_debug_assert!(!v.is_null(), "vector is null");
             let (x, y, z) = (*v, *v.add(1), *v.add(2));
-            format!("vector({x},{y},{z})")
+            #[cfg(not(feature = "luau-vector4"))]
+            return format!("vector({x}, {y}, {z})");
+            #[cfg(feature = "luau-vector4")]
+            return format!("vector({x}, {y}, {z}, {w})", w = *v.add(3));
         }
         ffi::LUA_TSTRING => {
             let mut size = 0;
@@ -1045,14 +1068,30 @@ pub(crate) unsafe fn get_destructed_userdata_metatable(state: *mut ffi::lua_Stat
     ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, key);
 }
 
-pub(crate) unsafe fn ptr_to_cstr_bytes<'a>(input: *const c_char) -> Option<&'a [u8]> {
+pub(crate) unsafe fn ptr_to_str<'a>(input: *const c_char) -> Option<&'a str> {
     if input.is_null() {
         return None;
     }
-    Some(CStr::from_ptr(input).to_bytes())
+    str::from_utf8(CStr::from_ptr(input).to_bytes()).ok()
+}
+
+pub(crate) unsafe fn ptr_to_lossy_str<'a>(input: *const c_char) -> Option<Cow<'a, str>> {
+    if input.is_null() {
+        return None;
+    }
+    Some(String::from_utf8_lossy(CStr::from_ptr(input).to_bytes()))
+}
+
+pub(crate) fn linenumber_to_usize(n: c_int) -> Option<usize> {
+    match n {
+        n if n < 0 => None,
+        n => Some(n as usize),
+    }
 }
 
 static DESTRUCTED_USERDATA_METATABLE: u8 = 0;
 static ERROR_PRINT_BUFFER_KEY: u8 = 0;
 static USERDATA_METATABLE_INDEX: u8 = 0;
 static USERDATA_METATABLE_NEWINDEX: u8 = 0;
+
+mod short_names;

src/util/short_names.rs

@@ -0,0 +1,85 @@
+//! Mostly copied from [bevy_utils]
+//!
+//! [bevy_utils]: https://github.com/bevyengine/bevy/blob/main/crates/bevy_utils/src/short_names.rs
+
+use std::any::type_name;
+
+/// Returns a short version of a type name `T` without all module paths.
+///
+/// The short name of a type is its full name as returned by
+/// [`std::any::type_name`], but with the prefix of all paths removed. For
+/// example, the short name of `alloc::vec::Vec<core::option::Option<u32>>`
+/// would be `Vec<Option<u32>>`.
+pub(crate) fn short_type_name<T: ?Sized>() -> String {
+    let full_name = type_name::<T>();
+
+    // Generics result in nested paths within <..> blocks.
+    // Consider "core::option::Option<alloc::string::String>".
+    // To tackle this, we parse the string from left to right, collapsing as we go.
+    let mut index: usize = 0;
+    let end_of_string = full_name.len();
+    let mut parsed_name = String::new();
+
+    while index < end_of_string {
+        let rest_of_string = full_name.get(index..end_of_string).unwrap_or_default();
+
+        // Collapse everything up to the next special character,
+        // then skip over it
+        if let Some(special_character_index) = rest_of_string
+            .find(|c: char| [' ', '<', '>', '(', ')', '[', ']', ',', ';'].contains(&c))
+        {
+            let segment_to_collapse = rest_of_string
+                .get(0..special_character_index)
+                .unwrap_or_default();
+            parsed_name += collapse_type_name(segment_to_collapse);
+            // Insert the special character
+            let special_character =
+                &rest_of_string[special_character_index..=special_character_index];
+            parsed_name.push_str(special_character);
+
+            match special_character {
+                ">" | ")" | "]"
+                    if rest_of_string[special_character_index + 1..].starts_with("::") =>
+                {
+                    parsed_name.push_str("::");
+                    // Move the index past the "::"
+                    index += special_character_index + 3;
+                }
+                // Move the index just past the special character
+                _ => index += special_character_index + 1,
+            }
+        } else {
+            // If there are no special characters left, we're done!
+            parsed_name += collapse_type_name(rest_of_string);
+            index = end_of_string;
+        }
+    }
+    parsed_name
+}
+
+#[inline(always)]
+fn collapse_type_name(string: &str) -> &str {
+    string.rsplit("::").next().unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::short_type_name;
+    use std::collections::HashMap;
+
+    #[test]
+    fn tests() {
+        assert_eq!(short_type_name::<String>(), "String");
+        assert_eq!(short_type_name::<Option<String>>(), "Option<String>");
+        assert_eq!(short_type_name::<(String, &str)>(), "(String, &str)");
+        assert_eq!(short_type_name::<[i32; 3]>(), "[i32; 3]");
+        assert_eq!(
+            short_type_name::<HashMap<String, Option<[i32; 3]>>>(),
+            "HashMap<String, Option<[i32; 3]>>"
+        );
+        assert_eq!(
+            short_type_name::<dyn Fn(i32) -> i32>(),
+            "dyn Fn(i32) -> i32"
+        );
+    }
+}

src/value.rs

@@ -3,6 +3,7 @@ use std::collections::HashSet;
 use std::iter::{self, FromIterator};
 use std::ops::Index;
 use std::os::raw::c_void;
+use std::string::String as StdString;
 use std::sync::Arc;
 use std::{fmt, ptr, slice, str, vec};
 
@@ -21,6 +22,7 @@ use crate::table::Table;
 use crate::thread::Thread;
 use crate::types::{Integer, LightUserData, Number};
 use crate::userdata::AnyUserData;
+use crate::util::{check_stack, StackGuard};
 
 /// A dynamically typed Lua value. The `String`, `Table`, `Function`, `Thread`, and `UserData`
 /// variants contain handle types into the internal Lua state. It is a logic error to mix handle
@@ -42,7 +44,7 @@ pub enum Value<'lua> {
     /// A Luau vector.
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    Vector(f32, f32, f32),
+    Vector(crate::types::Vector),
     /// An interned string, managed by Lua.
     ///
     /// Unlike Rust strings, Lua strings may not be valid UTF-8.
@@ -63,6 +65,12 @@ pub enum Value<'lua> {
 pub use self::Value::Nil;
 
 impl<'lua> Value<'lua> {
+    /// A special value (lightuserdata) to represent null value.
+    ///
+    /// It can be used in Lua tables without downsides of `nil`.
+    pub const NULL: Value<'static> = Value::LightUserData(LightUserData(ptr::null_mut()));
+
+    /// Returns type name of this value.
     pub const fn type_name(&self) -> &'static str {
         match *self {
             Value::Nil => "nil",
@@ -71,7 +79,7 @@ impl<'lua> Value<'lua> {
             Value::Integer(_) => "integer",
             Value::Number(_) => "number",
             #[cfg(feature = "luau")]
-            Value::Vector(_, _, _) => "vector",
+            Value::Vector(_) => "vector",
             Value::String(_) => "string",
             Value::Table(_) => "table",
             Value::Function(_) => "function",
@@ -108,18 +116,46 @@ impl<'lua> Value<'lua> {
     /// 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::Table(t) => t.to_pointer(),
-                Value::String(s) => s.to_pointer(),
-                Value::Function(Function(r))
-                | Value::Thread(Thread(r))
-                | Value::UserData(AnyUserData(r)) => {
-                    ffi::lua_topointer(r.lua.ref_thread(), r.index)
-                }
-                _ => ptr::null(),
-            }
+        match self {
+            Value::LightUserData(ud) => ud.0,
+            Value::String(String(r))
+            | Value::Table(Table(r))
+            | Value::Function(Function(r))
+            | Value::Thread(Thread(r))
+            | Value::UserData(AnyUserData(r)) => r.to_pointer(),
+            _ => ptr::null(),
+        }
+    }
+
+    /// Converts the value to a string.
+    ///
+    /// If the value has a metatable with a `__tostring` method, then it will be called to get the result.
+    pub fn to_string(&self) -> Result<StdString> {
+        match self {
+            Value::Nil => Ok("nil".to_string()),
+            Value::Boolean(b) => Ok(b.to_string()),
+            Value::LightUserData(ud) if ud.0.is_null() => Ok("null".to_string()),
+            Value::LightUserData(ud) => Ok(format!("lightuserdata: {:p}", ud.0)),
+            Value::Integer(i) => Ok(i.to_string()),
+            Value::Number(n) => Ok(n.to_string()),
+            #[cfg(feature = "luau")]
+            Value::Vector(v) => Ok(v.to_string()),
+            Value::String(s) => Ok(s.to_str()?.to_string()),
+            Value::Table(Table(r))
+            | Value::Function(Function(r))
+            | Value::Thread(Thread(r))
+            | Value::UserData(AnyUserData(r)) => unsafe {
+                let state = r.lua.state();
+                let _guard = StackGuard::new(state);
+                check_stack(state, 3)?;
+
+                r.lua.push_ref(r);
+                protect_lua!(state, 1, 1, fn(state) {
+                    ffi::luaL_tolstring(state, -1, ptr::null_mut());
+                })?;
+                Ok(String(r.lua.pop_ref()).to_str()?.to_string())
+            },
+            Value::Error(err) => Ok(err.to_string()),
         }
     }
 
@@ -174,22 +210,29 @@ impl<'lua> Value<'lua> {
             Value::Nil => write!(fmt, "nil"),
             Value::Boolean(b) => write!(fmt, "{b}"),
             Value::LightUserData(ud) if ud.0.is_null() => write!(fmt, "null"),
-            Value::LightUserData(ud) => write!(fmt, "<lightuserdata {:?}>", ud.0),
+            Value::LightUserData(ud) => write!(fmt, "lightuserdata: {:?}", ud.0),
             Value::Integer(i) => write!(fmt, "{i}"),
             Value::Number(n) => write!(fmt, "{n}"),
             #[cfg(feature = "luau")]
-            Value::Vector(x, y, z) => write!(fmt, "vector({x}, {y}, {z})"),
+            Value::Vector(v) => write!(fmt, "{v}"),
             Value::String(s) => write!(fmt, "{s:?}"),
             Value::Table(t) if recursive && !visited.contains(&t.to_pointer()) => {
                 t.fmt_pretty(fmt, ident, visited)
             }
-            t @ Value::Table(_) => write!(fmt, "<table {:?}>", t.to_pointer()),
-            f @ Value::Function(_) => write!(fmt, "<function {:?}>", f.to_pointer()),
-            t @ Value::Thread(_) => write!(fmt, "<thread {:?}>", t.to_pointer()),
-            // TODO: Show type name for registered userdata
-            u @ Value::UserData(_) => write!(fmt, "<userdata {:?}>", u.to_pointer()),
+            t @ Value::Table(_) => write!(fmt, "table: {:?}", t.to_pointer()),
+            f @ Value::Function(_) => write!(fmt, "function: {:?}", f.to_pointer()),
+            t @ Value::Thread(_) => write!(fmt, "thread: {:?}", t.to_pointer()),
+            u @ Value::UserData(ud) => {
+                // Try `__name/__type` first then `__tostring`
+                let name = ud.type_name().ok().flatten();
+                let s = name
+                    .map(|name| format!("{name}: {:?}", u.to_pointer()))
+                    .or_else(|| u.to_string().ok())
+                    .unwrap_or_else(|| format!("userdata: {:?}", u.to_pointer()));
+                write!(fmt, "{s}")
+            }
             Value::Error(e) if recursive => write!(fmt, "{e:?}"),
-            Value::Error(_) => write!(fmt, "<error>"),
+            Value::Error(_) => write!(fmt, "error"),
         }
     }
 }
@@ -206,7 +249,7 @@ impl fmt::Debug for Value<'_> {
             Value::Integer(i) => write!(fmt, "Integer({i})"),
             Value::Number(n) => write!(fmt, "Number({n})"),
             #[cfg(feature = "luau")]
-            Value::Vector(x, y, z) => write!(fmt, "Vector({x}, {y}, {z})"),
+            Value::Vector(v) => write!(fmt, "{v:?}"),
             Value::String(s) => write!(fmt, "String({s:?})"),
             Value::Table(t) => write!(fmt, "{t:?}"),
             Value::Function(f) => write!(fmt, "{f:?}"),
@@ -228,7 +271,7 @@ impl<'lua> PartialEq for Value<'lua> {
             (Value::Number(a), Value::Integer(b)) => *a == *b as Number,
             (Value::Number(a), Value::Number(b)) => *a == *b,
             #[cfg(feature = "luau")]
-            (Value::Vector(x1, y1, z1), Value::Vector(x2, y2, z2)) => (x1, y1, z1) == (x2, y2, z2),
+            (Value::Vector(v1), Value::Vector(v2)) => v1 == v2,
             (Value::String(a), Value::String(b)) => a == b,
             (Value::Table(a), Value::Table(b)) => a == b,
             (Value::Function(a), Value::Function(b)) => a == b,
@@ -260,7 +303,7 @@ impl<'lua> Serialize for Value<'lua> {
                 .serialize_i64((*i).try_into().expect("cannot convert Lua Integer to i64")),
             Value::Number(n) => serializer.serialize_f64(*n),
             #[cfg(feature = "luau")]
-            Value::Vector(x, y, z) => (x, y, z).serialize(serializer),
+            Value::Vector(v) => v.serialize(serializer),
             Value::String(s) => s.serialize(serializer),
             Value::Table(t) => t.serialize(serializer),
             Value::UserData(ud) => ud.serialize(serializer),

tests/async.rs

@@ -1,10 +1,8 @@
 #![cfg(feature = "async")]
 
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use futures_timer::Delay;
 use futures_util::stream::TryStreamExt;
 
 use mlua::{
@@ -12,6 +10,10 @@ use mlua::{
     UserDataMethods, Value,
 };
 
+async fn sleep_ms(ms: u64) {
+    tokio::time::sleep(Duration::from_millis(ms)).await;
+}
+
 #[tokio::test]
 async fn test_async_function() -> Result<()> {
     let lua = Lua::new();
@@ -44,7 +46,7 @@ async fn test_async_sleep() -> Result<()> {
     let lua = Lua::new();
 
     let sleep = lua.create_async_function(move |_lua, n: u64| async move {
-        Delay::new(Duration::from_millis(n)).await;
+        sleep_ms(n).await;
         Ok(format!("elapsed:{}ms", n))
     })?;
     lua.globals().set("sleep", sleep)?;
@@ -60,7 +62,7 @@ async fn test_async_call() -> Result<()> {
     let lua = Lua::new();
 
     let hello = lua.create_async_function(|_lua, name: String| async move {
-        Delay::new(Duration::from_millis(10)).await;
+        sleep_ms(10).await;
         Ok(format!("hello, {}!", name))
     })?;
 
@@ -103,7 +105,7 @@ async fn test_async_handle_yield() -> Result<()> {
     let lua = Lua::new();
 
     let sum = lua.create_async_function(|_lua, (a, b): (i64, i64)| async move {
-        Delay::new(Duration::from_millis(10)).await;
+        sleep_ms(10).await;
         Ok(a + b)
     })?;
 
@@ -161,10 +163,10 @@ async fn test_async_return_async_closure() -> Result<()> {
     let lua = Lua::new();
 
     let f = lua.create_async_function(|lua, a: i64| async move {
-        Delay::new(Duration::from_millis(10)).await;
+        sleep_ms(10).await;
 
         let g = lua.create_async_function(move |_, b: i64| async move {
-            Delay::new(Duration::from_millis(10)).await;
+            sleep_ms(10).await;
             return Ok(a + b);
         })?;
 
@@ -254,7 +256,7 @@ async fn test_async_thread() -> Result<()> {
     let f = lua.create_async_function(move |_lua, ()| {
         let cnt3 = cnt2.clone();
         async move {
-            Delay::new(Duration::from_millis(*cnt3.as_ref())).await;
+            sleep_ms(*cnt3.as_ref()).await;
             Ok("done")
         }
     })?;
@@ -297,40 +299,34 @@ async fn test_async_table() -> Result<()> {
     table.set("val", 10)?;
 
     let get_value = lua.create_async_function(|_, table: Table| async move {
-        Delay::new(Duration::from_millis(10)).await;
+        sleep_ms(10).await;
         table.get::<_, i64>("val")
     })?;
     table.set("get_value", get_value)?;
 
     let set_value = lua.create_async_function(|_, (table, n): (Table, i64)| async move {
-        Delay::new(Duration::from_millis(10)).await;
+        sleep_ms(10).await;
         table.set("val", n)
     })?;
     table.set("set_value", set_value)?;
 
     let sleep = lua.create_async_function(|_, n| async move {
-        Delay::new(Duration::from_millis(n)).await;
+        sleep_ms(n).await;
         Ok(format!("elapsed:{}ms", n))
     })?;
     table.set("sleep", sleep)?;
 
     assert_eq!(
-        table
-            .call_async_method::<_, _, i64>("get_value", ())
-            .await?,
+        table.call_async_method::<_, i64>("get_value", ()).await?,
         10
     );
     table.call_async_method("set_value", 15).await?;
     assert_eq!(
-        table
-            .call_async_method::<_, _, i64>("get_value", ())
-            .await?,
+        table.call_async_method::<_, i64>("get_value", ()).await?,
         15
     );
     assert_eq!(
-        table
-            .call_async_function::<_, _, String>("sleep", 7)
-            .await?,
+        table.call_async_function::<_, String>("sleep", 7).await?,
         "elapsed:7ms"
     );
 
@@ -343,12 +339,12 @@ async fn test_async_thread_pool() -> Result<()> {
     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()))
+        sleep_ms(10).await;
+        Err::<(), _>(Error::runtime("test"))
     })?;
 
     let sleep = lua.create_async_function(|_, n| async move {
-        Delay::new(Duration::from_millis(n)).await;
+        sleep_ms(n).await;
         Ok(format!("elapsed:{}ms", n))
     })?;
 
@@ -361,31 +357,30 @@ async fn test_async_thread_pool() -> Result<()> {
 
 #[tokio::test]
 async fn test_async_userdata() -> Result<()> {
-    #[derive(Clone)]
-    struct MyUserData(Arc<AtomicU64>);
+    struct MyUserData(u64);
 
     impl UserData for MyUserData {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
             methods.add_async_method("get_value", |_, data, ()| async move {
-                Delay::new(Duration::from_millis(10)).await;
-                Ok(data.0.load(Ordering::Relaxed))
+                sleep_ms(10).await;
+                Ok(data.0)
             });
 
-            methods.add_async_method("set_value", |_, data, n| async move {
-                Delay::new(Duration::from_millis(10)).await;
-                data.0.store(n, Ordering::Relaxed);
+            methods.add_async_method_mut("set_value", |_, data, n| async move {
+                sleep_ms(10).await;
+                data.0 = n;
                 Ok(())
             });
 
             methods.add_async_function("sleep", |_, n| async move {
-                Delay::new(Duration::from_millis(n)).await;
+                sleep_ms(n).await;
                 Ok(format!("elapsed:{}ms", n))
             });
 
             #[cfg(not(any(feature = "lua51", feature = "luau")))]
             methods.add_async_meta_method(mlua::MetaMethod::Call, |_, data, ()| async move {
-                let n = data.0.load(Ordering::Relaxed);
-                Delay::new(Duration::from_millis(n)).await;
+                let n = data.0;
+                sleep_ms(n).await;
                 Ok(format!("elapsed:{}ms", n))
             });
 
@@ -393,25 +388,26 @@ async fn test_async_userdata() -> Result<()> {
             methods.add_async_meta_method(
                 mlua::MetaMethod::Index,
                 |_, data, key: String| async move {
-                    Delay::new(Duration::from_millis(10)).await;
+                    sleep_ms(10).await;
                     match key.as_str() {
-                        "ms" => Ok(Some(data.0.load(Ordering::Relaxed) as f64)),
-                        "s" => Ok(Some((data.0.load(Ordering::Relaxed) as f64) / 1000.0)),
+                        "ms" => Ok(Some(data.0 as f64)),
+                        "s" => Ok(Some((data.0 as f64) / 1000.0)),
                         _ => Ok(None),
                     }
                 },
             );
 
             #[cfg(not(any(feature = "lua51", feature = "luau")))]
-            methods.add_async_meta_method(
+            methods.add_async_meta_method_mut(
                 mlua::MetaMethod::NewIndex,
                 |_, data, (key, value): (String, f64)| async move {
-                    Delay::new(Duration::from_millis(10)).await;
+                    sleep_ms(10).await;
                     match key.as_str() {
-                        "ms" => Ok(data.0.store(value as u64, Ordering::Relaxed)),
-                        "s" => Ok(data.0.store((value * 1000.0) as u64, Ordering::Relaxed)),
-                        _ => Err(Error::external(format!("key '{}' not found", key))),
+                        "ms" => data.0 = value as u64,
+                        "s" => data.0 = (value * 1000.0) as u64,
+                        _ => return Err(Error::external(format!("key '{}' not found", key))),
                     }
+                    Ok(())
                 },
             );
         }
@@ -420,7 +416,7 @@ async fn test_async_userdata() -> Result<()> {
     let lua = Lua::new();
     let globals = lua.globals();
 
-    let userdata = lua.create_userdata(MyUserData(Arc::new(AtomicU64::new(11))))?;
+    let userdata = lua.create_userdata(MyUserData(11))?;
     globals.set("userdata", userdata.clone())?;
 
     lua.load(
@@ -492,7 +488,7 @@ async fn test_owned_async_call() -> Result<()> {
 
     let hello = lua
         .create_async_function(|_, name: String| async move {
-            Delay::new(Duration::from_millis(10)).await;
+            sleep_ms(10).await;
             Ok(format!("hello, {}!", name))
         })?
         .into_owned();
@@ -502,3 +498,25 @@ async fn test_owned_async_call() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_async_terminate() -> Result<()> {
+    let lua = Lua::new();
+
+    let mutex = Arc::new(Mutex::new(0u32));
+    let mutex2 = mutex.clone();
+    let func = lua.create_async_function(move |_, ()| {
+        let mutex = mutex2.clone();
+        async move {
+            let _guard = mutex.lock();
+            sleep_ms(100).await;
+            Ok(())
+        }
+    })?;
+
+    let _ = tokio::time::timeout(Duration::from_millis(30), func.call_async::<_, ()>(())).await;
+    lua.gc_collect()?;
+    assert!(mutex.try_lock().is_ok());
+
+    Ok(())
+}

tests/chunk.rs

@@ -1,7 +1,7 @@
 use std::fs;
 use std::io;
 
-use mlua::{Lua, Result};
+use mlua::{AnyUserData, Function, Lua, Result};
 
 #[test]
 fn test_chunk_path() -> Result<()> {
@@ -36,12 +36,24 @@ fn test_chunk_macro() -> Result<()> {
     let data = lua.create_table()?;
     data.raw_set("num", 1)?;
 
+    let ud = AnyUserData::wrap("hello");
+    let f = Function::wrap(|_lua, ()| Ok(()));
+
     lua.globals().set("g", 123)?;
 
+    let string = String::new();
+    let str = string.as_str();
+
     lua.load(mlua::chunk! {
         assert($name == "Rustacean")
+        assert(type($table) == "table")
         assert($table[1] == 1)
+        assert(type($data) == "table")
         assert($data.num == 1)
+        assert(type($ud) == "userdata")
+        assert(type($f) == "function")
+        assert(type($str) == "string")
+        assert($str == "")
         assert(g == 123)
         s = 321
     })

tests/compile.rs

@@ -15,7 +15,11 @@ fn test_compilation() {
     t.compile_fail("tests/compile/static_callback_args.rs");
 
     #[cfg(feature = "async")]
-    t.compile_fail("tests/compile/async_nonstatic_userdata.rs");
+    {
+        t.compile_fail("tests/compile/async_any_userdata_method.rs");
+        t.compile_fail("tests/compile/async_nonstatic_userdata.rs");
+        t.compile_fail("tests/compile/async_userdata_method.rs");
+    }
 
     #[cfg(feature = "send")]
     t.compile_fail("tests/compile/non_send.rs");

tests/compile/async_any_userdata_method.rs

@@ -0,0 +1,14 @@
+use mlua::{UserDataMethods, Lua};
+
+fn main() {
+    let lua = Lua::new();
+
+    lua.register_userdata_type::<String>(|reg| {
+        let s = String::new();
+        let mut s = &s;
+        reg.add_async_method("t", |_, this: &String, ()| async {
+            s = this;
+            Ok(())
+        });
+    }).unwrap();
+}

tests/compile/async_any_userdata_method.stderr

@@ -0,0 +1,81 @@
+error: lifetime may not live long enough
+  --> tests/compile/async_any_userdata_method.rs:9:58
+   |
+9  |           reg.add_async_method("t", |_, this: &String, ()| async {
+   |  ___________________________________----------------------_^
+   | |                                   |                    |
+   | |                                   |                    return type of closure `[async block@$DIR/tests/compile/async_any_userdata_method.rs:9:58: 12:10]` contains a lifetime `'2`
+   | |                                   lifetime `'1` represents this closure's body
+10 | |             s = this;
+11 | |             Ok(())
+12 | |         });
+   | |_________^ returning this value requires that `'1` must outlive `'2`
+   |
+   = note: closure implements `Fn`, so references to captured variables can't escape the closure
+
+error[E0596]: cannot borrow `s` as mutable, as it is a captured variable in a `Fn` closure
+  --> tests/compile/async_any_userdata_method.rs:9:58
+   |
+9  |           reg.add_async_method("t", |_, this: &String, ()| async {
+   |  __________________________________________________________^
+10 | |             s = this;
+   | |             - mutable borrow occurs due to use of `s` in closure
+11 | |             Ok(())
+12 | |         });
+   | |_________^ cannot borrow as mutable
+
+error[E0597]: `s` does not live long enough
+  --> tests/compile/async_any_userdata_method.rs:8:21
+   |
+8  |           let mut s = &s;
+   |                       ^^ borrowed value does not live long enough
+9  | /         reg.add_async_method("t", |_, this: &String, ()| async {
+10 | |             s = this;
+11 | |             Ok(())
+12 | |         });
+   | |__________- argument requires that `s` is borrowed for `'static`
+13 |       }).unwrap();
+   |       - `s` dropped here while still borrowed
+
+error[E0521]: borrowed data escapes outside of closure
+  --> tests/compile/async_any_userdata_method.rs:9:9
+   |
+6  |       lua.register_userdata_type::<String>(|reg| {
+   |                                             ---
+   |                                             |
+   |                                             `reg` is a reference that is only valid in the closure body
+   |                                             has type `&mut LuaUserDataRegistry<'1, std::string::String>`
+...
+9  | /         reg.add_async_method("t", |_, this: &String, ()| async {
+10 | |             s = this;
+11 | |             Ok(())
+12 | |         });
+   | |          ^
+   | |          |
+   | |__________`reg` escapes the closure body here
+   |            argument requires that `'1` must outlive `'static`
+   |
+   = note: requirement occurs because of a mutable reference to `LuaUserDataRegistry<'_, std::string::String>`
+   = note: mutable references are invariant over their type parameter
+   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
+
+error[E0373]: closure may outlive the current function, but it borrows `s`, which is owned by the current function
+  --> tests/compile/async_any_userdata_method.rs:9:35
+   |
+9  |         reg.add_async_method("t", |_, this: &String, ()| async {
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^ may outlive borrowed value `s`
+10 |             s = this;
+   |             - `s` is borrowed here
+   |
+note: function requires argument type to outlive `'static`
+  --> tests/compile/async_any_userdata_method.rs:9:9
+   |
+9  | /         reg.add_async_method("t", |_, this: &String, ()| async {
+10 | |             s = this;
+11 | |             Ok(())
+12 | |         });
+   | |__________^
+help: to force the closure to take ownership of `s` (and any other referenced variables), use the `move` keyword
+   |
+9  |         reg.add_async_method("t", move |_, this: &String, ()| async {
+   |                                   ++++

tests/compile/async_nonstatic_userdata.stderr

@@ -4,11 +4,8 @@ error: lifetime may not live long enough
 7  |       impl<'a> UserData for MyUserData<'a> {
    |            -- lifetime `'a` defined here
 8  |           fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-   |                          ---- lifetime `'lua` defined here
 9  | /             methods.add_async_method("print", |_, data, ()| async move {
 10 | |                 println!("{}", data.0);
 11 | |                 Ok(())
 12 | |             });
-   | |______________^ argument requires that `'a` must outlive `'lua`
-   |
-   = help: consider adding the following bound: `'a: 'lua`
+   | |______________^ requires that `'a` must outlive `'static`

tests/compile/async_userdata_method.rs

@@ -0,0 +1,14 @@
+use mlua::{UserData, UserDataMethods};
+
+struct MyUserData;
+
+impl UserData for MyUserData {
+    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+        methods.add_async_method("method", |_, this: &'static Self, ()| async {
+            Ok(())
+        });
+        // ^ lifetime may not live long enough
+    }
+}
+
+fn main() {}

tests/compile/async_userdata_method.stderr

@@ -0,0 +1,17 @@
+warning: unused variable: `this`
+ --> tests/compile/async_userdata_method.rs:7:48
+  |
+7 |         methods.add_async_method("method", |_, this: &'static Self, ()| async {
+  |                                                ^^^^ help: if this is intentional, prefix it with an underscore: `_this`
+  |
+  = note: `#[warn(unused_variables)]` on by default
+
+error: lifetime may not live long enough
+ --> tests/compile/async_userdata_method.rs:7:9
+  |
+6 |       fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+  |                      ---- lifetime `'lua` defined here
+7 | /         methods.add_async_method("method", |_, this: &'static Self, ()| async {
+8 | |             Ok(())
+9 | |         });
+  | |__________^ argument requires that `'lua` must outlive `'static`

tests/compile/non_send.stderr

@@ -21,5 +21,5 @@ note: required because it's used within this closure
 note: required by a bound in `Lua::create_function`
   --> src/lua.rs
    |
-   |         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
-   |                      ^^^^^^^^^ required by this bound in `Lua::create_function`
+   |         F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
+   |                                            ^^^^^^^^^ required by this bound in `Lua::create_function`

tests/debug.rs

@@ -7,7 +7,7 @@ fn test_debug_format() -> Result<()> {
     // Globals
     let globals = lua.globals();
     let dump = format!("{globals:#?}");
-    assert!(dump.starts_with("{\n  [\"_G\"] = <table"));
+    assert!(dump.starts_with("{\n  [\"_G\"] = table:"));
 
     // TODO: Other cases
 

tests/error.rs

@@ -1,3 +1,5 @@
+use std::io;
+
 use mlua::{Error, ErrorContext, Lua, Result};
 
 #[test]
@@ -5,7 +7,7 @@ fn test_error_context() -> Result<()> {
     let lua = Lua::new();
 
     let func = lua.create_function(|_, ()| {
-        Err::<(), _>(Error::RuntimeError("runtime error".into())).context("some context")
+        Err::<(), _>(Error::runtime("runtime error")).context("some context")
     })?;
     lua.globals().set("func", func)?;
 
@@ -29,5 +31,20 @@ fn test_error_context() -> Result<()> {
     println!("{msg2}");
     assert!(msg2.contains("error converting Lua nil to String"));
 
+    // Rewrite context message and test `downcast_ref`
+    let func3 = lua.create_function(|_, ()| {
+        Err::<(), _>(Error::external(io::Error::new(
+            io::ErrorKind::Other,
+            "other",
+        )))
+        .context("some context")
+        .context("some new context")
+    })?;
+    let res = func3.call::<_, ()>(()).err().unwrap();
+    let Error::CallbackError { cause, .. } = &res else { unreachable!() };
+    assert!(!res.to_string().contains("some context"));
+    assert!(res.to_string().contains("some new context"));
+    assert!(cause.downcast_ref::<io::Error>().is_some());
+
     Ok(())
 }

tests/function.rs

@@ -1,4 +1,4 @@
-use mlua::{Function, Lua, Result, String};
+use mlua::{Function, Lua, Result, String, Table};
 
 #[test]
 fn test_function() -> Result<()> {
@@ -86,7 +86,7 @@ fn test_rust_function() -> Result<()> {
 fn test_c_function() -> Result<()> {
     let lua = Lua::new();
 
-    unsafe extern "C" fn c_function(state: *mut mlua::lua_State) -> std::os::raw::c_int {
+    unsafe extern "C-unwind" fn c_function(state: *mut mlua::lua_State) -> std::os::raw::c_int {
         let lua = Lua::init_from_ptr(state);
         lua.globals().set("c_function", true).unwrap();
         0
@@ -114,6 +114,66 @@ fn test_dump() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_function_environment() -> Result<()> {
+    let lua = Lua::new();
+
+    // We must not get or set environment for C functions
+    let rust_func = lua.create_function(|_, ()| Ok("hello"))?;
+    assert_eq!(rust_func.environment(), None);
+    assert_eq!(rust_func.set_environment(lua.globals()).ok(), Some(false));
+
+    // Test getting Lua function environment
+    lua.globals().set("hello", "global")?;
+    let lua_func = lua
+        .load(
+            r#"
+        local t = ""
+        return function()
+            -- two upvalues
+            return t .. hello
+        end
+    "#,
+        )
+        .eval::<Function>()?;
+    let lua_func2 = lua.load("return hello").into_function()?;
+    assert_eq!(lua_func.call::<_, String>(())?, "global");
+    assert_eq!(lua_func.environment(), Some(lua.globals()));
+
+    // Test changing the environment
+    let env = lua.create_table_from([("hello", "local")])?;
+    assert!(lua_func.set_environment(env.clone())?);
+    assert_eq!(lua_func.call::<_, String>(())?, "local");
+    assert_eq!(lua_func2.call::<_, String>(())?, "global");
+
+    // More complex case
+    lua.load(
+        r#"
+        local number = 15
+        function lucky() return tostring("number is "..number) end
+        new_env = {
+            tostring = function() return tostring(number) end,
+        }
+    "#,
+    )
+    .exec()?;
+    let lucky = lua.globals().get::<_, Function>("lucky")?;
+    assert_eq!(lucky.call::<_, String>(())?, "number is 15");
+    let new_env = lua.globals().get::<_, Table>("new_env")?;
+    lucky.set_environment(new_env)?;
+    assert_eq!(lucky.call::<_, String>(())?, "15");
+
+    // Test inheritance
+    let lua_func2 = lua
+        .load(r#"return function() return (function() return hello end)() end"#)
+        .eval::<Function>()?;
+    assert!(lua_func2.set_environment(env.clone())?);
+    lua.gc_collect()?;
+    assert_eq!(lua_func2.call::<_, String>(())?, "local");
+
+    Ok(())
+}
+
 #[test]
 fn test_function_info() -> Result<()> {
     let lua = Lua::new();
@@ -135,35 +195,38 @@ fn test_function_info() -> Result<()> {
 
     let function1_info = function1.info();
     #[cfg(feature = "luau")]
-    assert_eq!(function1_info.name, Some(b"function1".to_vec()));
-    assert_eq!(function1_info.source, Some(b"source1".to_vec()));
-    assert_eq!(function1_info.line_defined, 2);
+    assert_eq!(function1_info.name.as_deref(), Some("function1"));
+    assert_eq!(function1_info.source.as_deref(), Some("source1"));
+    assert_eq!(function1_info.line_defined, Some(2));
     #[cfg(not(feature = "luau"))]
-    assert_eq!(function1_info.last_line_defined, 4);
-    assert_eq!(function1_info.what, Some(b"Lua".to_vec()));
+    assert_eq!(function1_info.last_line_defined, Some(4));
+    #[cfg(feature = "luau")]
+    assert_eq!(function1_info.last_line_defined, None);
+    assert_eq!(function1_info.what, "Lua");
 
     let function2_info = function2.info();
     assert_eq!(function2_info.name, None);
-    assert_eq!(function2_info.source, Some(b"source1".to_vec()));
-    assert_eq!(function2_info.line_defined, 3);
+    assert_eq!(function2_info.source.as_deref(), Some("source1"));
+    assert_eq!(function2_info.line_defined, Some(3));
     #[cfg(not(feature = "luau"))]
-    assert_eq!(function2_info.last_line_defined, 3);
-    assert_eq!(function2_info.what, Some(b"Lua".to_vec()));
+    assert_eq!(function2_info.last_line_defined, Some(3));
+    #[cfg(feature = "luau")]
+    assert_eq!(function2_info.last_line_defined, None);
+    assert_eq!(function2_info.what, "Lua");
 
     let function3_info = function3.info();
     assert_eq!(function3_info.name, None);
-    assert_eq!(function3_info.source, Some(b"=[C]".to_vec()));
-    assert_eq!(function3_info.line_defined, -1);
-    #[cfg(not(feature = "luau"))]
-    assert_eq!(function3_info.last_line_defined, -1);
-    assert_eq!(function3_info.what, Some(b"C".to_vec()));
+    assert_eq!(function3_info.source.as_deref(), Some("=[C]"));
+    assert_eq!(function3_info.line_defined, None);
+    assert_eq!(function3_info.last_line_defined, None);
+    assert_eq!(function3_info.what, "C");
 
     let print_info = globals.get::<_, Function>("print")?.info();
     #[cfg(feature = "luau")]
-    assert_eq!(print_info.name, Some(b"print".to_vec()));
-    assert_eq!(print_info.source, Some(b"=[C]".to_vec()));
-    assert_eq!(print_info.what, Some(b"C".to_vec()));
-    assert_eq!(print_info.line_defined, -1);
+    assert_eq!(print_info.name.as_deref(), Some("print"));
+    assert_eq!(print_info.source.as_deref(), Some("=[C]"));
+    assert_eq!(print_info.what, "C");
+    assert_eq!(print_info.line_defined, None);
 
     Ok(())
 }

tests/hooks.rs

@@ -2,7 +2,6 @@
 
 use std::cell::RefCell;
 use std::ops::Deref;
-use std::str;
 use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::{Arc, Mutex};
 
@@ -29,7 +28,7 @@ fn test_line_counts() -> Result<()> {
         assert_eq!(debug.event(), DebugEvent::Line);
         hook_output.lock().unwrap().push(debug.curr_line());
         Ok(())
-    })?;
+    });
     lua.load(
         r#"
             local x = 2 + 3
@@ -61,11 +60,10 @@ fn test_function_calls() -> Result<()> {
         assert_eq!(debug.event(), DebugEvent::Call);
         let names = debug.names();
         let source = debug.source();
-        let name = names.name.map(|s| str::from_utf8(s).unwrap().to_owned());
-        let what = source.what.map(|s| str::from_utf8(s).unwrap().to_owned());
-        hook_output.lock().unwrap().push((name, what));
+        let name = names.name.map(|s| s.into_owned());
+        hook_output.lock().unwrap().push((name, source.what));
         Ok(())
-    })?;
+    });
 
     lua.load(
         r#"
@@ -80,18 +78,12 @@ fn test_function_calls() -> Result<()> {
     if cfg!(feature = "luajit") && lua.load("jit.version_num").eval::<i64>()? >= 20100 {
         assert_eq!(
             *output,
-            vec![
-                (None, Some("main".to_string())),
-                (Some("len".to_string()), Some("Lua".to_string()))
-            ]
+            vec![(None, "main"), (Some("len".to_string()), "Lua")]
         );
     } else {
         assert_eq!(
             *output,
-            vec![
-                (None, Some("main".to_string())),
-                (Some("len".to_string()), Some("C".to_string()))
-            ]
+            vec![(None, "main"), (Some("len".to_string()), "C")]
         );
     }
 
@@ -103,10 +95,8 @@ fn test_error_within_hook() -> Result<()> {
     let lua = Lua::new();
 
     lua.set_hook(HookTriggers::EVERY_LINE, |_lua, _debug| {
-        Err(Error::RuntimeError(
-            "Something happened in there!".to_string(),
-        ))
-    })?;
+        Err(Error::runtime("Something happened in there!"))
+    });
 
     let err = lua
         .load("x = 1")
@@ -138,12 +128,12 @@ fn test_limit_execution_instructions() -> Result<()> {
         move |_lua, debug| {
             assert_eq!(debug.event(), DebugEvent::Count);
             if max_instructions.fetch_sub(30, Ordering::Relaxed) <= 30 {
-                Err(Error::RuntimeError("time's up".to_string()))
+                Err(Error::runtime("time's up"))
             } else {
                 Ok(())
             }
         },
-    )?;
+    );
 
     lua.globals().set("x", Value::Integer(0))?;
     let _ = lua
@@ -167,11 +157,11 @@ fn test_hook_removal() -> Result<()> {
     lua.set_hook(
         HookTriggers::new().every_nth_instruction(1),
         |_lua, _debug| {
-            Err(Error::RuntimeError(
-                "this hook should've been removed by this time".to_string(),
+            Err(Error::runtime(
+                "this hook should've been removed by this time",
             ))
         },
-    )?;
+    );
 
     assert!(lua.load("local x = 1").exec().is_err());
     lua.remove_hook();
@@ -215,9 +205,10 @@ fn test_hook_swap_within_hook() -> Result<()> {
                             Ok(())
                         },
                     )
-                })
+                });
+                Ok(())
             })
-    })?;
+    });
 
     TL_LUA.with(|tl| {
         let tl = tl.borrow();

tests/luau.rs

@@ -7,7 +7,19 @@ use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 
-use mlua::{Compiler, CoverageInfo, Error, Lua, Result, Table, ThreadStatus, Value, VmState};
+use mlua::{
+    Compiler, CoverageInfo, Error, Lua, Result, Table, ThreadStatus, Value, Vector, VmState,
+};
+
+#[test]
+fn test_version() -> Result<()> {
+    let lua = Lua::new();
+    assert!(lua
+        .globals()
+        .get::<_, String>("_VERSION")?
+        .starts_with("Luau 0."));
+    Ok(())
+}
 
 #[test]
 fn test_require() -> Result<()> {
@@ -40,13 +52,18 @@ fn test_require() -> Result<()> {
     .exec()
 }
 
+#[cfg(not(feature = "luau-vector4"))]
 #[test]
 fn test_vectors() -> Result<()> {
     let lua = Lua::new();
 
-    let v: [f32; 3] = lua.load("vector(1, 2, 3) + vector(3, 2, 1)").eval()?;
+    let v: Vector = lua.load("vector(1, 2, 3) + vector(3, 2, 1)").eval()?;
     assert_eq!(v, [4.0, 4.0, 4.0]);
 
+    // Test conversion into Rust array
+    let v: [f64; 3] = lua.load("vector(1, 2, 3)").eval()?;
+    assert!(v == [1.0, 2.0, 3.0]);
+
     // Test vector methods
     lua.load(
         r#"
@@ -73,6 +90,46 @@ fn test_vectors() -> Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "luau-vector4")]
+#[test]
+fn test_vectors() -> Result<()> {
+    let lua = Lua::new();
+
+    let v: Vector = lua.load("vector(1, 2, 3, 4) + vector(4, 3, 2, 1)").eval()?;
+    assert_eq!(v, [5.0, 5.0, 5.0, 5.0]);
+
+    // Test conversion into Rust array
+    let v: [f64; 4] = lua.load("vector(1, 2, 3, 4)").eval()?;
+    assert!(v == [1.0, 2.0, 3.0, 4.0]);
+
+    // Test vector methods
+    lua.load(
+        r#"
+        local v = vector(1, 2, 3, 4)
+        assert(v.x == 1)
+        assert(v.y == 2)
+        assert(v.z == 3)
+        assert(v.w == 4)
+    "#,
+    )
+    .exec()?;
+
+    // Test vector methods (fastcall)
+    lua.load(
+        r#"
+        local v = vector(1, 2, 3, 4)
+        assert(v.x == 1)
+        assert(v.y == 2)
+        assert(v.z == 3)
+        assert(v.w == 4)
+    "#,
+    )
+    .set_compiler(Compiler::new().set_vector_ctor(Some("vector".to_string())))
+    .exec()?;
+
+    Ok(())
+}
+
 #[test]
 fn test_readonly_table() -> Result<()> {
     let lua = Lua::new();
@@ -222,7 +279,7 @@ fn test_interrupts() -> Result<()> {
     //
     // Test errors in interrupts
     //
-    lua.set_interrupt(|_| Err(Error::RuntimeError("error from interrupt".into())));
+    lua.set_interrupt(|_| Err(Error::runtime("error from interrupt")));
     match f.call::<_, ()>(()) {
         Err(Error::CallbackError { cause, .. }) => match *cause {
             Error::RuntimeError(ref m) if m == "error from interrupt" => {}
@@ -244,8 +301,8 @@ fn test_coverage() -> Result<()> {
 
     let f = lua
         .load(
-            r#"local v = vector(1, 2, 3)
-        assert(v.x == 1 and v.y == 2 and v.z == 3)
+            r#"local s = "abc"
+        assert(#s == 3)
 
         function abc(i)
             if i < 5 then

tests/memory.rs

@@ -17,12 +17,8 @@ fn test_memory_limit() -> Result<()> {
         .into_function()?;
     f.call::<_, ()>(()).expect("should trigger no memory limit");
 
-    if cfg!(feature = "luajit") && cfg!(not(feature = "vendored")) {
-        // we don't support setting memory limit for non-vendored luajit
-        assert!(matches!(
-            lua.set_memory_limit(0),
-            Err(Error::MemoryLimitNotAvailable)
-        ));
+    if cfg!(feature = "luajit") && lua.set_memory_limit(0).is_err() {
+        // seems this luajit version does not support memory limit
         return Ok(());
     }
 
@@ -46,8 +42,8 @@ fn test_memory_limit_thread() -> Result<()> {
         .load("local t = {}; for i = 1,10000 do t[i] = i end")
         .into_function()?;
 
-    if cfg!(feature = "luajit") && cfg!(not(feature = "vendored")) {
-        // we don't support setting memory limit for non-vendored luajit
+    if cfg!(feature = "luajit") && lua.set_memory_limit(0).is_err() {
+        // seems this luajit version does not support memory limit
         return Ok(());
     }
 

tests/module/.cargo/config

@@ -1,11 +0,0 @@
-[target.x86_64-apple-darwin]
-rustflags = [
-  "-C", "link-arg=-undefined",
-  "-C", "link-arg=dynamic_lookup",
-]
-
-[target.aarch64-apple-darwin]
-rustflags = [
-  "-C", "link-arg=-undefined",
-  "-C", "link-arg=dynamic_lookup",
-]

tests/module/build.rs

@@ -0,0 +1,7 @@
+fn main() {
+    #[cfg(target_os = "macos")]
+    {
+        println!("cargo:rustc-cdylib-link-arg=-undefined");
+        println!("cargo:rustc-cdylib-link-arg=dynamic_lookup");
+    }
+}

tests/module/src/lib.rs

@@ -26,7 +26,7 @@ struct MyUserData(i32);
 
 impl LuaUserData for MyUserData {}
 
-#[mlua::lua_module(name = "test_module_second")]
+#[mlua::lua_module(name = "test_module_second", skip_memory_check)]
 fn test_module2(lua: &Lua) -> LuaResult<LuaTable> {
     let exports = lua.create_table()?;
     exports.set("userdata", MyUserData(123))?;

tests/serde.rs

@@ -145,7 +145,7 @@ fn test_serialize_failure() -> Result<(), Box<dyn StdError>> {
     Ok(())
 }
 
-#[cfg(feature = "luau")]
+#[cfg(all(feature = "luau", not(feature = "luau-vector4")))]
 #[test]
 fn test_serialize_vector() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
@@ -153,7 +153,7 @@ fn test_serialize_vector() -> Result<(), Box<dyn StdError>> {
     let globals = lua.globals();
     globals.set(
         "vector",
-        lua.create_function(|_, (x, y, z)| Ok(Value::Vector(x, y, z)))?,
+        lua.create_function(|_, (x, y, z)| Ok(mlua::Vector::new(x, y, z)))?,
     )?;
 
     let val = lua.load("{_vector = vector(1, 2, 3)}").eval::<Value>()?;
@@ -168,6 +168,29 @@ fn test_serialize_vector() -> Result<(), Box<dyn StdError>> {
     Ok(())
 }
 
+#[cfg(feature = "luau-vector4")]
+#[test]
+fn test_serialize_vector() -> Result<(), Box<dyn StdError>> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    globals.set(
+        "vector",
+        lua.create_function(|_, (x, y, z, w)| Ok(mlua::Vector::new(x, y, z, w)))?,
+    )?;
+
+    let val = lua.load("{_vector = vector(1, 2, 3, 4)}").eval::<Value>()?;
+    let json = serde_json::json!({
+        "_vector": [1.0, 2.0, 3.0, 4.0],
+    });
+    assert_eq!(serde_json::to_value(&val)?, json);
+
+    let expected_json = lua.from_value::<serde_json::Value>(val)?;
+    assert_eq!(expected_json, json);
+
+    Ok(())
+}
+
 #[test]
 fn test_to_value_struct() -> LuaResult<()> {
     let lua = Lua::new();

tests/table.rs

@@ -1,7 +1,7 @@
 use mlua::{Error, Lua, Nil, Result, Table, TableExt, Value};
 
 #[test]
-fn test_set_get() -> Result<()> {
+fn test_globals_set_get() -> Result<()> {
     let lua = Lua::new();
 
     let globals = lua.globals();
@@ -43,6 +43,7 @@ fn test_table() -> Result<()> {
     let table3 = globals.get::<_, Table>("table3")?;
 
     assert_eq!(table1.len()?, 5);
+    assert!(!table1.is_empty());
     assert_eq!(
         table1
             .clone()
@@ -57,8 +58,10 @@ fn test_table() -> Result<()> {
             .collect::<Result<Vec<i64>>>()?,
         vec![1, 2, 3, 4, 5]
     );
+    assert_eq!(table1, [1, 2, 3, 4, 5]);
 
     assert_eq!(table2.len()?, 0);
+    assert!(table2.is_empty());
     assert_eq!(
         table2
             .clone()
@@ -66,12 +69,10 @@ fn test_table() -> Result<()> {
             .collect::<Result<Vec<(i64, i64)>>>()?,
         vec![]
     );
-    assert_eq!(
-        table2.sequence_values().collect::<Result<Vec<i64>>>()?,
-        vec![]
-    );
+    assert_eq!(table2, [0; 0]);
 
     // sequence_values should only iterate until the first border
+    assert_eq!(table3, [1, 2]);
     assert_eq!(
         table3.sequence_values().collect::<Result<Vec<i64>>>()?,
         vec![1, 2]
@@ -116,17 +117,12 @@ fn test_table_push_pop() -> Result<()> {
     // Test raw access
     let table1 = lua.create_sequence_from(vec![123])?;
     table1.raw_push(321)?;
-    assert_eq!(
-        table1
-            .clone()
-            .raw_sequence_values::<i64>()
-            .collect::<Result<Vec<_>>>()?,
-        vec![123, 321]
-    );
+    assert_eq!(table1, [123, 321]);
     assert_eq!(table1.raw_pop::<i64>()?, 321);
     assert_eq!(table1.raw_pop::<i64>()?, 123);
     assert_eq!(table1.raw_pop::<Value>()?, Value::Nil); // An extra pop should do nothing
     assert_eq!(table1.raw_len(), 0);
+    assert_eq!(table1, [0; 0]);
 
     // Test access through metamethods
     let table2 = lua
@@ -144,6 +140,13 @@ fn test_table_push_pop() -> Result<()> {
         .eval::<Table>()?;
     table2.push(345)?;
     assert_eq!(table2.len()?, 2);
+    assert_eq!(
+        table2
+            .clone()
+            .sequence_values::<i64>()
+            .collect::<Result<Vec<_>>>()?,
+        vec![]
+    );
     assert_eq!(table2.pop::<i64>()?, 345);
     assert_eq!(table2.pop::<i64>()?, 234);
     assert_eq!(table2.pop::<Value>()?, Value::Nil);
@@ -191,8 +194,10 @@ fn test_table_clear() -> Result<()> {
         )
         .eval::<Table>()?;
     assert_eq!(t2.raw_len(), 3);
+    assert!(!t2.is_empty());
     t2.clear()?;
     assert_eq!(t2.raw_len(), 0);
+    assert!(t2.is_empty());
     assert_eq!(t2.raw_get::<_, Value>("a")?, Value::Nil);
     assert_ne!(t2.get_metatable(), None);
 
@@ -205,29 +210,9 @@ fn test_table_sequence_from() -> Result<()> {
 
     let get_table = lua.create_function(|_, t: Table| Ok(t))?;
 
-    assert_eq!(
-        get_table
-            .call::<_, Table>(vec![1, 2, 3])?
-            .sequence_values()
-            .collect::<Result<Vec<i64>>>()?,
-        vec![1, 2, 3]
-    );
-
-    assert_eq!(
-        get_table
-            .call::<_, Table>([1, 2, 3].as_ref())?
-            .sequence_values()
-            .collect::<Result<Vec<i64>>>()?,
-        vec![1, 2, 3]
-    );
-
-    assert_eq!(
-        get_table
-            .call::<_, Table>([1, 2, 3])?
-            .sequence_values()
-            .collect::<Result<Vec<i64>>>()?,
-        vec![1, 2, 3]
-    );
+    assert_eq!(get_table.call::<_, Table>(vec![1, 2, 3])?, [1, 2, 3]);
+    assert_eq!(get_table.call::<_, Table>([4, 5, 6])?, [4, 5, 6]);
+    assert_eq!(get_table.call::<_, Table>([7, 8, 9].as_slice())?, [7, 8, 9]);
 
     Ok(())
 }
@@ -377,11 +362,8 @@ fn test_table_call() -> Result<()> {
     let table: Table = lua.globals().get("table")?;
 
     assert_eq!(table.call::<_, String>("b")?, "call_2");
-    assert_eq!(table.call_function::<_, _, String>("func", "a")?, "func_a");
-    assert_eq!(
-        table.call_method::<_, _, String>("method", "a")?,
-        "method_1"
-    );
+    assert_eq!(table.call_function::<_, String>("func", "a")?, "func_a");
+    assert_eq!(table.call_method::<_, String>("method", "a")?, "method_1");
 
     // Test calling non-callable table
     let table2 = lua.create_table()?;

tests/tests.rs

@@ -69,7 +69,7 @@ fn test_safety() -> Result<()> {
 fn test_load() -> Result<()> {
     let lua = Lua::new();
 
-    let func = lua.load("return 1+2").into_function()?;
+    let func = lua.load("\treturn 1+2").into_function()?;
     let result: i32 = func.call(())?;
     assert_eq!(result, 3);
 
@@ -887,19 +887,47 @@ fn test_application_data() -> Result<()> {
     lua.set_app_data("test1");
     lua.set_app_data(vec!["test2"]);
 
+    // Borrow &str immutably and Vec<&str> mutably
+    let s = lua.app_data_ref::<&str>().unwrap();
+    let mut v = lua.app_data_mut::<Vec<&str>>().unwrap();
+    v.push("test3");
+
+    // Insert of new data or removal should fail now
+    assert!(lua.try_set_app_data::<i32>(123).is_err());
+    match catch_unwind(AssertUnwindSafe(|| lua.set_app_data::<i32>(123))) {
+        Ok(_) => panic!("expected panic"),
+        Err(_) => {}
+    }
+    match catch_unwind(AssertUnwindSafe(|| lua.remove_app_data::<i32>())) {
+        Ok(_) => panic!("expected panic"),
+        Err(_) => {}
+    }
+
+    // Check display and debug impls
+    assert_eq!(format!("{s}"), "test1");
+    assert_eq!(format!("{s:?}"), "\"test1\"");
+
+    // Borrowing immutably and mutably of the same type is not allowed
+    match catch_unwind(AssertUnwindSafe(|| lua.app_data_mut::<&str>().unwrap())) {
+        Ok(_) => panic!("expected panic"),
+        Err(_) => {}
+    }
+    drop((s, v));
+
+    // Test that application data is accessible from anywhere
     let f = lua.create_function(|lua, ()| {
-        {
-            let data1 = lua.app_data_ref::<&str>().unwrap();
-            assert_eq!(*data1, "test1");
-        }
-        let mut data2 = lua.app_data_mut::<Vec<&str>>().unwrap();
-        assert_eq!(*data2, vec!["test2"]);
-        data2.push("test3");
+        let mut data1 = lua.app_data_mut::<&str>().unwrap();
+        assert_eq!(*data1, "test1");
+        *data1 = "test4";
+
+        let data2 = lua.app_data_ref::<Vec<&str>>().unwrap();
+        assert_eq!(*data2, vec!["test2", "test3"]);
+
         Ok(())
     })?;
     f.call(())?;
 
-    assert_eq!(*lua.app_data_ref::<&str>().unwrap(), "test1");
+    assert_eq!(*lua.app_data_ref::<&str>().unwrap(), "test4");
     assert_eq!(
         *lua.app_data_ref::<Vec<&str>>().unwrap(),
         vec!["test2", "test3"]
@@ -991,7 +1019,7 @@ fn test_ref_stack_exhaustion() {
     match catch_unwind(AssertUnwindSafe(|| -> Result<()> {
         let lua = Lua::new();
         let mut vals = Vec::new();
-        for _ in 0..1000000 {
+        for _ in 0..10000000 {
             vals.push(lua.create_table()?);
         }
         Ok(())
@@ -1198,8 +1226,8 @@ fn test_inspect_stack() -> Result<()> {
 
     let logline = lua.create_function(|lua, msg: StdString| {
         let debug = lua.inspect_stack(1).unwrap(); // caller
-        let source = debug.source().short_src.map(core::str::from_utf8);
-        let source = source.transpose().unwrap().unwrap_or("?");
+        let source = debug.source().short_src;
+        let source = source.as_deref().unwrap_or("?");
         let line = debug.curr_line();
         Ok(format!("{}:{} {}", source, line, msg))
     })?;
@@ -1250,20 +1278,20 @@ fn test_warnings() -> Result<()> {
     let lua = Lua::new();
     lua.set_app_data::<Vec<(StdString, bool)>>(Vec::new());
 
-    lua.set_warning_function(|lua, msg, tocont| {
-        let msg = msg.to_string_lossy().to_string();
+    lua.set_warning_function(|lua, msg, incomplete| {
         lua.app_data_mut::<Vec<(StdString, bool)>>()
             .unwrap()
-            .push((msg, tocont));
+            .push((msg.to_string(), incomplete));
         Ok(())
     });
 
-    lua.warning("native warning ...", true)?;
-    lua.warning("finish", false)?;
+    lua.warning("native warning ...", true);
+    lua.warning("finish", false);
+    lua.warning("\0", false);
     lua.load(r#"warn("lua warning", "continue")"#).exec()?;
 
     lua.remove_warning_function();
-    lua.warning("one more warning", false)?;
+    lua.warning("one more warning", false);
 
     let messages = lua.app_data_ref::<Vec<(StdString, bool)>>().unwrap();
     assert_eq!(
@@ -1271,13 +1299,14 @@ fn test_warnings() -> Result<()> {
         vec![
             ("native warning ...".to_string(), true),
             ("finish".to_string(), false),
+            ("".to_string(), false),
             ("lua warning".to_string(), true),
             ("continue".to_string(), false),
         ]
     );
 
     // Trigger error inside warning
-    lua.set_warning_function(|_, _, _| Err(Error::RuntimeError("warning error".to_string())));
+    lua.set_warning_function(|_, _, _| Err(Error::runtime("warning error")));
     assert!(matches!(
         lua.load(r#"warn("test")"#).exec(),
         Err(Error::CallbackError { cause, .. })

tests/thread.rs

@@ -94,11 +94,7 @@ fn test_thread() -> Result<()> {
 }
 
 #[test]
-#[cfg(any(
-    feature = "lua54",
-    all(feature = "luajit", feature = "vendored"),
-    feature = "luau",
-))]
+#[cfg(any(feature = "lua54", feature = "luau"))]
 fn test_thread_reset() -> Result<()> {
     use mlua::{AnyUserData, UserData};
     use std::sync::Arc;

tests/userdata.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::string::String as StdString;
 use std::sync::Arc;
 #[cfg(not(feature = "parking_lot"))]
@@ -410,21 +411,21 @@ fn test_user_values() -> Result<()> {
     ud.set_nth_user_value(1, "hello")?;
     ud.set_nth_user_value(2, "world")?;
     ud.set_nth_user_value(65535, 321)?;
-    assert_eq!(ud.get_nth_user_value::<String>(1)?, "hello");
-    assert_eq!(ud.get_nth_user_value::<String>(2)?, "world");
-    assert_eq!(ud.get_nth_user_value::<Value>(3)?, Value::Nil);
-    assert_eq!(ud.get_nth_user_value::<i32>(65535)?, 321);
+    assert_eq!(ud.nth_user_value::<String>(1)?, "hello");
+    assert_eq!(ud.nth_user_value::<String>(2)?, "world");
+    assert_eq!(ud.nth_user_value::<Value>(3)?, Value::Nil);
+    assert_eq!(ud.nth_user_value::<i32>(65535)?, 321);
 
-    assert!(ud.get_nth_user_value::<Value>(0).is_err());
-    assert!(ud.get_nth_user_value::<Value>(65536).is_err());
+    assert!(ud.nth_user_value::<Value>(0).is_err());
+    assert!(ud.nth_user_value::<Value>(65536).is_err());
 
     // Named user values
     ud.set_named_user_value("name", "alex")?;
     ud.set_named_user_value("age", 10)?;
 
-    assert_eq!(ud.get_named_user_value::<String>("name")?, "alex");
-    assert_eq!(ud.get_named_user_value::<i32>("age")?, 10);
-    assert_eq!(ud.get_named_user_value::<Value>("nonexist")?, Value::Nil);
+    assert_eq!(ud.named_user_value::<String>("name")?, "alex");
+    assert_eq!(ud.named_user_value::<i32>("age")?, 10);
+    assert_eq!(ud.named_user_value::<Value>("nonexist")?, Value::Nil);
 
     Ok(())
 }
@@ -486,6 +487,7 @@ fn test_fields() -> Result<()> {
 
     impl UserData for MyUserData {
         fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field("static", "constant");
             fields.add_field_method_get("val", |_, data| Ok(data.0));
             fields.add_field_method_set("val", |_, data, val| {
                 data.0 = val;
@@ -493,15 +495,11 @@ fn test_fields() -> Result<()> {
             });
 
             // Use userdata "uservalue" storage
-            fields.add_field_function_get("uval", |_, ud| ud.get_user_value::<Option<String>>());
+            fields.add_field_function_get("uval", |_, ud| ud.user_value::<Option<String>>());
             fields
                 .add_field_function_set("uval", |_, ud, s| ud.set_user_value::<Option<String>>(s));
 
-            fields.add_meta_field_with(MetaMethod::Index, |lua| {
-                let index = lua.create_table()?;
-                index.set("f", 321)?;
-                Ok(index)
-            });
+            fields.add_meta_field(MetaMethod::Index, HashMap::from([("f", 321)]));
             fields.add_meta_field_with(MetaMethod::NewIndex, |lua| {
                 lua.create_function(|lua, (_, field, val): (AnyUserData, String, Value)| {
                     lua.globals().set(field, val)?;
@@ -516,6 +514,7 @@ fn test_fields() -> Result<()> {
     globals.set("ud", MyUserData(7))?;
     lua.load(
         r#"
+        assert(ud.static == "constant")
         assert(ud.val == 7)
         ud.val = 10
         assert(ud.val == 10)
@@ -538,30 +537,28 @@ fn test_fields() -> Result<()> {
 #[test]
 fn test_metatable() -> Result<()> {
     #[derive(Copy, Clone)]
-    struct MyUserData(i64);
+    struct MyUserData;
 
     impl UserData for MyUserData {
-        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
-            fields.add_meta_field_with("__type_name", |_| Ok("MyUserData"));
-        }
-
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
             methods.add_function("my_type_name", |_, data: AnyUserData| {
                 let metatable = data.get_metatable()?;
-                metatable.get::<String>("__type_name")
+                metatable.get::<String>(MetaMethod::Type)
             });
         }
     }
 
     let lua = Lua::new();
     let globals = lua.globals();
-    globals.set("ud", MyUserData(7))?;
-    lua.load(
-        r#"
-        assert(ud:my_type_name() == "MyUserData")
-    "#,
-    )
-    .exec()?;
+    globals.set("ud", MyUserData)?;
+    lua.load(r#"assert(ud:my_type_name() == "MyUserData")"#)
+        .exec()?;
+
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
+    lua.load(r#"assert(tostring(ud):sub(1, 11) == "MyUserData:")"#)
+        .exec()?;
+    #[cfg(feature = "luau")]
+    lua.load(r#"assert(typeof(ud) == "MyUserData")"#).exec()?;
 
     let ud: AnyUserData = globals.get("ud")?;
     let metatable = ud.get_metatable()?;
@@ -583,10 +580,10 @@ fn test_metatable() -> Result<()> {
         .map(|kv: Result<(_, Value)>| Ok(kv?.0))
         .collect::<Result<Vec<_>>>()?;
     methods.sort();
-    assert_eq!(methods, vec!["__index", "__type_name"]);
+    assert_eq!(methods, vec!["__index", MetaMethod::Type.name()]);
 
     #[derive(Copy, Clone)]
-    struct MyUserData2(i64);
+    struct MyUserData2;
 
     impl UserData for MyUserData2 {
         fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
@@ -594,12 +591,28 @@ fn test_metatable() -> Result<()> {
         }
     }
 
-    match lua.create_userdata(MyUserData2(1)) {
+    match lua.create_userdata(MyUserData2) {
         Ok(_) => panic!("expected MetaMethodTypeError, got no error"),
         Err(Error::MetaMethodTypeError { .. }) => {}
         Err(e) => panic!("expected MetaMethodTypeError, got {:?}", e),
     }
 
+    #[derive(Copy, Clone)]
+    struct MyUserData3;
+
+    impl UserData for MyUserData3 {
+        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_meta_field_with(MetaMethod::Type, |_| Ok("CustomName"));
+        }
+    }
+
+    let ud = lua.create_userdata(MyUserData3)?;
+    let metatable = ud.get_metatable()?;
+    assert_eq!(
+        metatable.get::<String>(MetaMethod::Type)?.to_str()?,
+        "CustomName"
+    );
+
     Ok(())
 }
 
@@ -609,6 +622,7 @@ fn test_userdata_wrapped() -> Result<()> {
 
     impl UserData for MyUserData {
         fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field("static", "constant");
             fields.add_field_method_get("data", |_, this| Ok(this.0));
             fields.add_field_method_set("data", |_, this, val| {
                 this.0 = val;
@@ -620,27 +634,72 @@ fn test_userdata_wrapped() -> Result<()> {
     let lua = Lua::new();
     let globals = lua.globals();
 
+    // Rc<T>
     #[cfg(not(feature = "send"))]
     {
-        let ud1 = Rc::new(RefCell::new(MyUserData(1)));
-        globals.set("rc_refcell_ud", ud1.clone())?;
+        let ud = Rc::new(MyUserData(1));
+        globals.set("rc_ud", ud.clone())?;
         lua.load(
             r#"
+            assert(rc_ud.static == "constant")
+            local ok, err = pcall(function() rc_ud.data = 2 end)
+            assert(
+                tostring(err):sub(1, 32) == "error mutably borrowing userdata",
+                "expected error mutably borrowing userdata, got " .. tostring(err)
+            )
+            assert(rc_ud.data == 1)
+        "#,
+        )
+        .exec()?;
+        globals.set("rc_ud", Nil)?;
+        lua.gc_collect()?;
+        assert_eq!(Rc::strong_count(&ud), 1);
+    }
+
+    // Rc<RefCell<T>>
+    #[cfg(not(feature = "send"))]
+    {
+        let ud = Rc::new(RefCell::new(MyUserData(1)));
+        globals.set("rc_refcell_ud", ud.clone())?;
+        lua.load(
+            r#"
+            assert(rc_refcell_ud.static == "constant")
             rc_refcell_ud.data = rc_refcell_ud.data + 1
             assert(rc_refcell_ud.data == 2)
         "#,
         )
         .exec()?;
-        assert_eq!(ud1.borrow().0, 2);
+        assert_eq!(ud.borrow().0, 2);
         globals.set("rc_refcell_ud", Nil)?;
         lua.gc_collect()?;
-        assert_eq!(Rc::strong_count(&ud1), 1);
+        assert_eq!(Rc::strong_count(&ud), 1);
     }
 
+    // Arc<T>
+    let ud1 = Arc::new(MyUserData(2));
+    globals.set("arc_ud", ud1.clone())?;
+    lua.load(
+        r#"
+        assert(arc_ud.static == "constant")
+        local ok, err = pcall(function() arc_ud.data = 3 end)
+        assert(
+            tostring(err):sub(1, 32) == "error mutably borrowing userdata",
+            "expected error mutably borrowing userdata, got " .. tostring(err)
+        )
+        assert(arc_ud.data == 2)
+    "#,
+    )
+    .exec()?;
+    globals.set("arc_ud", Nil)?;
+    lua.gc_collect()?;
+    assert_eq!(Arc::strong_count(&ud1), 1);
+
+    // Arc<Mutex<T>>
     let ud2 = Arc::new(Mutex::new(MyUserData(2)));
     globals.set("arc_mutex_ud", ud2.clone())?;
     lua.load(
         r#"
+        assert(arc_mutex_ud.static == "constant")
         arc_mutex_ud.data = arc_mutex_ud.data + 1
         assert(arc_mutex_ud.data == 3)
     "#,
@@ -650,11 +709,16 @@ fn test_userdata_wrapped() -> Result<()> {
     assert_eq!(ud2.lock().unwrap().0, 3);
     #[cfg(feature = "parking_lot")]
     assert_eq!(ud2.lock().0, 3);
+    globals.set("arc_mutex_ud", Nil)?;
+    lua.gc_collect()?;
+    assert_eq!(Arc::strong_count(&ud2), 1);
 
+    // Arc<RwLock<T>>
     let ud3 = Arc::new(RwLock::new(MyUserData(3)));
     globals.set("arc_rwlock_ud", ud3.clone())?;
     lua.load(
         r#"
+        assert(arc_rwlock_ud.static == "constant")
         arc_rwlock_ud.data = arc_rwlock_ud.data + 1
         assert(arc_rwlock_ud.data == 4)
     "#,
@@ -664,12 +728,8 @@ fn test_userdata_wrapped() -> Result<()> {
     assert_eq!(ud3.read().unwrap().0, 4);
     #[cfg(feature = "parking_lot")]
     assert_eq!(ud3.read().0, 4);
-
-    // Test drop
-    globals.set("arc_mutex_ud", Nil)?;
     globals.set("arc_rwlock_ud", Nil)?;
     lua.gc_collect()?;
-    assert_eq!(Arc::strong_count(&ud2), 1);
     assert_eq!(Arc::strong_count(&ud3), 1);
 
     Ok(())
@@ -681,7 +741,7 @@ fn test_userdata_proxy() -> Result<()> {
 
     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("static_field", 123);
             fields.add_field_method_get("n", |_, this| Ok(this.0));
         }
 
@@ -745,6 +805,27 @@ fn test_any_userdata() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_any_userdata_wrap() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.register_userdata_type::<StdString>(|reg| {
+        reg.add_method("get", |_, this, ()| Ok(this.clone()));
+    })?;
+
+    lua.globals()
+        .set("s", AnyUserData::wrap("hello".to_string()))?;
+    lua.load(
+        r#"
+        assert(s:get() == "hello")
+    "#,
+    )
+    .exec()
+    .unwrap();
+
+    Ok(())
+}
+
 #[test]
 fn test_userdata_ext() -> Result<()> {
     let lua = Lua::new();
@@ -775,10 +856,7 @@ fn test_userdata_ext() -> Result<()> {
     assert_eq!(ud.get::<_, u32>("n")?, 123);
     ud.set("n", 321)?;
     assert_eq!(ud.get::<_, u32>("n")?, 321);
-    match ud.get::<_, u32>("non-existent") {
-        Err(Error::RuntimeError(_)) => {}
-        r => panic!("expected RuntimeError, got {r:?}"),
-    }
+    assert_eq!(ud.get::<_, Option<u32>>("non-existent")?, None);
     match ud.set::<_, u32>("non-existent", 123) {
         Err(Error::RuntimeError(_)) => {}
         r => panic!("expected RuntimeError, got {r:?}"),
@@ -831,11 +909,47 @@ fn test_owned_userdata() -> Result<()> {
 
     assert_eq!(*ud.borrow::<&str>()?, "abc");
     *ud.borrow_mut()? = "cba";
-    assert_eq!(*ud.to_ref().borrow::<&str>()?, "cba");
     assert!(matches!(
         ud.borrow::<i64>(),
         Err(Error::UserDataTypeMismatch)
     ));
+    assert_eq!(ud.take::<&str>()?, "cba");
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[test]
+fn test_userdata_derive() -> Result<()> {
+    let lua = Lua::new();
+
+    // Simple struct
+
+    #[derive(Clone, Copy, mlua::FromLua)]
+    struct MyUserData(i32);
+
+    lua.register_userdata_type::<MyUserData>(|reg| {
+        reg.add_function("val", |_, this: MyUserData| Ok(this.0));
+    })?;
+
+    lua.globals()
+        .set("ud", AnyUserData::wrap(MyUserData(123)))?;
+    lua.load("assert(ud:val() == 123)").exec()?;
+
+    // More complex struct where generics and where clause
+
+    #[derive(Clone, Copy, mlua::FromLua)]
+    struct MyUserData2<'a, T>(&'a T)
+    where
+        T: ?Sized;
+
+    lua.register_userdata_type::<MyUserData2<'static, i32>>(|reg| {
+        reg.add_function("val", |_, this: MyUserData2<'static, i32>| Ok(*this.0));
+    })?;
+
+    lua.globals()
+        .set("ud", AnyUserData::wrap(MyUserData2(&321)))?;
+    lua.load("assert(ud:val() == 321)").exec()?;
 
     Ok(())
 }

tests/value.rs

@@ -1,6 +1,9 @@
+use std::collections::HashMap;
+use std::os::raw::c_void;
 use std::ptr;
+use std::string::String as StdString;
 
-use mlua::{Lua, MultiValue, Result, Value};
+use mlua::{Error, LightUserData, Lua, MultiValue, Result, UserData, UserDataMethods, Value};
 
 #[test]
 fn test_value_eq() -> Result<()> {
@@ -28,6 +31,7 @@ fn test_value_eq() -> Result<()> {
     "#,
     )
     .exec()?;
+    globals.set("null", Value::NULL)?;
 
     let table1: Value = globals.get("table1")?;
     let table2: Value = globals.get("table2")?;
@@ -41,6 +45,7 @@ fn test_value_eq() -> Result<()> {
     let func3: Value = globals.get("func3")?;
     let thread1: Value = globals.get("thread1")?;
     let thread2: Value = globals.get("thread2")?;
+    let null: Value = globals.get("null")?;
 
     assert!(table1 != table2);
     assert!(table1.equals(&table2)?);
@@ -54,6 +59,7 @@ fn test_value_eq() -> Result<()> {
     assert!(!func1.equals(&func3)?);
     assert!(thread1 == thread2);
     assert!(thread1.equals(&thread2)?);
+    assert!(null == Value::NULL);
 
     assert!(!table1.to_pointer().is_null());
     assert!(!ptr::eq(table1.to_pointer(), table2.to_pointer()));
@@ -81,3 +87,74 @@ fn test_multi_value() {
     multi_value.clear();
     assert!(multi_value.is_empty());
 }
+
+#[test]
+fn test_value_to_string() -> Result<()> {
+    let lua = Lua::new();
+
+    assert_eq!(Value::Nil.to_string()?, "nil");
+    assert_eq!(Value::Boolean(true).to_string()?, "true");
+    assert_eq!(Value::NULL.to_string()?, "null");
+    assert_eq!(
+        Value::LightUserData(LightUserData(0x1 as *const c_void as *mut _)).to_string()?,
+        "lightuserdata: 0x1"
+    );
+    assert_eq!(Value::Integer(1).to_string()?, "1");
+    assert_eq!(Value::Number(34.59).to_string()?, "34.59");
+    #[cfg(all(feature = "luau", not(feature = "luau-vector4")))]
+    assert_eq!(
+        Value::Vector(mlua::Vector::new(10.0, 11.1, 12.2)).to_string()?,
+        "vector(10, 11.1, 12.2)"
+    );
+    #[cfg(feature = "luau-vector4")]
+    assert_eq!(
+        Value::Vector(mlua::Vector::new(10.0, 11.1, 12.2, 13.3)).to_string()?,
+        "vector(10, 11.1, 12.2, 13.3)"
+    );
+    assert_eq!(
+        Value::String(lua.create_string("hello")?).to_string()?,
+        "hello"
+    );
+
+    let table: Value = lua.load("{}").eval()?;
+    assert!(table.to_string()?.starts_with("table:"));
+    let table: Value = lua
+        .load("setmetatable({}, {__tostring = function() return 'test table' end})")
+        .eval()?;
+    assert_eq!(table.to_string()?, "test table");
+
+    let func: Value = lua.load("function() end").eval()?;
+    assert!(func.to_string()?.starts_with("function:"));
+
+    let thread: Value = lua.load("coroutine.create(function() end)").eval()?;
+    assert!(thread.to_string()?.starts_with("thread:"));
+
+    lua.register_userdata_type::<StdString>(|reg| {
+        reg.add_meta_method("__tostring", |_, this, ()| Ok(this.clone()));
+    })?;
+    let ud: Value = Value::UserData(lua.create_any_userdata(String::from("string userdata"))?);
+    assert_eq!(ud.to_string()?, "string userdata");
+
+    struct MyUserData;
+    impl UserData for MyUserData {}
+    let ud: Value = Value::UserData(lua.create_userdata(MyUserData)?);
+    assert!(ud.to_string()?.starts_with("MyUserData:"));
+
+    let err = Value::Error(Error::runtime("test error"));
+    assert_eq!(err.to_string()?, "runtime error: test error");
+
+    Ok(())
+}
+
+#[test]
+fn test_debug_format() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.register_userdata_type::<HashMap<i32, StdString>>(|_| {})?;
+    let ud = lua
+        .create_any_userdata::<HashMap<i32, StdString>>(HashMap::new())
+        .map(Value::UserData)?;
+    assert!(format!("{ud:#?}").starts_with("HashMap<i32, String>:"));
+
+    Ok(())
+}