v0.9.9

- Store single `AtomicI32` field instead of pair i32,AtomicBool
- Make creation faster by skipping intermediate `Value` layer
Add new `RegistryKey::id()` method to return underlying identifier

.github/workflows/main.yml

@@ -18,7 +18,7 @@ jobs:
           - os: windows-latest
             target: x86_64-pc-windows-msvc
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -44,7 +44,7 @@ jobs:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
@@ -60,7 +60,7 @@ jobs:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
@@ -82,7 +82,7 @@ jobs:
       matrix:
         lua: [lua54, lua53, lua52, lua51]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
@@ -113,7 +113,7 @@ jobs:
           - os: windows-latest
             target: x86_64-pc-windows-msvc
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -145,7 +145,7 @@ jobs:
           - os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -166,14 +166,14 @@ jobs:
       matrix:
         os: [ubuntu-22.04, macos-latest]
         rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau]
         include:
           - os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
           - os: macos-latest
             target: x86_64-apple-darwin
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -197,7 +197,7 @@ jobs:
         shell: msys2 {0}
     steps:
       - uses: msys2/setup-msys2@v2
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Install Rust & Lua
         run: |
           pacman -S --noconfirm mingw-w64-x86_64-rust mingw-w64-x86_64-lua mingw-w64-x86_64-luajit mingw-w64-x86_64-pkg-config
@@ -206,11 +206,34 @@ jobs:
           (cd tests/module && cargo build --release --features "${{ matrix.lua }}")
           (cd tests/module/loader && cargo test --release --features "${{ matrix.lua }}")
 
+  test_wasm32_emscripten:
+    name: Test on wasm32-unknown-emscripten
+    runs-on: ubuntu-22.04
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua54, lua53, lua52, lua51, luau]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: wasm32-unknown-emscripten
+      - name: Install Emscripten
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends emscripten
+      - name: Run ${{ matrix.lua }} tests
+        run: |
+          cargo test --tests --features "${{ matrix.lua }},vendored"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,parking_lot,unstable"
+
   rustfmt:
     name: Rustfmt
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
@@ -224,7 +247,7 @@ jobs:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: nightly

CHANGELOG.md

@@ -1,3 +1,62 @@
+## v0.9.9
+
+- Minimal Luau updated to 0.629
+- Fixed bug when attempting to reset or resume already running coroutines (#416).
+- Added `RegistryKey::id()` method to get the underlying Lua registry key id.
+
+## v0.9.8
+
+- Fixed serializing same table multiple times (#408)
+- Use `mlua-sys` v0.6 (to support Luau 0.624+)
+- Fixed cross compilation of windows dlls from unix (#394)
+
+## v0.9.7
+
+- Implemented `IntoLua` for `RegistryKey`
+- Mark `__idiv` metamethod as available for luau
+- Added `Function::deep_clone()` method (Luau)
+- Added `SerializeOptions::detect_serde_json_arbitrary_precision` option
+- Added `Lua::create_buffer()` method (Luau)
+- Support serializing buffer type as a byte slice (Luau)
+- Perf: Implemented `push_into_stack`/`from_stack` for `Option<T>`
+- Added `Lua::create_ser_any_userdata()` method
+
+## v0.9.6
+
+- Added `to_pointer` function to `Function`/`Table`/`Thread`
+- Implemented `IntoLua` for `&Value`
+- Implemented `FromLua` for `RegistryKey`
+- Faster (~5%) table array traversal during serialization
+- Some performance improvements for bool/int types
+
+## v0.9.5
+
+- Minimal Luau updated to 0.609
+- Luau max stack size increased to 1M (from 100K)
+- Implemented `IntoLua` for refs to `String`/`Table`/`Function`/`AnyUserData`/`Thread` + `RegistryKey`
+- Implemented `IntoLua` and `FromLua` for `OwnedThread`/`OwnedString`
+- Fixed `FromLua` derive proc macro to cover more cases
+
+## v0.9.4
+
+- Fixed loading all-in-one modules under mixed states (eg. main state and coroutines)
+
+## v0.9.3
+
+- WebAssembly support (`wasm32-unknown-emscripten` target)
+- Performance improvements (faster Lua function calls for lua51/jit/luau)
+
+## v0.9.2
+
+- Added binary modules support to Luau
+- Added Luau package module (uses `StdLib::PACKAGE`) with loaders (follows lua5.1 interface)
+- Added support of Luau 0.601+ buffer type (represented as userdata in Rust)
+- LuaJIT `cdata` type is also represented as userdata in Rust (instead of panic)
+- Vendored LuaJIT switched to rolling vanilla (from openresty)
+- Added `Table::for_each` method for fast table pairs traversal (faster than `pairs`)
+- Performance improvements around table traversal (and faster serialization)
+- Bug fixes and improvements
+
 ## v0.9.1
 
 - impl Default for Lua

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "mlua"
-version = "0.9.1" # remember to update mlua_derive
-authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
+version = "0.9.9" # remember to update mlua_derive
+authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
 rust-version = "1.71"
 edition = "2021"
 repository = "https://github.com/khvzak/mlua"
@@ -32,50 +32,66 @@ lua52 = ["ffi/lua52"]
 lua51 = ["ffi/lua51"]
 luajit = ["ffi/luajit"]
 luajit52 = ["luajit", "ffi/luajit52"]
-luau = ["ffi/luau"]
+luau = ["ffi/luau", "dep:libloading"]
 luau-jit = ["luau", "ffi/luau-codegen"]
 luau-vector4 = ["luau", "ffi/luau-vector4"]
 vendored = ["ffi/vendored"]
-module = ["mlua_derive", "ffi/module"]
-async = ["futures-util"]
+module = ["dep:mlua_derive", "ffi/module"]
+async = ["dep:futures-util"]
 send = []
-serialize = ["serde", "erased-serde", "serde-value"]
+serialize = ["dep:serde", "dep:erased-serde", "dep:serde-value"]
 macros = ["mlua_derive/macros"]
 unstable = []
 
 [dependencies]
-mlua_derive = { version = "=0.9.0", optional = true, path = "mlua_derive" }
-bstr = { version = "1.0", features = ["std"], default_features = false }
+mlua_derive = { version = "=0.9.3", 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"
+rustc-hash = "2.0"
 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 }
+erased-serde = { version = "0.4", optional = true }
 serde-value = { version = "0.7", optional = true }
 parking_lot = { version = "0.12", optional = true }
 
-ffi = { package = "mlua-sys", version = "0.3.2", path = "mlua-sys" }
+ffi = { package = "mlua-sys", version = "0.6.1", path = "mlua-sys" }
+
+[target.'cfg(unix)'.dependencies]
+libloading = { version = "0.8", optional = true }
 
 [dev-dependencies]
-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"] }
+hyper = { version = "1.2", features = ["full"] }
+hyper-util = { version = "0.1.3", features = ["full"] }
+http-body-util = "0.1.1"
+reqwest = { version = "0.12", features = ["json"] }
+tokio = { version = "1.0", features = ["macros", "rt", "time"] }
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+serde_json = { version = "1.0", features = ["arbitrary_precision"] }
 maplit = "1.0"
 tempfile = "3"
 static_assertions = "1.0"
 
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+criterion = { version = "0.5", features = ["async_tokio"] }
+rustyline = "14.0"
+tokio = { version = "1.0", features = ["full"] }
+
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(tarpaulin_include)'] }
+
 [[bench]]
 name = "benchmark"
 harness = false
 required-features = ["async"]
 
+[[bench]]
+name = "serde"
+harness = false
+required-features = ["serialize"]
+
 [[example]]
 name = "async_http_client"
 required-features = ["async", "macros"]

README.md

@@ -7,8 +7,8 @@
 [crates.io]: https://crates.io/crates/mlua
 [API Documentation]: https://docs.rs/mlua/badge.svg
 [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
+[Coverage Status]: https://codecov.io/gh/mlua-rs/mlua/branch/master/graph/badge.svg?token=99339FS1CG
+[codecov.io]: https://codecov.io/gh/mlua-rs/mlua
 [MSRV]: https://img.shields.io/badge/rust-1.71+-brightgreen.svg?&logo=rust
 
 [Guided Tour] | [Benchmarks] | [FAQ]
@@ -28,6 +28,8 @@ Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT
 
 `mlua` tested on Windows/macOS/Linux including module mode in [GitHub Actions] on `x86_64` platform and cross-compilation to `aarch64` (other targets are also supported).
 
+WebAssembly (WASM) is supported through `wasm32-unknown-emscripten` target for all Lua versions excluding JIT.
+
 [GitHub Actions]: https://github.com/khvzak/mlua/actions
 [Roblox Luau]: https://luau-lang.org
 
@@ -82,6 +84,20 @@ This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6
 - [HTTP Server](examples/async_http_server.rs)
 - [TCP Server](examples/async_tcp_server.rs)
 
+
+**shell command examples**:
+```shell
+# async http client (hyper)
+cargo run --example async_http_client --features=lua54,async,macros
+
+# async http client (reqwest)
+cargo run --example async_http_reqwest --features=lua54,async,macros,serialize
+
+# async http server
+cargo run --example async_http_server --features=lua54,async,macros
+curl -v http://localhost:3000
+```
+
 ### Serialization (serde) support
 
 With `serialize` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition `mlua` provides [`serde::Serialize`] trait implementation for it (including `UserData` support).
@@ -117,7 +133,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.9.1", features = ["lua54", "vendored"] }
+mlua = { version = "0.9.9", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -152,7 +168,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.9.1", features = ["lua54", "module"] }
+mlua = { version = "0.9.9", features = ["lua54", "module"] }
 ```
 
 `lib.rs` :

benches/benchmark.rs

@@ -1,5 +1,7 @@
-use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use tokio::runtime::Runtime;
 use tokio::task;
 
@@ -10,10 +12,10 @@ fn collect_gc_twice(lua: &Lua) {
     lua.gc_collect().unwrap();
 }
 
-fn create_table(c: &mut Criterion) {
+fn table_create_empty(c: &mut Criterion) {
     let lua = Lua::new();
 
-    c.bench_function("create [table empty]", |b| {
+    c.bench_function("table [create empty]", |b| {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
@@ -24,35 +26,33 @@ fn create_table(c: &mut Criterion) {
     });
 }
 
-fn create_array(c: &mut Criterion) {
+fn table_create_array(c: &mut Criterion) {
     let lua = Lua::new();
 
-    c.bench_function("create [array] 10", |b| {
+    c.bench_function("table [create array]", |b| {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                let table = lua.create_table().unwrap();
-                for i in 1..=10 {
-                    table.set(i, i).unwrap();
-                }
+                lua.create_sequence_from(1..=10).unwrap();
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn create_string_table(c: &mut Criterion) {
+fn table_create_hash(c: &mut Criterion) {
     let lua = Lua::new();
 
-    c.bench_function("create [table string] 10", |b| {
+    c.bench_function("table [create hash]", |b| {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                let table = lua.create_table().unwrap();
-                for &s in &["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] {
-                    let s = lua.create_string(s).unwrap();
-                    table.set(s.clone(), s).unwrap();
-                }
+                lua.create_table_from(
+                    ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
+                        .into_iter()
+                        .map(|s| (s, s)),
+                )
+                .unwrap();
             },
             BatchSize::SmallInput,
         );
@@ -62,17 +62,15 @@ fn create_string_table(c: &mut Criterion) {
 fn table_get_set(c: &mut Criterion) {
     let lua = Lua::new();
 
-    let table = lua.create_table().unwrap();
-
-    c.bench_function("table raw_get and raw_set [10]", |b| {
+    c.bench_function("table [get and set]", |b| {
         b.iter_batched(
             || {
                 collect_gc_twice(&lua);
-                table.clear().unwrap();
+                lua.create_table().unwrap()
             },
-            |_| {
-                for (i, &s) in ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
-                    .iter()
+            |table| {
+                for (i, s) in ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+                    .into_iter()
                     .enumerate()
                 {
                     table.raw_set(s, i).unwrap();
@@ -84,236 +82,318 @@ fn table_get_set(c: &mut Criterion) {
     });
 }
 
-fn create_function(c: &mut Criterion) {
+fn table_traversal_pairs(c: &mut Criterion) {
     let lua = Lua::new();
 
-    c.bench_function("create [function] 10", |b| {
+    c.bench_function("table [traversal pairs]", |b| {
+        b.iter_batched(
+            || lua.globals(),
+            |globals| {
+                for kv in globals.pairs::<String, LuaValue>() {
+                    let (_k, _v) = kv.unwrap();
+                }
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn table_traversal_for_each(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    c.bench_function("table [traversal for_each]", |b| {
+        b.iter_batched(
+            || lua.globals(),
+            |globals| globals.for_each::<String, LuaValue>(|_k, _v| Ok(())),
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn table_traversal_sequence(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let table = lua.create_sequence_from(1..1000).unwrap();
+
+    c.bench_function("table [traversal sequence]", |b| {
+        b.iter_batched(
+            || table.clone(),
+            |table| {
+                for v in table.sequence_values::<i32>() {
+                    let _i = v.unwrap();
+                }
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_create(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    c.bench_function("function [create Rust]", |b| {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                for i in 0..10 {
-                    lua.create_function(move |_, ()| Ok(i)).unwrap();
-                }
+                lua.create_function(|_, ()| Ok(123)).unwrap();
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn call_lua_function(c: &mut Criterion) {
+fn function_call_sum(c: &mut Criterion) {
     let lua = Lua::new();
 
-    c.bench_function("call Lua function [sum] 3 10", |b| {
-        b.iter_batched_ref(
-            || {
-                collect_gc_twice(&lua);
-                lua.load("function(a, b, c) return a + b + c end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
-            },
-            |function| {
-                for i in 0..10 {
-                    let _result: i64 = function.call((i, i + 1, i + 2)).unwrap();
-                }
-            },
-            BatchSize::SmallInput,
-        );
-    });
-}
-
-fn call_sum_callback(c: &mut Criterion) {
-    let lua = Lua::new();
-    let callback = lua
-        .create_function(|_, (a, b, c): (i64, i64, i64)| Ok(a + b + c))
+    let sum = lua
+        .create_function(|_, (a, b, c): (i64, i64, i64)| Ok(a + b - c))
         .unwrap();
-    lua.globals().set("callback", callback).unwrap();
 
-    c.bench_function("call Rust callback [sum] 3 10", |b| {
-        b.iter_batched_ref(
-            || {
-                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do callback(i, i+1, i+2) end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
-            },
-            |function| {
-                function.call::<_, ()>(()).unwrap();
+    c.bench_function("function [call Rust sum]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                assert_eq!(sum.call::<_, i64>((10, 20, 30)).unwrap(), 0);
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn call_async_sum_callback(c: &mut Criterion) {
-    let options = LuaOptions::new().thread_pool_size(1024);
-    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
-    let callback = lua
-        .create_async_function(|_, (a, b, c): (i64, i64, i64)| async move {
-            task::yield_now().await;
-            Ok(a + b + c)
-        })
-        .unwrap();
-    lua.globals().set("callback", callback).unwrap();
-
-    c.bench_function("call async Rust callback [sum] 3 10", |b| {
-        let rt = Runtime::new().unwrap();
-        b.to_async(rt).iter_batched(
-            || {
-                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do callback(i, i+1, i+2) end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
-            },
-            |function| async move {
-                function.call_async::<_, ()>(()).await.unwrap();
-            },
-            BatchSize::SmallInput,
-        );
-    });
-}
-
-fn call_concat_callback(c: &mut Criterion) {
+fn function_call_lua_sum(c: &mut Criterion) {
     let lua = Lua::new();
-    let callback = lua
+
+    let sum = lua
+        .load("function(a, b, c) return a + b - c end")
+        .eval::<LuaFunction>()
+        .unwrap();
+
+    c.bench_function("function [call Lua sum]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                assert_eq!(sum.call::<_, i64>((10, 20, 30)).unwrap(), 0);
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_call_concat(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let concat = lua
         .create_function(|_, (a, b): (LuaString, LuaString)| {
             Ok(format!("{}{}", a.to_str()?, b.to_str()?))
         })
         .unwrap();
-    lua.globals().set("callback", callback).unwrap();
+    let i = AtomicUsize::new(0);
 
-    c.bench_function("call Rust callback [concat string] 10", |b| {
-        b.iter_batched_ref(
+    c.bench_function("function [call Rust concat string]", |b| {
+        b.iter_batched(
             || {
                 collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do callback('a', tostring(i)) end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
+                i.fetch_add(1, Ordering::Relaxed)
             },
-            |function| {
-                function.call::<_, ()>(()).unwrap();
+            |i| {
+                assert_eq!(
+                    concat.call::<_, LuaString>(("num:", i)).unwrap(),
+                    format!("num:{i}")
+                );
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn create_registry_values(c: &mut Criterion) {
+fn function_call_lua_concat(c: &mut Criterion) {
     let lua = Lua::new();
 
-    c.bench_function("create [registry value] 10", |b| {
+    let concat = lua
+        .load("function(a, b) return a..b end")
+        .eval::<LuaFunction>()
+        .unwrap();
+    let i = AtomicUsize::new(0);
+
+    c.bench_function("function [call Lua concat string]", |b| {
+        b.iter_batched(
+            || {
+                collect_gc_twice(&lua);
+                i.fetch_add(1, Ordering::Relaxed)
+            },
+            |i| {
+                assert_eq!(
+                    concat.call::<_, LuaString>(("num:", i)).unwrap(),
+                    format!("num:{i}")
+                );
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_async_call_sum(c: &mut Criterion) {
+    let options = LuaOptions::new().thread_pool_size(1024);
+    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
+
+    let sum = lua
+        .create_async_function(|_, (a, b, c): (i64, i64, i64)| async move {
+            task::yield_now().await;
+            Ok(a + b - c)
+        })
+        .unwrap();
+
+    c.bench_function("function [async call Rust sum]", |b| {
+        let rt = Runtime::new().unwrap();
+        b.to_async(rt).iter_batched(
+            || collect_gc_twice(&lua),
+            |_| async {
+                assert_eq!(sum.call_async::<_, i64>((10, 20, 30)).await.unwrap(), 0);
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn registry_value_create(c: &mut Criterion) {
+    let lua = Lua::new();
+    lua.gc_stop();
+
+    c.bench_function("registry value [create]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| lua.create_registry_value("hello").unwrap(),
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn registry_value_get(c: &mut Criterion) {
+    let lua = Lua::new();
+    lua.gc_stop();
+
+    let value = lua.create_registry_value("hello").unwrap();
+
+    c.bench_function("registry value [get]", |b| {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                for _ in 0..10 {
-                    lua.create_registry_value(lua.pack(true).unwrap()).unwrap();
-                }
-                lua.expire_registry_values();
+                assert_eq!(lua.registry_value::<LuaString>(&value).unwrap(), "hello");
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn create_userdata(c: &mut Criterion) {
-    struct UserData(i64);
+fn userdata_create(c: &mut Criterion) {
+    struct UserData(#[allow(unused)] i64);
     impl LuaUserData for UserData {}
 
     let lua = Lua::new();
 
-    c.bench_function("create [table userdata] 10", |b| {
+    c.bench_function("userdata [create]", |b| {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                let table: LuaTable = lua.create_table().unwrap();
-                for i in 1..11 {
-                    table.set(i, UserData(i)).unwrap();
-                }
+                lua.create_userdata(UserData(123)).unwrap();
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn call_userdata_index(c: &mut Criterion) {
-    struct UserData(i64);
+fn userdata_call_index(c: &mut Criterion) {
+    struct UserData(#[allow(unused)] i64);
     impl LuaUserData for UserData {
         fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_meta_method(LuaMetaMethod::Index, move |_, _, index: String| Ok(index));
+            methods.add_meta_method(LuaMetaMethod::Index, move |_, _, key: LuaString| Ok(key));
         }
     }
 
     let lua = Lua::new();
-    lua.globals().set("userdata", UserData(10)).unwrap();
+    let ud = lua.create_userdata(UserData(123)).unwrap();
+    let index = lua
+        .load("function(ud) return ud.test end")
+        .eval::<LuaFunction>()
+        .unwrap();
 
-    c.bench_function("call [userdata index] 10", |b| {
-        b.iter_batched_ref(
-            || {
-                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do local v = userdata.test end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
-            },
-            |function| {
-                function.call::<_, ()>(()).unwrap();
+    c.bench_function("userdata [call index]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                assert_eq!(index.call::<_, LuaString>(&ud).unwrap(), "test");
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn call_userdata_method(c: &mut Criterion) {
+fn userdata_call_method(c: &mut Criterion) {
     struct UserData(i64);
     impl LuaUserData for UserData {
         fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_method("method", |_, this, ()| Ok(this.0));
+            methods.add_method("add", |_, this, i: i64| Ok(this.0 + i));
         }
     }
 
     let lua = Lua::new();
-    lua.globals().set("userdata", UserData(10)).unwrap();
+    let ud = lua.create_userdata(UserData(123)).unwrap();
+    let method = lua
+        .load("function(ud, i) return ud:add(i) end")
+        .eval::<LuaFunction>()
+        .unwrap();
+    let i = AtomicUsize::new(0);
 
-    c.bench_function("call [userdata method] 10", |b| {
-        b.iter_batched_ref(
+    c.bench_function("userdata [call method]", |b| {
+        b.iter_batched(
             || {
                 collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do userdata:method() end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
+                i.fetch_add(1, Ordering::Relaxed)
             },
-            |function| {
-                function.call::<_, ()>(()).unwrap();
+            |i| {
+                assert_eq!(method.call::<_, usize>((&ud, i)).unwrap(), 123 + i);
             },
             BatchSize::SmallInput,
         );
     });
 }
 
-fn call_async_userdata_method(c: &mut Criterion) {
-    struct UserData(String);
-
+fn userdata_async_call_method(c: &mut Criterion) {
+    struct UserData(i64);
     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.clone()) });
+            methods.add_async_method("add", |_, this, i: i64| async move {
+                task::yield_now().await;
+                Ok(this.0 + i)
+            });
         }
     }
 
     let options = LuaOptions::new().thread_pool_size(1024);
     let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
-    lua.globals()
-        .set("userdata", UserData("hello".to_string()))
+    let ud = lua.create_userdata(UserData(123)).unwrap();
+    let method = lua
+        .load("function(ud, i) return ud:add(i) end")
+        .eval::<LuaFunction>()
         .unwrap();
+    let i = AtomicUsize::new(0);
 
-    c.bench_function("call async [userdata method] 10", |b| {
+    c.bench_function("userdata [async call method] 10", |b| {
         let rt = Runtime::new().unwrap();
         b.to_async(rt).iter_batched(
             || {
                 collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do userdata:method() end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
+                (
+                    method.clone(),
+                    ud.clone(),
+                    i.fetch_add(1, Ordering::Relaxed),
+                )
             },
-            |function| async move {
-                function.call_async::<_, ()>(()).await.unwrap();
+            |(method, ud, i)| async move {
+                assert_eq!(
+                    method.call_async::<_, usize>((ud, i)).await.unwrap(),
+                    123 + i
+                );
             },
             BatchSize::SmallInput,
         );
@@ -323,24 +403,32 @@ fn call_async_userdata_method(c: &mut Criterion) {
 criterion_group! {
     name = benches;
     config = Criterion::default()
-        .sample_size(300)
+        .sample_size(500)
         .measurement_time(Duration::from_secs(10))
         .noise_threshold(0.02);
     targets =
-        create_table,
-        create_array,
-        create_string_table,
+        table_create_empty,
+        table_create_array,
+        table_create_hash,
         table_get_set,
-        create_function,
-        call_lua_function,
-        call_sum_callback,
-        call_async_sum_callback,
-        call_concat_callback,
-        create_registry_values,
-        create_userdata,
-        call_userdata_index,
-        call_userdata_method,
-        call_async_userdata_method,
+        table_traversal_pairs,
+        table_traversal_for_each,
+        table_traversal_sequence,
+
+        function_create,
+        function_call_sum,
+        function_call_lua_sum,
+        function_call_concat,
+        function_call_lua_concat,
+        function_async_call_sum,
+
+        registry_value_create,
+        registry_value_get,
+
+        userdata_create,
+        userdata_call_index,
+        userdata_call_method,
+        userdata_async_call_method,
 }
 
 criterion_main!(benches);

benches/serde.rs

@@ -0,0 +1,90 @@
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+
+use mlua::prelude::*;
+
+fn collect_gc_twice(lua: &Lua) {
+    lua.gc_collect().unwrap();
+    lua.gc_collect().unwrap();
+}
+
+fn encode_json(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let encode = lua
+        .create_function(|_, t: LuaValue| Ok(serde_json::to_string(&t).unwrap()))
+        .unwrap();
+    let table = lua
+        .load(
+            r#"{
+        name = "Clark Kent",
+        address = {
+            city = "Smallville",
+            state = "Kansas",
+            country = "USA",
+        },
+        age = 22,
+        parents = {"Jonathan Kent", "Martha Kent"},
+        superman = true,
+        interests = {"flying", "saving the world", "kryptonite"},
+    }"#,
+        )
+        .eval::<LuaTable>()
+        .unwrap();
+
+    c.bench_function("serialize json", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                encode.call::<_, LuaString>(&table).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn decode_json(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let decode = lua
+        .create_function(|lua, s: String| {
+            lua.to_value(&serde_json::from_str::<serde_json::Value>(&s).unwrap())
+        })
+        .unwrap();
+    let json = r#"{
+        "name": "Clark Kent",
+        "address": {
+            "city": "Smallville",
+            "state": "Kansas",
+            "country": "USA"
+        },
+        "age": 22,
+        "parents": ["Jonathan Kent", "Martha Kent"],
+        "superman": true,
+        "interests": ["flying", "saving the world", "kryptonite"]
+    }"#;
+
+    c.bench_function("deserialize json", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                decode.call::<_, LuaTable>(json).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .sample_size(500)
+        .measurement_time(Duration::from_secs(10))
+        .noise_threshold(0.02);
+    targets =
+        encode_json,
+        decode_json,
+}
+
+criterion_main!(benches);

examples/async_http_client.rs

@@ -1,30 +1,34 @@
 use std::collections::HashMap;
 
-use hyper::body::{Body as HyperBody, HttpBody as _};
-use hyper::Client as HyperClient;
+use http_body_util::BodyExt as _;
+use hyper::body::Incoming;
+use hyper_util::client::legacy::Client as HyperClient;
+use hyper_util::rt::TokioExecutor;
 
 use mlua::{chunk, ExternalResult, Lua, Result, UserData, UserDataMethods};
 
-struct BodyReader(HyperBody);
+struct BodyReader(Incoming);
 
 impl UserData for BodyReader {
     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+        // Every call returns a next chunk
         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();
+            if let Some(bytes) = reader.0.frame().await {
+                if let Some(bytes) = bytes.into_lua_err()?.data_ref() {
+                    return Some(lua.create_string(&bytes)).transpose();
+                }
             }
             Ok(None)
         });
     }
 }
 
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
     let lua = Lua::new();
 
     let fetch_url = lua.create_async_function(|lua, uri: String| async move {
-        let client = HyperClient::new();
+        let client = HyperClient::builder(TokioExecutor::new()).build_http::<String>();
         let uri = uri.parse().into_lua_err()?;
         let resp = client.get(uri).await.into_lua_err()?;
 
@@ -55,11 +59,11 @@ async fn main() -> Result<()> {
                 end
             end
             repeat
-                local body = res.body:read()
-                if body then
-                    print(body)
+                local chunk = res.body:read()
+                if chunk then
+                    print(chunk)
                 end
-            until not body
+            until not chunk
         })
         .into_function()?;
 

examples/async_http_reqwest.rs

@@ -1,11 +1,9 @@
-use mlua::{chunk, ExternalResult, Lua, LuaSerdeExt, Result};
+use mlua::{chunk, ExternalResult, Lua, LuaSerdeExt, Result, Value};
 
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
     let lua = Lua::new();
 
-    let null = lua.null();
-
     let fetch_json = lua.create_async_function(|lua, uri: String| async move {
         let resp = reqwest::get(&uri)
             .await
@@ -15,19 +13,15 @@ async fn main() -> Result<()> {
         lua.to_value(&json)
     })?;
 
+    let dbg = lua.create_function(|_, value: Value| {
+        println!("{value:#?}");
+        Ok(())
+    })?;
+
     let f = lua
         .load(chunk! {
-            function print_r(t, indent)
-                local indent = indent or ""
-                for k, v in pairs(t) do
-                    io.write(indent, tostring(k))
-                    if type(v) == "table" then io.write(":\n") print_r(v, indent.."  ")
-                    else io.write(": ", v == $null and "null" or tostring(v), "\n") end
-                end
-            end
-
             local res = $fetch_json(...)
-            print_r(res)
+            $dbg(res)
         })
         .into_function()?;
 

examples/async_http_server.rs

@@ -1,43 +1,63 @@
+use std::convert::Infallible;
 use std::future::Future;
 use std::net::SocketAddr;
-use std::pin::Pin;
 use std::rc::Rc;
-use std::task::{Context, Poll};
 
-use hyper::server::conn::AddrStream;
-use hyper::service::Service;
-use hyper::{Body, Request, Response, Server};
+use futures::future::LocalBoxFuture;
+use http_body_util::{combinators::BoxBody, BodyExt as _, Empty, Full};
+use hyper::body::{Bytes, Incoming};
+use hyper::{Request, Response};
+use hyper_util::rt::TokioIo;
+use hyper_util::server::conn::auto::Builder as ServerConnBuilder;
+use tokio::net::TcpListener;
+use tokio::task::LocalSet;
 
 use mlua::{
-    chunk, Error as LuaError, Function, Lua, String as LuaString, Table, UserData, UserDataMethods,
+    chunk, Error as LuaError, Function, Lua, RegistryKey, String as LuaString, Table, UserData,
+    UserDataMethods,
 };
 
-struct LuaRequest(SocketAddr, Request<Body>);
+/// Wrapper around incoming request that implements UserData
+struct LuaRequest(SocketAddr, Request<Incoming>);
 
 impl UserData for LuaRequest {
     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("remote_addr", |_lua, req, ()| Ok((req.0).to_string()));
-        methods.add_method("method", |_lua, req, ()| Ok((req.1).method().to_string()));
+        methods.add_method("remote_addr", |_, req, ()| Ok((req.0).to_string()));
+        methods.add_method("method", |_, req, ()| Ok((req.1).method().to_string()));
+        methods.add_method("path", |_, req, ()| Ok(req.1.uri().path().to_string()));
     }
 }
 
-pub struct Svc(Rc<Lua>, SocketAddr);
+/// Service that handles incoming requests
+#[derive(Clone)]
+pub struct Svc {
+    lua: Rc<Lua>,
+    handler: Rc<RegistryKey>,
+    peer_addr: SocketAddr,
+}
 
-impl Service<Request<Body>> for Svc {
-    type Response = Response<Body>;
-    type Error = LuaError;
-    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
-
-    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+impl Svc {
+    pub fn new(lua: Rc<Lua>, handler: Rc<RegistryKey>, peer_addr: SocketAddr) -> Self {
+        Self {
+            lua,
+            handler,
+            peer_addr,
+        }
     }
+}
 
-    fn call(&mut self, req: Request<Body>) -> Self::Future {
+impl hyper::service::Service<Request<Incoming>> for Svc {
+    type Response = Response<BoxBody<Bytes, Infallible>>;
+    type Error = LuaError;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+    fn call(&self, req: Request<Incoming>) -> Self::Future {
         // If handler returns an error then generate 5xx response
-        let lua = self.0.clone();
-        let lua_req = LuaRequest(self.1, req);
+        let lua = self.lua.clone();
+        let handler_key = self.handler.clone();
+        let lua_req = LuaRequest(self.peer_addr, req);
         Box::pin(async move {
-            let handler: Function = lua.named_registry_value("http_handler")?;
+            let handler: Function = lua.registry_value(&handler_key)?;
             match handler.call_async::<_, Table>(lua_req).await {
                 Ok(lua_resp) => {
                     let status = lua_resp.get::<_, Option<u16>>("status")?.unwrap_or(200);
@@ -51,10 +71,11 @@ impl Service<Request<Body>> for Svc {
                         }
                     }
 
+                    // Set body
                     let body = lua_resp
                         .get::<_, Option<LuaString>>("body")?
-                        .map(|b| Body::from(b.as_bytes().to_vec()))
-                        .unwrap_or_else(Body::empty);
+                        .map(|b| Full::new(Bytes::copy_from_slice(b.as_bytes())).boxed())
+                        .unwrap_or_else(|| Empty::<Bytes>::new().boxed());
 
                     Ok(resp.body(body).unwrap())
                 }
@@ -62,7 +83,7 @@ impl Service<Request<Body>> for Svc {
                     eprintln!("{}", err);
                     Ok(Response::builder()
                         .status(500)
-                        .body(Body::from("Internal Server Error"))
+                        .body(Full::new(Bytes::from("Internal Server Error")).boxed())
                         .unwrap())
                 }
             }
@@ -75,13 +96,14 @@ async fn main() {
     let lua = Rc::new(Lua::new());
 
     // Create Lua handler function
-    let handler: Function = lua
+    let handler: RegistryKey = lua
         .load(chunk! {
             function(req)
                 return {
                     status = 200,
                     headers = {
                         ["X-Req-Method"] = req:method(),
+                        ["X-Req-Path"] = req:path(),
                         ["X-Remote-Addr"] = req:remote_addr(),
                     },
                     body = "Hello from Lua!\n"
@@ -89,37 +111,35 @@ async fn main() {
             end
         })
         .eval()
-        .expect("cannot create Lua handler");
+        .expect("Failed to create Lua handler");
+    let handler = Rc::new(handler);
 
-    // Store it in the Registry
-    lua.set_named_registry_value("http_handler", handler)
-        .expect("cannot store Lua handler");
+    let listen_addr = "127.0.0.1:3000";
+    let listener = TcpListener::bind(listen_addr).await.unwrap();
+    println!("Listening on http://{listen_addr}");
 
-    let addr = ([127, 0, 0, 1], 3000).into();
-    let server = Server::bind(&addr).executor(LocalExec).serve(MakeSvc(lua));
+    let local = LocalSet::new();
+    loop {
+        let (stream, peer_addr) = match listener.accept().await {
+            Ok(x) => x,
+            Err(err) => {
+                eprintln!("Failed to accept connection: {err}");
+                continue;
+            }
+        };
 
-    println!("Listening on http://{}", addr);
-
-    // Create `LocalSet` to spawn !Send futures
-    let local = tokio::task::LocalSet::new();
-    local.run_until(server).await.expect("cannot run server")
-}
-
-struct MakeSvc(Rc<Lua>);
-
-impl Service<&AddrStream> for MakeSvc {
-    type Response = Svc;
-    type Error = hyper::Error;
-    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
-
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, stream: &AddrStream) -> Self::Future {
-        let lua = self.0.clone();
-        let remote_addr = stream.remote_addr();
-        Box::pin(async move { Ok(Svc(lua, remote_addr)) })
+        let svc = Svc::new(lua.clone(), handler.clone(), peer_addr);
+        local
+            .run_until(async move {
+                let result = ServerConnBuilder::new(LocalExec)
+                    .http1()
+                    .serve_connection(TokioIo::new(stream), svc)
+                    .await;
+                if let Err(err) = result {
+                    eprintln!("Error serving connection: {err:?}");
+                }
+            })
+            .await;
     }
 }
 
@@ -128,7 +148,7 @@ struct LocalExec;
 
 impl<F> hyper::rt::Executor<F> for LocalExec
 where
-    F: std::future::Future + 'static, // not requiring `Send`
+    F: Future + 'static, // not requiring `Send`
 {
     fn execute(&self, fut: F) {
         tokio::task::spawn_local(fut);

examples/guided_tour.rs

@@ -24,7 +24,7 @@ fn main() -> Result<()> {
 
     // You can load and evaluate Lua code. The returned type of `Lua::load` is a builder
     // that allows you to change settings before running Lua code. Here, we are using it to set
-    // the name of the laoded chunk to "example code", which will be used when Lua error
+    // the name of the loaded chunk to "example code", which will be used when Lua error
     // messages are printed.
 
     lua.load(
@@ -89,7 +89,7 @@ fn main() -> Result<()> {
     let print: Function = globals.get("print")?;
     print.call::<_, ()>("hello from rust")?;
 
-    // This API generally handles variadics using tuples. This is one way to call a function with
+    // This API generally handles variadic using tuples. This is one way to call a function with
     // multiple parameters:
 
     print.call::<_, ()>(("hello", "again", "from", "rust"))?;
@@ -100,7 +100,7 @@ fn main() -> Result<()> {
         ["hello", "yet", "again", "from", "rust"].iter().cloned(),
     ))?;
 
-    // You can bind rust functions to Lua as well. Callbacks receive the Lua state inself as their
+    // You can bind rust functions to Lua as well. Callbacks receive the Lua state itself as their
     // first parameter, and the arguments given to the function as the second parameter. The type
     // of the arguments can be anything that is convertible from the parameters given by Lua, in
     // this case, the function expects two string sequences.

mlua-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua-sys"
-version = "0.3.2"
+version = "0.6.1"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 rust-version = "1.71"
 edition = "2021"
@@ -38,6 +38,9 @@ module = []
 cc = "1.0"
 cfg-if = "1.0"
 pkg-config = "0.3.17"
-lua-src = { version = ">= 546.0.0, < 546.1.0", optional = true }
-luajit-src = { version = ">= 210.4.6, < 210.5.0", optional = true }
-luau0-src = { version = "0.7.0", optional = true }
+lua-src = { version = ">= 546.0.2, < 546.1.0", optional = true }
+luajit-src = { version = ">= 210.5.0, < 210.6.0", optional = true }
+luau0-src = { version = "0.10.0", optional = true }
+
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(raw_dylib)'] }

mlua-sys/build/find_normal.rs

@@ -4,6 +4,12 @@ use std::env;
 use std::ops::Bound;
 
 pub fn probe_lua() {
+    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+
+    if target_arch == "wasm32" && cfg!(not(feature = "vendored")) {
+        panic!("Please enable `vendored` feature to build for wasm32");
+    }
+
     let lib_dir = env::var("LUA_LIB").unwrap_or_default();
     let lua_lib = env::var("LUA_LIB_NAME").unwrap_or_default();
 

mlua-sys/build/find_vendored.rs

@@ -21,6 +21,7 @@ pub fn probe_lua() {
     #[cfg(feature = "luau")]
     let artifacts = luau0_src::Build::new()
         .enable_codegen(cfg!(feature = "luau-codegen"))
+        .set_max_cstack_size(1000000)
         .set_vector_size(if cfg!(feature = "luau-vector4") { 4 } else { 3 })
         .build();
 

mlua-sys/build/main_inner.rs

@@ -1,3 +1,5 @@
+use std::env;
+
 cfg_if::cfg_if! {
     if #[cfg(any(feature = "luau", feature = "vendored"))] {
         #[path = "find_vendored.rs"]
@@ -9,16 +11,16 @@ cfg_if::cfg_if! {
 }
 
 fn main() {
-    #[cfg(all(feature = "luau", feature = "module"))]
-    compile_error!("Luau does not support `module` mode");
+    #[cfg(all(feature = "luau", feature = "module", windows))]
+    compile_error!("Luau does not support `module` mode on Windows");
 
     #[cfg(all(feature = "module", feature = "vendored"))]
     compile_error!("`vendored` and `module` features are mutually exclusive");
 
     println!("cargo:rerun-if-changed=build");
 
-    #[cfg(windows)]
-    if cfg!(feature = "module") {
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+    if target_os == "windows" && cfg!(feature = "module") {
         if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
             // Don't use raw-dylib linking
             find::probe_lua();

mlua-sys/src/lib.rs

@@ -39,20 +39,25 @@ pub const LUA_MAX_UPVALUES: c_int = 200;
 #[doc(hidden)]
 pub const LUA_TRACEBACK_STACK: c_int = 11;
 
+// Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/pal/common/alloc.rs
 // 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(any(
     target_arch = "x86",
     target_arch = "arm",
+    target_arch = "m68k",
+    target_arch = "csky",
     target_arch = "mips",
+    target_arch = "mips32r6",
     target_arch = "powerpc",
     target_arch = "powerpc64",
     target_arch = "sparc",
-    target_arch = "asmjs",
     target_arch = "wasm32",
     target_arch = "hexagon",
-    all(target_arch = "riscv32", not(target_os = "espidf")),
+    all(
+        target_arch = "riscv32",
+        not(any(target_os = "espidf", target_os = "zkvm"))
+    ),
     all(target_arch = "xtensa", not(target_os = "espidf")),
 ))]
 #[doc(hidden)]
@@ -60,7 +65,10 @@ pub const SYS_MIN_ALIGN: usize = 8;
 #[cfg(any(
     target_arch = "x86_64",
     target_arch = "aarch64",
+    target_arch = "arm64ec",
+    target_arch = "loongarch64",
     target_arch = "mips64",
+    target_arch = "mips64r6",
     target_arch = "s390x",
     target_arch = "sparc64",
     target_arch = "riscv64",
@@ -68,9 +76,9 @@ pub const SYS_MIN_ALIGN: usize = 8;
 ))]
 #[doc(hidden)]
 pub const SYS_MIN_ALIGN: usize = 16;
-// The allocator on the esp-idf platform guarentees 4 byte alignment.
+// The allocator on the esp-idf and zkvm platforms guarantee 4 byte alignment.
 #[cfg(any(
-    all(target_arch = "riscv32", target_os = "espidf"),
+    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
     all(target_arch = "xtensa", target_os = "espidf"),
 ))]
 #[doc(hidden)]

mlua-sys/src/lua51/compat.rs

@@ -2,7 +2,6 @@
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3
 
-use std::convert::TryInto;
 use std::mem;
 use std::os::raw::{c_char, c_int, c_void};
 use std::ptr;

mlua-sys/src/lua51/lauxlib.rs

@@ -43,7 +43,7 @@ extern "C-unwind" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,

mlua-sys/src/lua51/lua.rs

@@ -228,13 +228,23 @@ extern "C-unwind" {
 //
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
 extern "C-unwind" {
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
     pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -318,6 +328,14 @@ pub unsafe fn lua_getglobal_(L: *mut lua_State, var: *const c_char) {
     lua_getfield_(L, LUA_GLOBALSINDEX, var)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())

mlua-sys/src/lua52/compat.rs

@@ -2,7 +2,6 @@
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3
 
-use std::convert::TryInto;
 use std::os::raw::{c_char, c_int, c_void};
 use std::ptr;
 

mlua-sys/src/lua52/lauxlib.rs

@@ -49,7 +49,7 @@ extern "C-unwind" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,

mlua-sys/src/lua52/lua.rs

@@ -308,7 +308,8 @@ extern "C-unwind" {
     //
     // Miscellaneous functions
     //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_len(L: *mut lua_State, idx: c_int);
@@ -316,6 +317,15 @@ extern "C-unwind" {
     pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -407,6 +417,14 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
     lua_rawgeti_(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS as _)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
@@ -453,7 +471,12 @@ extern "C-unwind" {
     pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
     pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
 
-    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int);
+    pub fn lua_sethook(
+        L: *mut lua_State,
+        func: Option<lua_Hook>,
+        mask: c_int,
+        count: c_int,
+    ) -> c_int;
     pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
     pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
     pub fn lua_gethookcount(L: *mut lua_State) -> c_int;

mlua-sys/src/lua53/lauxlib.rs

@@ -20,7 +20,7 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
 extern "C-unwind" {
     pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
 
@@ -51,7 +51,7 @@ extern "C-unwind" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,

mlua-sys/src/lua53/lua.rs

@@ -314,7 +314,8 @@ extern "C-unwind" {
     //
     // Miscellaneous functions
     //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_len(L: *mut lua_State, idx: c_int);
@@ -323,6 +324,15 @@ extern "C-unwind" {
     pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -414,6 +424,14 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
     lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())

mlua-sys/src/lua54/lauxlib.rs

@@ -50,7 +50,7 @@ extern "C-unwind" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,

mlua-sys/src/lua54/lua.rs

@@ -149,13 +149,21 @@ extern "C-unwind" {
     pub fn lua_tointegerx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
     pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
-    pub fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize;
+    #[link_name = "lua_rawlen"]
+    fn lua_rawlen_(L: *mut lua_State, idx: c_int) -> lua_Unsigned;
     pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
     pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
     pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
 }
 
+// lua_rawlen's return type changed from size_t to lua_Unsigned int in Lua 5.4.
+// This adapts the crate API to the new Lua ABI.
+#[inline(always)]
+pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
+    lua_rawlen_(L, idx) as usize
+}
+
 //
 // Comparison and arithmetic functions
 //
@@ -336,7 +344,8 @@ extern "C-unwind" {
     //
     // Miscellaneous functions
     //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_len(L: *mut lua_State, idx: c_int);
@@ -348,6 +357,15 @@ extern "C-unwind" {
     pub fn lua_closeslot(L: *mut lua_State, idx: c_int);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -439,6 +457,14 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
     lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())

mlua-sys/src/luau/lauxlib.rs

@@ -52,6 +52,8 @@ extern "C-unwind" {
     pub fn luaL_newmetatable_(L: *mut lua_State, tname: *const c_char) -> c_int;
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
+    pub fn luaL_checkbuffer(L: *mut lua_State, narg: c_int, len: *mut usize) -> *mut c_void;
+
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
 
     #[link_name = "luaL_errorL"]
@@ -142,9 +144,12 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
 
     // set all builtin metatables to read-only
     lua_pushliteral(L, "");
-    lua_getmetatable(L, -1);
-    lua_setreadonly(L, -1, enabled);
-    lua_pop(L, 2);
+    if lua_getmetatable(L, -1) != 0 {
+        lua_setreadonly(L, -1, enabled);
+        lua_pop(L, 2);
+    } else {
+        lua_pop(L, 1);
+    }
 
     // set globals to readonly and activate safeenv since the env is immutable
     lua_setreadonly(L, LUA_GLOBALSINDEX, enabled);
@@ -152,5 +157,48 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
 }
 
 //
-// TODO: Generic Buffer Manipulation
+// Generic Buffer Manipulation
 //
+
+/// Buffer size used for on-stack string operations. This limit depends on native stack size.
+pub const LUA_BUFFERSIZE: usize = 512;
+
+#[repr(C)]
+pub struct luaL_Strbuf {
+    p: *mut c_char,   // current position in buffer
+    end: *mut c_char, // end of the current buffer
+    L: *mut lua_State,
+    storage: *mut c_void, // TString
+    buffer: [c_char; LUA_BUFFERSIZE],
+}
+
+// For compatibility
+pub type luaL_Buffer = luaL_Strbuf;
+
+extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Strbuf);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_prepbuffsize(B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Strbuf, s: *const c_char, l: usize);
+    pub fn luaL_addvalue(B: *mut luaL_Strbuf);
+    pub fn luaL_addvalueany(B: *mut luaL_Strbuf, idx: c_int);
+    pub fn luaL_pushresult(B: *mut luaL_Strbuf);
+    pub fn luaL_pushresultsize(B: *mut luaL_Strbuf, size: usize);
+}
+
+pub unsafe fn luaL_addchar(B: *mut luaL_Strbuf, c: c_char) {
+    if (*B).p >= (*B).end {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).p = c;
+    (*B).p = (*B).p.add(1);
+}
+
+pub unsafe fn luaL_addstring(B: *mut luaL_Strbuf, s: *const c_char) {
+    // Calculate length of s
+    let mut len = 0;
+    while *s.add(len) != 0 {
+        len += 1;
+    }
+    luaL_addlstring(B, s, len);
+}

mlua-sys/src/luau/lua.rs

@@ -2,13 +2,19 @@
 
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_float, c_int, c_uint, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 // Option for multiple returns in 'lua_pcall' and 'lua_call'
 pub const LUA_MULTRET: c_int = -1;
 
 // Max number of Lua stack slots
-const LUAI_MAXCSTACK: c_int = 100000;
+const LUAI_MAXCSTACK: c_int = 1000000;
+
+// Number of valid Lua userdata tags
+const LUA_UTAG_LIMIT: c_int = 128;
+
+// Number of valid Lua lightuserdata tags
+const LUA_LUTAG_LIMIT: c_int = 128;
 
 //
 // Pseudo-indices
@@ -55,6 +61,7 @@ pub const LUA_TTABLE: c_int = 6;
 pub const LUA_TFUNCTION: c_int = 7;
 pub const LUA_TUSERDATA: c_int = 8;
 pub const LUA_TTHREAD: c_int = 9;
+pub const LUA_TBUFFER: c_int = 10;
 
 /// Guaranteed number of Lua stack slots available to a C function.
 pub const LUA_MINSTACK: c_int = 20;
@@ -143,10 +150,13 @@ extern "C-unwind" {
     pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
     pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
     pub fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tolightuserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
     pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_touserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
     pub fn lua_userdatatag(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_lightuserdatatag(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_tobuffer(L: *mut lua_State, idx: c_int, len: *mut usize) -> *mut c_void;
     pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
 
     //
@@ -177,10 +187,12 @@ extern "C-unwind" {
     pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
     pub fn lua_pushthread(L: *mut lua_State) -> c_int;
 
-    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushlightuserdatatagged(L: *mut lua_State, p: *mut c_void, tag: c_int);
     pub fn lua_newuserdatatagged(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
     pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Udestructor) -> *mut c_void;
 
+    pub fn lua_newbuffer(L: *mut lua_State, sz: usize) -> *mut c_void;
+
     //
     // Get functions (Lua -> stack)
     //
@@ -276,8 +288,13 @@ extern "C-unwind" {
     pub fn lua_setuserdatatag(L: *mut lua_State, idx: c_int, tag: c_int);
     pub fn lua_setuserdatadtor(L: *mut lua_State, tag: c_int, dtor: Option<lua_Destructor>);
     pub fn lua_getuserdatadtor(L: *mut lua_State, tag: c_int) -> Option<lua_Destructor>;
+    pub fn lua_setuserdatametatable(L: *mut lua_State, tag: c_int, idx: c_int);
+    pub fn lua_getuserdatametatable(L: *mut lua_State, tag: c_int);
+    pub fn lua_setlightuserdataname(L: *mut lua_State, tag: c_int, name: *const c_char);
+    pub fn lua_getlightuserdataname(L: *mut lua_State, tag: c_int) -> *const c_char;
     pub fn lua_clonefunction(L: *mut lua_State, idx: c_int);
     pub fn lua_cleartable(L: *mut lua_State, idx: c_int);
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
 }
 
 //
@@ -325,6 +342,15 @@ pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
     lua_newuserdatatagged(L, sz, 0)
 }
 
+#[inline(always)]
+pub unsafe fn lua_newuserdata_t<T>(L: *mut lua_State) -> *mut T {
+    unsafe extern "C-unwind" fn destructor<T>(ud: *mut c_void) {
+        ptr::drop_in_place(ud as *mut T);
+    }
+
+    lua_newuserdatadtor(L, mem::size_of::<T>(), destructor::<T>) as *mut T
+}
+
 // TODO: lua_strlen
 
 #[inline(always)]
@@ -362,6 +388,11 @@ pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
     (lua_type(L, n) == LUA_TTHREAD) as c_int
 }
 
+#[inline(always)]
+pub unsafe fn lua_isbuffer(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBUFFER) as c_int
+}
+
 #[inline(always)]
 pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
     (lua_type(L, n) == LUA_TNONE) as c_int
@@ -379,18 +410,22 @@ pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
     lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
 }
 
+#[inline(always)]
 pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
     lua_pushcclosurek(L, f, ptr::null(), 0, None)
 }
 
+#[inline(always)]
 pub unsafe fn lua_pushcfunctiond(L: *mut lua_State, f: lua_CFunction, debugname: *const c_char) {
     lua_pushcclosurek(L, f, debugname, 0, None)
 }
 
+#[inline(always)]
 pub unsafe fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, nup: c_int) {
     lua_pushcclosurek(L, f, ptr::null(), nup, None)
 }
 
+#[inline(always)]
 pub unsafe fn lua_pushcclosured(
     L: *mut lua_State,
     f: lua_CFunction,
@@ -400,6 +435,11 @@ pub unsafe fn lua_pushcclosured(
     lua_pushcclosurek(L, f, debugname, nup, None)
 }
 
+#[inline(always)]
+pub unsafe fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void) {
+    lua_pushlightuserdatatagged(L, p, 0)
+}
+
 #[inline(always)]
 pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
     lua_setfield(L, LUA_GLOBALSINDEX, var)
@@ -487,6 +527,7 @@ pub struct lua_Debug {
 //
 
 #[repr(C)]
+#[non_exhaustive]
 pub struct lua_Callbacks {
     /// arbitrary userdata pointer that is never overwritten by Luau
     pub userdata: *mut c_void,
@@ -514,3 +555,8 @@ pub struct lua_Callbacks {
 extern "C" {
     pub fn lua_callbacks(L: *mut lua_State) -> *mut lua_Callbacks;
 }
+
+// Functions from customization lib
+extern "C" {
+    pub fn luau_setfflag(name: *const c_char, value: c_int) -> c_int;
+}

mlua-sys/src/luau/luacode.rs

@@ -1,17 +1,36 @@
 //! Contains definitions from `luacode.h`.
 
 use std::os::raw::{c_char, c_int, c_void};
-use std::slice;
+use std::{ptr, slice};
 
 #[repr(C)]
+#[non_exhaustive]
 pub struct lua_CompileOptions {
     pub optimizationLevel: c_int,
     pub debugLevel: c_int,
+    pub typeInfoLevel: c_int,
     pub coverageLevel: c_int,
     pub vectorLib: *const c_char,
     pub vectorCtor: *const c_char,
     pub vectorType: *const c_char,
     pub mutableGlobals: *const *const c_char,
+    pub userdataTypes: *const *const c_char,
+}
+
+impl Default for lua_CompileOptions {
+    fn default() -> Self {
+        Self {
+            optimizationLevel: 1,
+            debugLevel: 1,
+            typeInfoLevel: 0,
+            coverageLevel: 0,
+            vectorLib: ptr::null(),
+            vectorCtor: ptr::null(),
+            vectorType: ptr::null(),
+            mutableGlobals: ptr::null(),
+            userdataTypes: ptr::null(),
+        }
+    }
 }
 
 extern "C-unwind" {
@@ -36,6 +55,7 @@ pub unsafe fn luau_compile(source: &[u8], mut options: lua_CompileOptions) -> Ve
         &mut options,
         &mut outsize,
     );
+    assert!(!data_ptr.is_null(), "luau_compile failed");
     let data = slice::from_raw_parts(data_ptr as *mut u8, outsize).to_vec();
     free(data_ptr as *mut c_void);
     data

mlua-sys/src/luau/lualib.rs

@@ -9,6 +9,7 @@ pub const LUA_TABLIBNAME: &str = "table";
 pub const LUA_OSLIBNAME: &str = "os";
 pub const LUA_STRLIBNAME: &str = "string";
 pub const LUA_BITLIBNAME: &str = "bit32";
+pub const LUA_BUFFERLIBNAME: &str = "buffer";
 pub const LUA_UTF8LIBNAME: &str = "utf8";
 pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
@@ -20,6 +21,7 @@ extern "C-unwind" {
     pub fn luaopen_os(L: *mut lua_State) -> c_int;
     pub fn luaopen_string(L: *mut lua_State) -> c_int;
     pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
+    pub fn luaopen_buffer(L: *mut lua_State) -> c_int;
     pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
     pub fn luaopen_math(L: *mut lua_State) -> c_int;
     pub fn luaopen_debug(L: *mut lua_State) -> c_int;

mlua_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua_derive"
-version = "0.9.0"
+version = "0.9.3"
 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.11", optional = true }
+itertools = { version = "0.12", optional = true }
 regex = { version = "1.4", optional = true }
 once_cell = { version = "1.0", optional = true }

mlua_derive/src/from_lua.rs

@@ -7,16 +7,17 @@ pub fn from_lua(input: TokenStream) -> TokenStream {
         ident, generics, ..
     } = parse_macro_input!(input as DeriveInput);
 
+    let ident_str = ident.to_string();
+    let (impl_generics, ty_generics, _) = generics.split_for_impl();
     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 {
+      impl #impl_generics ::mlua::FromLua<'_> for #ident #ty_generics #where_clause {
         #[inline]
-        fn from_lua(value: ::mlua::Value<'_>, lua: &'_ ::mlua::Lua) -> ::mlua::Result<Self> {
+        fn from_lua(value: ::mlua::Value<'_>, _: &'_ ::mlua::Lua) -> ::mlua::Result<Self> {
           match value {
             ::mlua::Value::UserData(ud) => Ok(ud.borrow::<Self>()?.clone()),
             _ => Err(::mlua::Error::FromLuaConversionError {

mlua_derive/src/lib.rs

@@ -51,18 +51,22 @@ 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 skip_memory_check = if args.skip_memory_check {
+        quote! { lua.skip_memory_check(true); }
+    } else {
+        quote! {}
+    };
 
     let wrapped = quote! {
-        ::mlua::require_module_feature!();
+        mlua::require_module_feature!();
 
         #func
 
         #[no_mangle]
-        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);
-            lua.skip_memory_check(#skip_memory_check);
-            lua.entrypoint1(#func_name)
+        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);
+            #skip_memory_check
+            lua.entrypoint1(state, #func_name)
         }
     };
 
@@ -91,7 +95,7 @@ pub fn chunk(input: TokenStream) -> TokenStream {
     });
 
     let wrapped_code = quote! {{
-        use ::mlua::{AsChunk, ChunkMode, Lua, Result, Table};
+        use mlua::{AsChunk, ChunkMode, Lua, Result, Table};
         use ::std::borrow::Cow;
         use ::std::cell::Cell;
         use ::std::io::Result as IoResult;

mlua_derive/src/token.rs

@@ -1,7 +1,6 @@
 use std::{
     cmp::{Eq, PartialEq},
     fmt::{self, Display, Formatter},
-    iter::IntoIterator,
     vec::IntoIter,
 };
 

src/chunk.rs

@@ -122,11 +122,13 @@ pub enum ChunkMode {
 pub struct Compiler {
     optimization_level: u8,
     debug_level: u8,
+    type_info_level: u8,
     coverage_level: u8,
     vector_lib: Option<String>,
     vector_ctor: Option<String>,
     vector_type: Option<String>,
     mutable_globals: Vec<String>,
+    userdata_types: Vec<String>,
 }
 
 #[cfg(any(feature = "luau", doc))]
@@ -144,11 +146,13 @@ impl Compiler {
         Compiler {
             optimization_level: 1,
             debug_level: 1,
+            type_info_level: 0,
             coverage_level: 0,
             vector_lib: None,
             vector_ctor: None,
             vector_type: None,
             mutable_globals: Vec::new(),
+            userdata_types: Vec::new(),
         }
     }
 
@@ -176,6 +180,16 @@ impl Compiler {
         self
     }
 
+    /// Sets Luau type information level used to guide native code generation decisions.
+    ///
+    /// Possible values:
+    /// * 0 - generate for native modules (default)
+    /// * 1 - generate for all modules
+    pub const fn set_type_info_level(mut self, level: u8) -> Self {
+        self.type_info_level = level;
+        self
+    }
+
     /// Sets Luau compiler code coverage level.
     ///
     /// Possible values:
@@ -218,6 +232,13 @@ impl Compiler {
         self
     }
 
+    /// Sets a list of userdata types that will be included in the type information.
+    #[must_use]
+    pub fn set_userdata_types(mut self, types: Vec<String>) -> Self {
+        self.userdata_types = types;
+        self
+    }
+
     /// Compiles the `source` into bytecode.
     pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
         use std::os::raw::c_int;
@@ -233,32 +254,37 @@ impl Compiler {
         let vector_type = vector_type.and_then(|t| CString::new(t).ok());
         let vector_type = vector_type.as_ref();
 
-        let mutable_globals = self
-            .mutable_globals
-            .iter()
-            .map(|name| CString::new(name.clone()).ok())
-            .collect::<Option<Vec<_>>>()
-            .unwrap_or_default();
-        let mut mutable_globals = mutable_globals
-            .iter()
-            .map(|s| s.as_ptr())
-            .collect::<Vec<_>>();
-        let mut mutable_globals_ptr = ptr::null();
-        if !mutable_globals.is_empty() {
-            mutable_globals.push(ptr::null());
-            mutable_globals_ptr = mutable_globals.as_ptr();
+        macro_rules! vec2cstring_ptr {
+            ($name:ident, $name_ptr:ident) => {
+                let $name = self
+                    .$name
+                    .iter()
+                    .map(|name| CString::new(name.clone()).ok())
+                    .collect::<Option<Vec<_>>>()
+                    .unwrap_or_default();
+                let mut $name = $name.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+                let mut $name_ptr = ptr::null();
+                if !$name.is_empty() {
+                    $name.push(ptr::null());
+                    $name_ptr = $name.as_ptr();
+                }
+            };
         }
 
+        vec2cstring_ptr!(mutable_globals, mutable_globals_ptr);
+        vec2cstring_ptr!(userdata_types, userdata_types_ptr);
+
         unsafe {
-            let options = ffi::lua_CompileOptions {
-                optimizationLevel: self.optimization_level as c_int,
-                debugLevel: self.debug_level as c_int,
-                coverageLevel: self.coverage_level as c_int,
-                vectorLib: vector_lib.map_or(ptr::null(), |s| s.as_ptr()),
-                vectorCtor: vector_ctor.map_or(ptr::null(), |s| s.as_ptr()),
-                vectorType: vector_type.map_or(ptr::null(), |s| s.as_ptr()),
-                mutableGlobals: mutable_globals_ptr,
-            };
+            let mut options = ffi::lua_CompileOptions::default();
+            options.optimizationLevel = self.optimization_level as c_int;
+            options.debugLevel = self.debug_level as c_int;
+            options.typeInfoLevel = self.type_info_level as c_int;
+            options.coverageLevel = self.coverage_level as c_int;
+            options.vectorLib = vector_lib.map_or(ptr::null(), |s| s.as_ptr());
+            options.vectorCtor = vector_ctor.map_or(ptr::null(), |s| s.as_ptr());
+            options.vectorType = vector_type.map_or(ptr::null(), |s| s.as_ptr());
+            options.mutableGlobals = mutable_globals_ptr;
+            options.userdataTypes = userdata_types_ptr;
             ffi::luau_compile(source.as_ref(), options)
         }
     }
@@ -315,7 +341,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// This is equivalent to calling the chunk function with no arguments and no return values.
     pub fn exec(self) -> Result<()> {
-        self.call(())?;
+        self.call::<_, ()>(())?;
         Ok(())
     }
 

src/conversion.rs

@@ -1,6 +1,5 @@
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::convert::TryInto;
 use std::ffi::{CStr, CString};
 use std::hash::{BuildHasher, Hash};
 use std::os::raw::c_int;
@@ -16,12 +15,15 @@ use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
-use crate::types::{LightUserData, MaybeSend};
+use crate::types::{LightUserData, MaybeSend, RegistryKey};
 use crate::userdata::{AnyUserData, UserData, UserDataRef, UserDataRefMut};
 use crate::value::{FromLua, IntoLua, Nil, Value};
 
 #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
-use crate::{function::OwnedFunction, table::OwnedTable, userdata::OwnedAnyUserData};
+use crate::{
+    function::OwnedFunction, string::OwnedString, table::OwnedTable, thread::OwnedThread,
+    userdata::OwnedAnyUserData,
+};
 
 impl<'lua> IntoLua<'lua> for Value<'lua> {
     #[inline]
@@ -30,6 +32,18 @@ impl<'lua> IntoLua<'lua> for Value<'lua> {
     }
 }
 
+impl<'lua> IntoLua<'lua> for &Value<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(self.clone())
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_value_ref(self)
+    }
+}
+
 impl<'lua> FromLua<'lua> for Value<'lua> {
     #[inline]
     fn from_lua(lua_value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
@@ -44,6 +58,19 @@ impl<'lua> IntoLua<'lua> for String<'lua> {
     }
 }
 
+impl<'lua> IntoLua<'lua> for &String<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::String(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
 impl<'lua> FromLua<'lua> for String<'lua> {
     #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<String<'lua>> {
@@ -57,6 +84,39 @@ impl<'lua> FromLua<'lua> for String<'lua> {
     }
 }
 
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> IntoLua<'lua> for OwnedString {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::String(String(lua.adopt_owned_ref(self.0))))
+    }
+}
+
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> IntoLua<'lua> for &OwnedString {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        OwnedString::into_lua(self.clone(), lua)
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_owned_ref(&self.0);
+        Ok(())
+    }
+}
+
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> FromLua<'lua> for OwnedString {
+    #[inline]
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<OwnedString> {
+        String::from_lua(value, lua).map(|s| s.into_owned())
+    }
+}
+
 impl<'lua> IntoLua<'lua> for Table<'lua> {
     #[inline]
     fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
@@ -64,6 +124,19 @@ impl<'lua> IntoLua<'lua> for Table<'lua> {
     }
 }
 
+impl<'lua> IntoLua<'lua> for &Table<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Table(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
 impl<'lua> FromLua<'lua> for Table<'lua> {
     #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Table<'lua>> {
@@ -87,6 +160,21 @@ impl<'lua> IntoLua<'lua> for OwnedTable {
     }
 }
 
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> IntoLua<'lua> for &OwnedTable {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        OwnedTable::into_lua(self.clone(), lua)
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_owned_ref(&self.0);
+        Ok(())
+    }
+}
+
 #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
 #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
 impl<'lua> FromLua<'lua> for OwnedTable {
@@ -103,6 +191,19 @@ impl<'lua> IntoLua<'lua> for Function<'lua> {
     }
 }
 
+impl<'lua> IntoLua<'lua> for &Function<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Function(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
 impl<'lua> FromLua<'lua> for Function<'lua> {
     #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Function<'lua>> {
@@ -126,6 +227,21 @@ impl<'lua> IntoLua<'lua> for OwnedFunction {
     }
 }
 
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> IntoLua<'lua> for &OwnedFunction {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        OwnedFunction::into_lua(self.clone(), lua)
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_owned_ref(&self.0);
+        Ok(())
+    }
+}
+
 #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
 #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
 impl<'lua> FromLua<'lua> for OwnedFunction {
@@ -142,6 +258,19 @@ impl<'lua> IntoLua<'lua> for Thread<'lua> {
     }
 }
 
+impl<'lua> IntoLua<'lua> for &Thread<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Thread(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
 impl<'lua> FromLua<'lua> for Thread<'lua> {
     #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Thread<'lua>> {
@@ -156,6 +285,39 @@ impl<'lua> FromLua<'lua> for Thread<'lua> {
     }
 }
 
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> IntoLua<'lua> for OwnedThread {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Thread(Thread(lua.adopt_owned_ref(self.0), self.1)))
+    }
+}
+
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> IntoLua<'lua> for &OwnedThread {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        OwnedThread::into_lua(self.clone(), lua)
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_owned_ref(&self.0);
+        Ok(())
+    }
+}
+
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> FromLua<'lua> for OwnedThread {
+    #[inline]
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<OwnedThread> {
+        Thread::from_lua(value, lua).map(|s| s.into_owned())
+    }
+}
+
 impl<'lua> IntoLua<'lua> for AnyUserData<'lua> {
     #[inline]
     fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
@@ -163,6 +325,19 @@ impl<'lua> IntoLua<'lua> for AnyUserData<'lua> {
     }
 }
 
+impl<'lua> IntoLua<'lua> for &AnyUserData<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::UserData(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
 impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
     #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<AnyUserData<'lua>> {
@@ -182,7 +357,25 @@ impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
 impl<'lua> IntoLua<'lua> for OwnedAnyUserData {
     #[inline]
     fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::UserData(AnyUserData(lua.adopt_owned_ref(self.0))))
+        Ok(Value::UserData(AnyUserData(
+            lua.adopt_owned_ref(self.0),
+            self.1,
+        )))
+    }
+}
+
+#[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+impl<'lua> IntoLua<'lua> for &OwnedAnyUserData {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        OwnedAnyUserData::into_lua(self.clone(), lua)
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        lua.push_owned_ref(&self.0);
+        Ok(())
     }
 }
 
@@ -237,11 +430,57 @@ impl<'lua> FromLua<'lua> for Error {
     }
 }
 
+impl<'lua> IntoLua<'lua> for RegistryKey {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.registry_value(&self)
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        <&RegistryKey>::push_into_stack(&self, lua)
+    }
+}
+
+impl<'lua> IntoLua<'lua> for &RegistryKey {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.registry_value(self)
+    }
+
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        if !lua.owns_registry_value(self) {
+            return Err(Error::MismatchedRegistryKey);
+        }
+
+        match self.id() {
+            ffi::LUA_REFNIL => ffi::lua_pushnil(lua.state()),
+            id => {
+                ffi::lua_rawgeti(lua.state(), ffi::LUA_REGISTRYINDEX, id as _);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl<'lua> FromLua<'lua> for RegistryKey {
+    #[inline]
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<RegistryKey> {
+        lua.create_registry_value(value)
+    }
+}
+
 impl<'lua> IntoLua<'lua> for bool {
     #[inline]
     fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Boolean(self))
     }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        ffi::lua_pushboolean(lua.state(), self as c_int);
+        Ok(())
+    }
 }
 
 impl<'lua> FromLua<'lua> for bool {
@@ -253,6 +492,11 @@ impl<'lua> FromLua<'lua> for bool {
             _ => Ok(true),
         }
     }
+
+    #[inline]
+    unsafe fn from_stack(idx: c_int, lua: &'lua Lua) -> Result<Self> {
+        Ok(ffi::lua_toboolean(lua.state(), idx) != 0)
+    }
 }
 
 impl<'lua> IntoLua<'lua> for LightUserData {
@@ -441,19 +685,49 @@ impl<'lua> IntoLua<'lua> for BString {
 }
 
 impl<'lua> FromLua<'lua> for BString {
-    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         let ty = value.type_name();
-        Ok(BString::from(
-            lua.coerce_string(value)?
+        match value {
+            Value::String(s) => Ok(s.as_bytes().into()),
+            #[cfg(feature = "luau")]
+            Value::UserData(ud) if ud.1 == crate::types::SubtypeId::Buffer => unsafe {
+                let mut size = 0usize;
+                let buf = ffi::lua_tobuffer(ud.0.lua.ref_thread(), ud.0.index, &mut size);
+                mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+                Ok(slice::from_raw_parts(buf as *const u8, size).into())
+            },
+            _ => Ok(lua
+                .coerce_string(value)?
                 .ok_or_else(|| Error::FromLuaConversionError {
                     from: ty,
                     to: "BString",
                     message: Some("expected string or number".to_string()),
                 })?
                 .as_bytes()
-                .to_vec(),
-        ))
+                .into()),
+        }
+    }
+
+    unsafe fn from_stack(idx: c_int, lua: &'lua Lua) -> Result<Self> {
+        let state = lua.state();
+        match ffi::lua_type(state, idx) {
+            ffi::LUA_TSTRING => {
+                let mut size = 0;
+                let data = ffi::lua_tolstring(state, idx, &mut size);
+                Ok(slice::from_raw_parts(data as *const u8, size).into())
+            }
+            #[cfg(feature = "luau")]
+            ffi::LUA_TBUFFER => {
+                let mut size = 0;
+                let buf = ffi::lua_tobuffer(state, idx, &mut size);
+                mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+                Ok(slice::from_raw_parts(buf as *const u8, size).into())
+            }
+            _ => {
+                // Fallback to default
+                Self::from_lua(lua.stack_value(idx), lua)
+            }
+        }
     }
 }
 
@@ -494,6 +768,15 @@ macro_rules! lua_convert_int {
                         message: Some("out of range".to_owned()),
                     })
             }
+
+            #[inline]
+            unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+                match cast(self) {
+                    Some(i) => ffi::lua_pushinteger(lua.state(), i),
+                    None => ffi::lua_pushnumber(lua.state(), self as ffi::lua_Number),
+                }
+                Ok(())
+            }
         }
 
         impl<'lua> FromLua<'lua> for $x {
@@ -786,6 +1069,15 @@ impl<'lua, T: IntoLua<'lua>> IntoLua<'lua> for Option<T> {
             None => Ok(Nil),
         }
     }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
+        match self {
+            Some(val) => val.push_into_stack(lua)?,
+            None => ffi::lua_pushnil(lua.state()),
+        }
+        Ok(())
+    }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Option<T> {
@@ -796,4 +1088,13 @@ impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Option<T> {
             value => Ok(Some(T::from_lua(value, lua)?)),
         }
     }
+
+    #[inline]
+    unsafe fn from_stack(idx: c_int, lua: &'lua Lua) -> Result<Self> {
+        if ffi::lua_isnil(lua.state(), idx) != 0 {
+            Ok(None)
+        } else {
+            Ok(Some(T::from_stack(idx, lua)?))
+        }
+    }
 }

src/error.rs

@@ -101,7 +101,7 @@ pub enum Error {
     /// [`Thread::resume`] was called on an inactive coroutine.
     ///
     /// A coroutine is inactive if its main function has returned or if an error has occurred inside
-    /// the coroutine.
+    /// the coroutine. Already running coroutines are also marked as inactive (unresumable).
     ///
     /// [`Thread::status`] can be used to check if the coroutine can be resumed without causing this
     /// error.

src/function.rs

@@ -6,12 +6,11 @@ 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, linenumber_to_usize, pop_error, ptr_to_lossy_str,
-    ptr_to_str, StackGuard,
+    assert_stack, check_stack, linenumber_to_usize, pop_error, ptr_to_lossy_str, ptr_to_str,
+    StackGuard,
 };
 use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
@@ -131,7 +130,7 @@ impl<'lua> Function<'lua> {
             check_stack(state, 2)?;
 
             // Push error handler
-            MemoryState::relax_limit_with(state, || ffi::lua_pushcfunction(state, error_traceback));
+            lua.push_error_traceback();
             let stack_start = ffi::lua_gettop(state);
             // Push function and the arguments
             lua.push_ref(&self.0);
@@ -495,6 +494,37 @@ impl<'lua> Function<'lua> {
         }
     }
 
+    /// Converts this function to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
+
+    /// Creates a deep clone of the Lua function.
+    ///
+    /// Copies the function prototype and all its upvalues to the
+    /// newly created function.
+    ///
+    /// This function returns shallow clone (same handle) for Rust/C functions.
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn deep_clone(&self) -> Self {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe {
+            if ffi::lua_iscfunction(ref_thread, self.0.index) != 0 {
+                return self.clone();
+            }
+
+            ffi::lua_clonefunction(ref_thread, self.0.index);
+            Function(self.0.lua.pop_ref_thread())
+        }
+    }
+
     /// Convert this handle to owned version.
     #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
     #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]

src/hook.rs

@@ -353,8 +353,10 @@ impl HookTriggers {
     // Returns the `count` parameter to pass to `lua_sethook`, if applicable. Otherwise, zero is
     // returned.
     pub(crate) const fn count(&self) -> c_int {
-        let Some(n) = self.every_nth_instruction else { return 0 };
-        n as c_int
+        match self.every_nth_instruction {
+            Some(n) => n as c_int,
+            None => 0,
+        }
     }
 }
 

src/lib.rs

@@ -73,7 +73,7 @@
 
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
-#![doc(test(attr(deny(warnings))))]
+#![doc(test(attr(warn(warnings))))] // FIXME: Remove this when rust-lang/rust#123748 is fixed
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[macro_use]

src/lua.rs

@@ -3,15 +3,14 @@ use std::cell::{RefCell, UnsafeCell};
 use std::ffi::{CStr, CString};
 use std::fmt;
 use std::marker::PhantomData;
-use std::mem::MaybeUninit;
+use std::mem::{self, MaybeUninit};
 use std::ops::Deref;
 use std::os::raw::{c_char, c_int, c_void};
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe, Location};
-use std::ptr::NonNull;
+use std::ptr;
 use std::result::Result as StdResult;
 use std::sync::atomic::{AtomicPtr, Ordering};
 use std::sync::{Arc, Mutex};
-use std::{mem, ptr, str};
 
 use rustc_hash::FxHashMap;
 
@@ -27,15 +26,15 @@ use crate::table::Table;
 use crate::thread::Thread;
 use crate::types::{
     AppData, AppDataRef, AppDataRefMut, Callback, CallbackUpvalue, DestructedUserdata, Integer,
-    LightUserData, LuaRef, MaybeSend, Number, RegistryKey,
+    LightUserData, LuaRef, MaybeSend, Number, RegistryKey, SubtypeId,
 };
 use crate::userdata::{AnyUserData, MetaMethod, UserData, UserDataCell};
 use crate::userdata_impl::{UserDataProxy, UserDataRegistry};
 use crate::util::{
-    self, assert_stack, check_stack, get_destructed_userdata_metatable, get_gc_metatable,
-    get_gc_userdata, get_main_state, get_userdata, init_error_registry, init_gc_metatable,
-    init_userdata_metatable, pop_error, push_gc_userdata, push_string, push_table, rawset_field,
-    safe_pcall, safe_xpcall, short_type_name, StackGuard, WrappedFailure,
+    self, assert_stack, check_stack, error_traceback, get_destructed_userdata_metatable,
+    get_gc_metatable, get_gc_userdata, get_main_state, get_userdata, init_error_registry,
+    init_gc_metatable, init_userdata_metatable, pop_error, push_gc_userdata, push_string,
+    push_table, rawset_field, safe_pcall, safe_xpcall, short_type_name, StackGuard, WrappedFailure,
 };
 use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, Value};
 
@@ -60,6 +59,7 @@ use {
     crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue},
     futures_util::future::{self, Future},
     futures_util::task::{noop_waker_ref, Context, Poll, Waker},
+    std::ptr::NonNull,
 };
 
 #[cfg(feature = "serialize")]
@@ -94,7 +94,6 @@ pub(crate) struct ExtraData {
 
     safe: bool,
     libs: StdLib,
-    mem_state: Option<NonNull<MemoryState>>,
     #[cfg(feature = "module")]
     skip_memory_check: bool,
 
@@ -227,6 +226,7 @@ pub(crate) static EXTRA_REGISTRY_KEY: u8 = 0;
 
 const WRAPPED_FAILURE_POOL_SIZE: usize = 64;
 const MULTIVALUE_POOL_SIZE: usize = 64;
+const REF_STACK_RESERVE: c_int = 1;
 
 /// Requires `feature = "send"`
 #[cfg(feature = "send")]
@@ -244,11 +244,14 @@ impl Drop for Lua {
 impl Drop for LuaInner {
     fn drop(&mut self) {
         unsafe {
-            #[cfg(feature = "luau")]
-            {
-                (*ffi::lua_callbacks(self.state())).userdata = ptr::null_mut();
-            }
+            let mem_state = MemoryState::get(self.main_state);
+
             ffi::lua_close(self.main_state);
+
+            // Deallocate MemoryState
+            if !mem_state.is_null() {
+                drop(Box::from_raw(mem_state));
+            }
         }
     }
 }
@@ -261,9 +264,6 @@ impl Drop for ExtraData {
         }
 
         *mlua_expect!(self.registry_unref_list.lock(), "unref list poisoned") = None;
-        if let Some(mem_state) = self.mem_state {
-            drop(unsafe { Box::from_raw(mem_state.as_ptr()) });
-        }
     }
 }
 
@@ -341,7 +341,6 @@ impl Lua {
 
         let lua = unsafe { Self::inner_new(libs, options) };
 
-        #[cfg(not(feature = "luau"))]
         if libs.contains(StdLib::PACKAGE) {
             mlua_expect!(lua.disable_c_modules(), "Error during disabling C modules");
         }
@@ -359,23 +358,22 @@ impl Lua {
     ///
     /// [`StdLib`]: crate::StdLib
     pub unsafe fn unsafe_new_with(libs: StdLib, options: LuaOptions) -> Lua {
+        // Workaround to avoid stripping a few unused Lua symbols that could be imported
+        // by C modules in unsafe mode
+        let mut _symbols: Vec<*const extern "C-unwind" fn()> =
+            vec![ffi::lua_isuserdata as _, ffi::lua_tocfunction as _];
+
         #[cfg(not(feature = "luau"))]
+        _symbols.extend_from_slice(&[
+            ffi::lua_atpanic as _,
+            ffi::luaL_loadstring as _,
+            ffi::luaL_openlibs as _,
+        ]);
+        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
         {
-            // Workaround to avoid stripping a few unused Lua symbols that could be imported
-            // by C modules in unsafe mode
-            let mut _symbols: Vec<*const extern "C-unwind" fn()> = vec![
-                ffi::lua_atpanic as _,
-                ffi::lua_isuserdata as _,
-                ffi::lua_tocfunction as _,
-                ffi::luaL_loadstring as _,
-                ffi::luaL_openlibs as _,
-            ];
-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-            {
-                _symbols.push(ffi::lua_getglobal as _);
-                _symbols.push(ffi::lua_setglobal as _);
-                _symbols.push(ffi::luaL_setfuncs as _);
-            }
+            _symbols.push(ffi::lua_getglobal as _);
+            _symbols.push(ffi::lua_setglobal as _);
+            _symbols.push(ffi::luaL_setfuncs as _);
         }
 
         Self::inner_new(libs, options)
@@ -383,12 +381,11 @@ impl Lua {
 
     /// Creates a new Lua state with required `libs` and `options`
     unsafe fn inner_new(libs: StdLib, options: LuaOptions) -> Lua {
-        let mut mem_state: *mut MemoryState = Box::into_raw(Box::default());
+        let mem_state: *mut MemoryState = Box::into_raw(Box::default());
         let mut state = ffi::lua_newstate(ALLOCATOR, mem_state as *mut c_void);
         // If state is null then switch to Lua internal allocator
         if state.is_null() {
             drop(Box::from_raw(mem_state));
-            mem_state = ptr::null_mut();
             state = ffi::luaL_newstate();
         }
         assert!(!state.is_null(), "Failed to instantiate Lua VM");
@@ -404,7 +401,6 @@ impl Lua {
 
         let lua = Lua::init_from_ptr(state);
         let extra = lua.extra.get();
-        (*extra).mem_state = NonNull::new(mem_state);
 
         mlua_expect!(
             load_from_std_lib(state, libs),
@@ -440,7 +436,7 @@ impl Lua {
         }
 
         #[cfg(feature = "luau")]
-        mlua_expect!(lua.prepare_luau_state(), "Error preparing Luau state");
+        mlua_expect!(lua.configure_luau(), "Error configuring Luau");
 
         lua
     }
@@ -504,6 +500,13 @@ impl Lua {
             ptr
         };
 
+        // Store `error_traceback` function on the ref stack
+        #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+        {
+            ffi::lua_pushcfunction(ref_thread, error_traceback);
+            assert_eq!(ffi::lua_gettop(ref_thread), ExtraData::ERROR_TRACEBACK_IDX);
+        }
+
         // Create ExtraData
         let extra = Arc::new(UnsafeCell::new(ExtraData {
             inner: MaybeUninit::uninit(),
@@ -514,12 +517,11 @@ impl Lua {
             app_data: AppData::default(),
             safe: false,
             libs: StdLib::NONE,
-            mem_state: None,
             #[cfg(feature = "module")]
             skip_memory_check: false,
             ref_thread,
-            // We need 1 extra stack space to move values in and out of the ref stack.
-            ref_stack_size: ffi::LUA_MINSTACK - 1,
+            // We need some reserved stack space to move values in and out of the ref stack.
+            ref_stack_size: ffi::LUA_MINSTACK - REF_STACK_RESERVE,
             ref_stack_top: ffi::lua_gettop(ref_thread),
             ref_free: Vec::new(),
             wrapped_failure_pool: Vec::with_capacity(WRAPPED_FAILURE_POOL_SIZE),
@@ -547,14 +549,8 @@ impl Lua {
 
         // Store it in the registry
         mlua_expect!(
-            (|state| {
-                push_gc_userdata(state, Arc::clone(&extra), true)?;
-                protect_lua!(state, 1, 0, fn(state) {
-                    let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
-                    ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, extra_key);
-                })
-            })(main_state),
-            "Error while storing extra data",
+            set_extra_data(main_state, &extra),
+            "Error while storing extra data"
         );
 
         // Register `DestructedUserdata` type
@@ -572,13 +568,6 @@ impl Lua {
         );
         assert_stack(main_state, ffi::LUA_MINSTACK);
 
-        // Set Luau callbacks userdata to extra data
-        // We can use global callbacks userdata since we don't allow C modules in Luau
-        #[cfg(feature = "luau")]
-        {
-            (*ffi::lua_callbacks(main_state)).userdata = extra.get() as *mut c_void;
-        }
-
         let inner = Arc::new(LuaInner {
             state: AtomicPtr::new(state),
             main_state,
@@ -598,7 +587,6 @@ impl Lua {
     ///
     /// [`StdLib`]: crate::StdLib
     pub fn load_from_std_lib(&self, libs: StdLib) -> Result<()> {
-        #[cfg(not(feature = "luau"))]
         let is_safe = unsafe { (*self.extra.get()).safe };
 
         #[cfg(not(feature = "luau"))]
@@ -617,12 +605,9 @@ impl Lua {
         let res = unsafe { load_from_std_lib(self.main_state, libs) };
 
         // If `package` library loaded into a safe lua state then disable C modules
-        #[cfg(not(feature = "luau"))]
-        {
-            let curr_libs = unsafe { (*self.extra.get()).libs };
-            if is_safe && (curr_libs ^ (curr_libs | libs)).contains(StdLib::PACKAGE) {
-                mlua_expect!(self.disable_c_modules(), "Error during disabling C modules");
-            }
+        let curr_libs = unsafe { (*self.extra.get()).libs };
+        if is_safe && (curr_libs ^ (curr_libs | libs)).contains(StdLib::PACKAGE) {
+            mlua_expect!(self.disable_c_modules(), "Error during disabling C modules");
         }
         unsafe { (*self.extra.get()).libs |= libs };
 
@@ -724,18 +709,20 @@ impl Lua {
     // The returned value then pushed onto the stack.
     #[doc(hidden)]
     #[cfg(not(tarpaulin_include))]
-    pub unsafe fn entrypoint<'lua, A, R, F>(self, func: F) -> c_int
+    pub unsafe fn entrypoint<'lua, A, R, F>(self, state: *mut ffi::lua_State, func: F) -> c_int
     where
         A: FromLuaMulti<'lua>,
         R: IntoLua<'lua>,
         F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
     {
-        let (state, extra) = (self.state(), self.extra.get());
-        // It must be safe to drop `self` as in the module mode we keep strong reference to `Lua` in the registry
+        let extra = self.extra.get();
+        // `self` is no longer needed and must be dropped at this point to avoid possible memory leak
+        // in case of possible longjmp (lua_error) below
         drop(self);
 
         callback_error_ext(state, extra, move |nargs| {
             let lua: &Lua = mem::transmute((*extra).inner.assume_init_ref());
+            let _guard = StateGuard::new(&lua.0, state);
             let args = A::from_stack_args(nargs, 1, None, lua)?;
             func(lua, args)?.push_into_stack(lua)?;
             Ok(1)
@@ -745,12 +732,12 @@ impl Lua {
     // A simple module entrypoint without arguments
     #[doc(hidden)]
     #[cfg(not(tarpaulin_include))]
-    pub unsafe fn entrypoint1<'lua, R, F>(self, func: F) -> c_int
+    pub unsafe fn entrypoint1<'lua, R, F>(self, state: *mut ffi::lua_State, func: F) -> c_int
     where
         R: IntoLua<'lua>,
         F: Fn(&'lua Lua) -> Result<R> + MaybeSend + 'static,
     {
-        self.entrypoint(move |lua, _: ()| func(lua))
+        self.entrypoint(state, move |lua, _: ()| func(lua))
     }
 
     /// Skips memory checks for some operations.
@@ -1098,9 +1085,9 @@ impl Lua {
     /// Returns the amount of memory (in bytes) currently used inside this Lua state.
     pub fn used_memory(&self) -> usize {
         unsafe {
-            match (*self.extra.get()).mem_state.map(|x| x.as_ref()) {
-                Some(mem_state) => mem_state.used_memory(),
-                None => {
+            match MemoryState::get(self.main_state) {
+                mem_state if !mem_state.is_null() => (*mem_state).used_memory(),
+                _ => {
                     // Get data from the Lua GC
                     let used_kbytes = ffi::lua_gc(self.main_state, ffi::LUA_GCCOUNT, 0);
                     let used_kbytes_rem = ffi::lua_gc(self.main_state, ffi::LUA_GCCOUNTB, 0);
@@ -1119,9 +1106,9 @@ impl Lua {
     /// Does not work in module mode where Lua state is managed externally.
     pub fn set_memory_limit(&self, limit: usize) -> Result<usize> {
         unsafe {
-            match (*self.extra.get()).mem_state.map(|mut x| x.as_mut()) {
-                Some(mem_state) => Ok(mem_state.set_memory_limit(limit)),
-                None => Err(Error::MemoryLimitNotAvailable),
+            match MemoryState::get(self.main_state) {
+                mem_state if !mem_state.is_null() => Ok((*mem_state).set_memory_limit(limit)),
+                _ => Err(Error::MemoryLimitNotAvailable),
             }
         }
     }
@@ -1301,6 +1288,21 @@ impl Lua {
         unsafe { (*self.extra.get()).enable_jit = enable };
     }
 
+    /// Sets Luau feature flag (global setting).
+    ///
+    /// See https://github.com/luau-lang/luau/blob/master/CONTRIBUTING.md#feature-flags for details.
+    #[cfg(feature = "luau")]
+    #[doc(hidden)]
+    #[allow(clippy::result_unit_err)]
+    pub fn set_fflag(name: &str, enabled: bool) -> StdResult<(), ()> {
+        if let Ok(name) = CString::new(name) {
+            if unsafe { ffi::luau_setfflag(name.as_ptr(), enabled as c_int) != 0 } {
+                return Ok(());
+            }
+        }
+        Err(())
+    }
+
     /// Returns Lua source code as a `Chunk` builder type.
     ///
     /// In order to actually compile or run the resulting code, you must call [`Chunk::exec`] or
@@ -1386,6 +1388,27 @@ impl Lua {
         }
     }
 
+    /// Create and return a Luau [buffer] object from a byte slice of data.
+    ///
+    /// Requires `feature = "luau"`
+    ///
+    /// [buffer]: https://luau-lang.org/library#buffer-library
+    #[cfg(feature = "luau")]
+    pub fn create_buffer(&self, buf: impl AsRef<[u8]>) -> Result<AnyUserData> {
+        let state = self.state();
+        unsafe {
+            if self.unlikely_memory_error() {
+                crate::util::push_buffer(self.ref_thread(), buf.as_ref(), false)?;
+                return Ok(AnyUserData(self.pop_ref_thread(), SubtypeId::Buffer));
+            }
+
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
+            crate::util::push_buffer(state, buf.as_ref(), true)?;
+            Ok(AnyUserData(self.pop_ref(), SubtypeId::Buffer))
+        }
+    }
+
     /// Creates and returns a new empty table.
     pub fn create_table(&self) -> Result<Table> {
         self.create_table_with_capacity(0, 0)
@@ -1427,8 +1450,8 @@ impl Lua {
             let protect = !self.unlikely_memory_error();
             push_table(state, 0, lower_bound, protect)?;
             for (k, v) in iter {
-                self.push_value(k.into_lua(self)?)?;
-                self.push_value(v.into_lua(self)?)?;
+                self.push(k)?;
+                self.push(v)?;
                 if protect {
                     protect_lua!(state, 3, 1, fn(state) ffi::lua_rawset(state, -3))?;
                 } else {
@@ -1456,7 +1479,7 @@ impl Lua {
             let protect = !self.unlikely_memory_error();
             push_table(state, lower_bound, 0, protect)?;
             for (i, v) in iter.enumerate() {
-                self.push_value(v.into_lua(self)?)?;
+                self.push(v)?;
                 if protect {
                     protect_lua!(state, 2, 1, |state| {
                         ffi::lua_rawseti(state, -2, (i + 1) as Integer);
@@ -1738,6 +1761,21 @@ impl Lua {
         unsafe { self.make_any_userdata(UserDataCell::new(data)) }
     }
 
+    /// Creates a Lua userdata object from a custom serializable Rust type.
+    ///
+    /// See [`Lua::create_any_userdata()`] for more details.
+    ///
+    /// Requires `feature = "serialize"`
+    #[cfg(feature = "serialize")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+    #[inline]
+    pub fn create_ser_any_userdata<T>(&self, data: T) -> Result<AnyUserData>
+    where
+        T: Serialize + MaybeSend + 'static,
+    {
+        unsafe { self.make_any_userdata(UserDataCell::new_ser(data)) }
+    }
+
     /// Registers a custom Rust type in Lua to use in userdata objects.
     ///
     /// This methods provides a way to add fields or methods to userdata objects of a type `T`.
@@ -1991,12 +2029,11 @@ impl Lua {
         T: IntoLua<'lua>,
     {
         let state = self.state();
-        let t = t.into_lua(self)?;
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 5)?;
 
-            self.push_value(t)?;
+            self.push(t)?;
             rawset_field(state, ffi::LUA_REGISTRYINDEX, name)
         }
     }
@@ -2012,7 +2049,7 @@ impl Lua {
         T: FromLua<'lua>,
     {
         let state = self.state();
-        let value = unsafe {
+        unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 3)?;
 
@@ -2020,9 +2057,8 @@ impl Lua {
             push_string(state, name.as_bytes(), protect)?;
             ffi::lua_rawget(state, ffi::LUA_REGISTRYINDEX);
 
-            self.pop_value()
-        };
-        T::from_lua(value, self)
+            T::from_stack(-1, self)
+        }
     }
 
     /// Removes a named value in the Lua registry.
@@ -2045,22 +2081,21 @@ impl Lua {
     ///
     /// [`RegistryKey`]: crate::RegistryKey
     pub fn create_registry_value<'lua, T: IntoLua<'lua>>(&'lua self, t: T) -> Result<RegistryKey> {
-        let t = t.into_lua(self)?;
-        if t == Value::Nil {
-            // Special case to skip calling `luaL_ref` and use `LUA_REFNIL` instead
-            let unref_list = unsafe { (*self.extra.get()).registry_unref_list.clone() };
-            return Ok(RegistryKey::new(ffi::LUA_REFNIL, unref_list));
-        }
-
         let state = self.state();
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 4)?;
 
-            self.push_value(t)?;
+            self.push(t)?;
+
+            let unref_list = (*self.extra.get()).registry_unref_list.clone();
+
+            // Check if the value is nil (no need to store it in the registry)
+            if ffi::lua_isnil(state, -1) != 0 {
+                return Ok(RegistryKey::new(ffi::LUA_REFNIL, unref_list));
+            }
 
             // Try to reuse previously allocated slot
-            let unref_list = (*self.extra.get()).registry_unref_list.clone();
             let free_registry_id = mlua_expect!(unref_list.lock(), "unref list poisoned")
                 .as_mut()
                 .and_then(|x| x.pop());
@@ -2070,7 +2105,7 @@ impl Lua {
                 return Ok(RegistryKey::new(registry_id, unref_list));
             }
 
-            // Allocate a new RegistryKey
+            // Allocate a new RegistryKey slot
             let registry_id = if self.unlikely_memory_error() {
                 ffi::luaL_ref(state, ffi::LUA_REGISTRYINDEX)
             } else {
@@ -2094,18 +2129,16 @@ impl Lua {
         }
 
         let state = self.state();
-        let value = match key.is_nil() {
-            true => Value::Nil,
-            false => unsafe {
+        match key.id() {
+            ffi::LUA_REFNIL => T::from_lua(Value::Nil, self),
+            registry_id => unsafe {
                 let _sg = StackGuard::new(state);
                 check_stack(state, 1)?;
 
-                let id = key.registry_id as Integer;
-                ffi::lua_rawgeti(state, ffi::LUA_REGISTRYINDEX, id);
-                self.pop_value()
+                ffi::lua_rawgeti(state, ffi::LUA_REGISTRYINDEX, registry_id as Integer);
+                T::from_stack(-1, self)
             },
-        };
-        T::from_lua(value, self)
+        }
     }
 
     /// Removes a value from the Lua registry.
@@ -2143,29 +2176,32 @@ impl Lua {
         }
 
         let t = t.into_lua(self)?;
-        if t == Value::Nil && key.is_nil() {
-            // Nothing to replace
-            return Ok(());
-        } else if t != Value::Nil && key.registry_id == ffi::LUA_REFNIL {
-            // We cannot update `LUA_REFNIL` slot
-            return Err(Error::runtime("cannot replace nil value with non-nil"));
-        }
 
         let state = self.state();
         unsafe {
             let _sg = StackGuard::new(state);
             check_stack(state, 2)?;
 
-            let id = key.registry_id as Integer;
-            if t == Value::Nil {
-                self.push_value(Value::Integer(id))?;
-                key.set_nil(true);
-            } else {
-                self.push_value(t)?;
-                key.set_nil(false);
+            match (t, key.id()) {
+                (Value::Nil, ffi::LUA_REFNIL) => {
+                    // Do nothing, no need to replace nil with nil
+                }
+                (Value::Nil, registry_id) => {
+                    // Remove the value
+                    ffi::luaL_unref(state, ffi::LUA_REGISTRYINDEX, registry_id);
+                    key.set_id(ffi::LUA_REFNIL);
+                }
+                (value, ffi::LUA_REFNIL) => {
+                    // Allocate a new `RegistryKey`
+                    let new_key = self.create_registry_value(value)?;
+                    key.set_id(new_key.take());
+                }
+                (value, registry_id) => {
+                    // It must be safe to replace the value without triggering memory error
+                    self.push_value(value)?;
+                    ffi::lua_rawseti(state, ffi::LUA_REGISTRYINDEX, registry_id as Integer);
+                }
             }
-            // It must be safe to replace the value without triggering memory error
-            ffi::lua_rawseti(state, ffi::LUA_REGISTRYINDEX, id);
         }
         Ok(())
     }
@@ -2283,33 +2319,38 @@ impl Lua {
         extra.app_data.remove()
     }
 
-    /// Pushes a value onto the Lua stack.
+    /// Pushes a value that implements `IntoLua` onto the Lua stack.
+    ///
+    /// Uses 2 stack spaces, does not call checkstack.
+    #[doc(hidden)]
+    #[inline(always)]
+    pub unsafe fn push<'lua>(&'lua self, value: impl IntoLua<'lua>) -> Result<()> {
+        value.push_into_stack(self)
+    }
+
+    /// Pushes a `Value` onto the Lua stack.
     ///
     /// Uses 2 stack spaces, does not call checkstack.
     #[doc(hidden)]
     pub unsafe fn push_value(&self, value: Value) -> Result<()> {
+        if let Value::Error(err) = value {
+            let protect = !self.unlikely_memory_error();
+            return push_gc_userdata(self.state(), WrappedFailure::Error(err), protect);
+        }
+        self.push_value_ref(&value)
+    }
+
+    /// Pushes a `&Value` (by reference) onto the Lua stack.
+    ///
+    /// Similar to [`Lua::push_value`], uses 2 stack spaces, does not call checkstack.
+    pub(crate) unsafe fn push_value_ref(&self, value: &Value) -> Result<()> {
         let state = self.state();
         match value {
-            Value::Nil => {
-                ffi::lua_pushnil(state);
-            }
-
-            Value::Boolean(b) => {
-                ffi::lua_pushboolean(state, b as c_int);
-            }
-
-            Value::LightUserData(ud) => {
-                ffi::lua_pushlightuserdata(state, ud.0);
-            }
-
-            Value::Integer(i) => {
-                ffi::lua_pushinteger(state, i);
-            }
-
-            Value::Number(n) => {
-                ffi::lua_pushnumber(state, n);
-            }
-
+            Value::Nil => ffi::lua_pushnil(state),
+            Value::Boolean(b) => ffi::lua_pushboolean(state, *b as c_int),
+            Value::LightUserData(ud) => ffi::lua_pushlightuserdata(state, ud.0),
+            Value::Integer(i) => ffi::lua_pushinteger(state, *i),
+            Value::Number(n) => ffi::lua_pushnumber(state, *n),
             #[cfg(feature = "luau")]
             Value::Vector(v) => {
                 #[cfg(not(feature = "luau-vector4"))]
@@ -2317,33 +2358,16 @@ impl Lua {
                 #[cfg(feature = "luau-vector4")]
                 ffi::lua_pushvector(state, v.x(), v.y(), v.z(), v.w());
             }
-
-            Value::String(s) => {
-                self.push_ref(&s.0);
-            }
-
-            Value::Table(t) => {
-                self.push_ref(&t.0);
-            }
-
-            Value::Function(f) => {
-                self.push_ref(&f.0);
-            }
-
-            Value::Thread(t) => {
-                self.push_ref(&t.0);
-            }
-
-            Value::UserData(ud) => {
-                self.push_ref(&ud.0);
-            }
-
+            Value::String(s) => self.push_ref(&s.0),
+            Value::Table(t) => self.push_ref(&t.0),
+            Value::Function(f) => self.push_ref(&f.0),
+            Value::Thread(t) => self.push_ref(&t.0),
+            Value::UserData(ud) => self.push_ref(&ud.0),
             Value::Error(err) => {
                 let protect = !self.unlikely_memory_error();
-                push_gc_userdata(state, WrappedFailure::Error(err), protect)?;
+                push_gc_userdata(state, WrappedFailure::Error(err.clone()), protect)?;
             }
         }
-
         Ok(())
     }
 
@@ -2435,17 +2459,22 @@ impl Lua {
                         ffi::lua_pop(state, 1);
                         Nil
                     }
-                    _ => Value::UserData(AnyUserData(self.pop_ref())),
+                    _ => Value::UserData(AnyUserData(self.pop_ref(), SubtypeId::None)),
                 }
             }
 
             ffi::LUA_TTHREAD => Value::Thread(Thread::new(self.pop_ref())),
 
+            #[cfg(feature = "luau")]
+            ffi::LUA_TBUFFER => {
+                // Buffer is represented as a userdata type
+                Value::UserData(AnyUserData(self.pop_ref(), SubtypeId::Buffer))
+            }
+
             #[cfg(feature = "luajit")]
             ffi::LUA_TCDATA => {
-                ffi::lua_pop(state, 1);
-                // TODO: Fix this in a next major release
-                panic!("cdata objects cannot be handled by mlua yet");
+                // CDATA is represented as a userdata type
+                Value::UserData(AnyUserData(self.pop_ref(), SubtypeId::CData))
             }
 
             _ => mlua_panic!("LUA_TNONE in pop_value"),
@@ -2530,7 +2559,7 @@ impl Lua {
                     }
                     _ => {
                         ffi::lua_xpush(state, self.ref_thread(), idx);
-                        Value::UserData(AnyUserData(self.pop_ref_thread()))
+                        Value::UserData(AnyUserData(self.pop_ref_thread(), SubtypeId::None))
                     }
                 }
             }
@@ -2540,10 +2569,18 @@ impl Lua {
                 Value::Thread(Thread::new(self.pop_ref_thread()))
             }
 
+            #[cfg(feature = "luau")]
+            ffi::LUA_TBUFFER => {
+                // Buffer is represented as a userdata type
+                ffi::lua_xpush(state, self.ref_thread(), idx);
+                Value::UserData(AnyUserData(self.pop_ref_thread(), SubtypeId::Buffer))
+            }
+
             #[cfg(feature = "luajit")]
             ffi::LUA_TCDATA => {
-                // TODO: Fix this in a next major release
-                panic!("cdata objects cannot be handled by mlua yet");
+                // CData is represented as a userdata type
+                ffi::lua_xpush(state, self.ref_thread(), idx);
+                Value::UserData(AnyUserData(self.pop_ref_thread(), SubtypeId::CData))
             }
 
             _ => mlua_panic!("LUA_TNONE in pop_value"),
@@ -2559,6 +2596,15 @@ impl Lua {
         ffi::lua_xpush(self.ref_thread(), self.state(), lref.index);
     }
 
+    #[cfg(all(feature = "unstable", not(feature = "send")))]
+    pub(crate) unsafe fn push_owned_ref(&self, loref: &crate::types::LuaOwnedRef) {
+        assert!(
+            Arc::ptr_eq(&loref.inner, &self.0),
+            "Lua instance passed Value created from a different main Lua state"
+        );
+        ffi::lua_xpush(self.ref_thread(), self.state(), loref.index);
+    }
+
     // Pops the topmost element of the stack and stores a reference to it. This pins the object,
     // preventing garbage collection until the returned `LuaRef` is dropped.
     //
@@ -2611,6 +2657,16 @@ impl Lua {
         LuaRef::new(self, index)
     }
 
+    #[inline]
+    pub(crate) unsafe fn push_error_traceback(&self) {
+        let state = self.state();
+        #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+        ffi::lua_xpush(self.ref_thread(), state, ExtraData::ERROR_TRACEBACK_IDX);
+        // Lua 5.2+ support light C functions that does not require extra allocations
+        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+        ffi::lua_pushcfunction(state, error_traceback);
+    }
+
     unsafe fn register_userdata_metatable<'lua, T: 'static>(
         &'lua self,
         mut registry: UserDataRegistry<'lua, T>,
@@ -2625,12 +2681,12 @@ impl Lua {
         let metatable_nrec = metatable_nrec + registry.async_meta_methods.len();
         push_table(state, 0, metatable_nrec, true)?;
         for (k, m) in registry.meta_methods {
-            self.push_value(Value::Function(self.create_callback(m)?))?;
+            self.push(self.create_callback(m)?)?;
             rawset_field(state, -2, MetaMethod::validate(&k)?)?;
         }
         #[cfg(feature = "async")]
         for (k, m) in registry.async_meta_methods {
-            self.push_value(Value::Function(self.create_async_callback(m)?))?;
+            self.push(self.create_async_callback(m)?)?;
             rawset_field(state, -2, MetaMethod::validate(&k)?)?;
         }
         let mut has_name = false;
@@ -2667,6 +2723,7 @@ impl Lua {
                     rawset_field(state, metatable_index, "__index")?;
                 }
                 _ => {
+                    ffi::lua_pop(state, 1);
                     // Propagate fields to the field getters
                     for (k, f) in registry.fields {
                         registry.field_getters.push((k, f))
@@ -2680,7 +2737,7 @@ impl Lua {
         if field_getters_nrec > 0 {
             push_table(state, 0, field_getters_nrec, true)?;
             for (k, m) in registry.field_getters {
-                self.push_value(Value::Function(self.create_callback(m)?))?;
+                self.push(self.create_callback(m)?)?;
                 rawset_field(state, -2, &k)?;
             }
             field_getters_index = Some(ffi::lua_absindex(state, -1));
@@ -2692,7 +2749,7 @@ impl Lua {
         if field_setters_nrec > 0 {
             push_table(state, 0, field_setters_nrec, true)?;
             for (k, m) in registry.field_setters {
-                self.push_value(Value::Function(self.create_callback(m)?))?;
+                self.push(self.create_callback(m)?)?;
                 rawset_field(state, -2, &k)?;
             }
             field_setters_index = Some(ffi::lua_absindex(state, -1));
@@ -2715,12 +2772,12 @@ impl Lua {
                 }
             }
             for (k, m) in registry.methods {
-                self.push_value(Value::Function(self.create_callback(m)?))?;
+                self.push(self.create_callback(m)?)?;
                 rawset_field(state, -2, &k)?;
             }
             #[cfg(feature = "async")]
             for (k, m) in registry.async_methods {
-                self.push_value(Value::Function(self.create_async_callback(m)?))?;
+                self.push(self.create_async_callback(m)?)?;
                 rawset_field(state, -2, &k)?;
             }
             match index_type {
@@ -2953,11 +3010,14 @@ impl Lua {
                 let fut = &mut (*upvalue).data;
                 let mut ctx = Context::from_waker(lua.waker());
                 match fut.as_mut().poll(&mut ctx) {
-                    Poll::Pending => Ok(0),
+                    Poll::Pending => {
+                        ffi::lua_pushnil(state);
+                        ffi::lua_pushlightuserdata(state, Lua::poll_pending().0);
+                        Ok(2)
+                    }
                     Poll::Ready(nresults) => {
-                        let nresults = nresults?;
-                        match nresults {
-                            0..=2 => {
+                        match nresults? {
+                            nresults @ 0..=2 => {
                                 // Fast path for up to 2 results without creating a table
                                 ffi::lua_pushinteger(state, nresults as _);
                                 if nresults > 0 {
@@ -2965,10 +3025,10 @@ impl Lua {
                                 }
                                 Ok(nresults + 1)
                             }
-                            _ => {
+                            nresults => {
                                 let results = MultiValue::from_stack_multi(nresults, lua)?;
                                 ffi::lua_pushinteger(state, nresults as _);
-                                lua.push_value(Value::Table(lua.create_sequence_from(results)?))?;
+                                lua.push(lua.create_sequence_from(results)?)?;
                                 Ok(2)
                             }
                         }
@@ -3009,20 +3069,17 @@ impl Lua {
 
         let coroutine = self.globals().get::<_, Table>("coroutine")?;
 
-        let env = self.create_table_with_capacity(0, 4)?;
+        let env = self.create_table_with_capacity(0, 3)?;
         env.set("get_poll", get_poll)?;
+        // Cache `yield` function
         env.set("yield", coroutine.get::<_, Function>("yield")?)?;
         unsafe {
             env.set("unpack", self.create_c_function(unpack)?)?;
         }
-        env.set("pending", {
-            LightUserData(&ASYNC_POLL_PENDING as *const u8 as *mut c_void)
-        })?;
 
         self.load(
             r#"
             local poll = get_poll(...)
-            local pending, yield, unpack = pending, yield, unpack
             while true do
                 local nres, res, res2 = poll()
                 if nres ~= nil then
@@ -3036,7 +3093,7 @@ impl Lua {
                         return unpack(res, nres)
                     end
                 end
-                yield(pending)
+                yield(res) -- `res` is a "pending" value
             end
             "#,
         )
@@ -3058,6 +3115,14 @@ impl Lua {
         mem::replace(&mut (*self.extra.get()).waker, waker)
     }
 
+    /// Returns internal `Poll::Pending` constant used for executing async callbacks.
+    #[cfg(feature = "async")]
+    #[doc(hidden)]
+    #[inline]
+    pub fn poll_pending() -> LightUserData {
+        LightUserData(&ASYNC_POLL_PENDING as *const u8 as *mut c_void)
+    }
+
     pub(crate) unsafe fn make_userdata<T>(&self, data: UserDataCell<T>) -> Result<AnyUserData>
     where
         T: UserData + 'static,
@@ -3127,9 +3192,10 @@ impl Lua {
             ffi::lua_setuservalue(state, -2);
         }
 
-        Ok(AnyUserData(self.pop_ref()))
+        Ok(AnyUserData(self.pop_ref(), SubtypeId::None))
     }
 
+    // Luau version located in `luau/mod.rs`
     #[cfg(not(feature = "luau"))]
     fn disable_c_modules(&self) -> Result<()> {
         let package: Table = self.globals().get("package")?;
@@ -3168,16 +3234,13 @@ impl Lua {
     #[inline]
     pub(crate) unsafe fn unlikely_memory_error(&self) -> bool {
         // MemoryInfo is empty in module mode so we cannot predict memory limits
-        (*self.extra.get())
-            .mem_state
-            .map(|x| x.as_ref().memory_limit() == 0)
-            .unwrap_or_else(|| {
-                // Alternatively, check the special flag (only for module mode)
-                #[cfg(feature = "module")]
-                return (*self.extra.get()).skip_memory_check;
-                #[cfg(not(feature = "module"))]
-                return false;
-            })
+        match MemoryState::get(self.main_state) {
+            mem_state if !mem_state.is_null() => (*mem_state).memory_limit() == 0,
+            #[cfg(feature = "module")]
+            _ => (*self.extra.get()).skip_memory_check, // Check the special flag (only for module mode)
+            #[cfg(not(feature = "module"))]
+            _ => false,
+        }
     }
 
     #[cfg(feature = "unstable")]
@@ -3223,11 +3286,9 @@ impl LuaInner {
 }
 
 impl ExtraData {
-    #[cfg(feature = "luau")]
-    #[inline]
-    pub(crate) fn mem_state(&self) -> NonNull<MemoryState> {
-        self.mem_state.unwrap()
-    }
+    // Index of `error_traceback` function in auxiliary thread stack
+    #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+    const ERROR_TRACEBACK_IDX: c_int = 1;
 }
 
 struct StateGuard<'a>(&'a LuaInner, *mut ffi::lua_State);
@@ -3245,13 +3306,13 @@ impl<'a> Drop for StateGuard<'a> {
     }
 }
 
-#[cfg(feature = "luau")]
 unsafe fn extra_data(state: *mut ffi::lua_State) -> *mut ExtraData {
-    (*ffi::lua_callbacks(state)).userdata as *mut ExtraData
-}
+    #[cfg(feature = "luau")]
+    if cfg!(not(feature = "module")) {
+        // In the main app we can use `lua_callbacks` to access ExtraData
+        return (*ffi::lua_callbacks(state)).userdata as *mut _;
+    }
 
-#[cfg(not(feature = "luau"))]
-unsafe fn extra_data(state: *mut ffi::lua_State) -> *mut ExtraData {
     let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
     if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, extra_key) != ffi::LUA_TUSERDATA {
         // `ExtraData` can be null only when Lua state is foreign.
@@ -3264,6 +3325,23 @@ unsafe fn extra_data(state: *mut ffi::lua_State) -> *mut ExtraData {
     (*extra_ptr).get()
 }
 
+unsafe fn set_extra_data(
+    state: *mut ffi::lua_State,
+    extra: &Arc<UnsafeCell<ExtraData>>,
+) -> Result<()> {
+    #[cfg(feature = "luau")]
+    if cfg!(not(feature = "module")) {
+        (*ffi::lua_callbacks(state)).userdata = extra.get() as *mut _;
+        return Ok(());
+    }
+
+    push_gc_userdata(state, Arc::clone(extra), true)?;
+    protect_lua!(state, 1, 0, fn(state) {
+        let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, extra_key);
+    })
+}
+
 // Creates required entries in the metatable cache (see `util::METATABLE_CACHE`)
 pub(crate) fn init_metatable_cache(cache: &mut FxHashMap<TypeId, u8>) {
     cache.insert(TypeId::of::<Arc<UnsafeCell<ExtraData>>>(), 0);
@@ -3502,6 +3580,12 @@ unsafe fn load_from_std_lib(state: *mut ffi::lua_State, libs: StdLib) -> Result<
         }
     }
 
+    #[cfg(feature = "luau")]
+    if libs.contains(StdLib::BUFFER) {
+        requiref(state, ffi::LUA_BUFFERLIBNAME, ffi::luaopen_buffer, 1)?;
+        ffi::lua_pop(state, 1);
+    }
+
     if libs.contains(StdLib::MATH) {
         requiref(state, ffi::LUA_MATHLIBNAME, ffi::luaopen_math, 1)?;
         ffi::lua_pop(state, 1);
@@ -3517,6 +3601,11 @@ unsafe fn load_from_std_lib(state: *mut ffi::lua_State, libs: StdLib) -> Result<
         requiref(state, ffi::LUA_LOADLIBNAME, ffi::luaopen_package, 1)?;
         ffi::lua_pop(state, 1);
     }
+    #[cfg(feature = "luau")]
+    if libs.contains(StdLib::PACKAGE) {
+        let lua: &Lua = mem::transmute((*extra_data(state)).inner.assume_init_ref());
+        crate::luau::register_package_module(lua)?;
+    }
 
     #[cfg(feature = "luajit")]
     {

src/luau/mod.rs

@@ -1,25 +1,19 @@
 use std::ffi::CStr;
 use std::os::raw::{c_float, c_int};
-use std::string::String as StdString;
 
-use crate::chunk::ChunkMode;
-use crate::error::{Error, Result};
+use crate::error::Result;
 use crate::lua::Lua;
-use crate::table::Table;
-use crate::util::{check_stack, StackGuard};
-use crate::value::Value;
 
-// Since Luau has some missing standard function, we re-implement them here
+// Since Luau has some missing standard functions, we re-implement them here
 
 impl Lua {
-    pub(crate) unsafe fn prepare_luau_state(&self) -> Result<()> {
+    pub(crate) unsafe fn configure_luau(&self) -> Result<()> {
         let globals = self.globals();
 
         globals.raw_set(
             "collectgarbage",
             self.create_c_function(lua_collectgarbage)?,
         )?;
-        globals.raw_set("require", self.create_function(lua_require)?)?;
         globals.raw_set("vector", self.create_c_function(lua_vector)?)?;
 
         // Set `_VERSION` global to include version number
@@ -30,6 +24,11 @@ impl Lua {
 
         Ok(())
     }
+
+    pub(crate) fn disable_c_modules(&self) -> Result<()> {
+        package::disable_dylibs(self);
+        Ok(())
+    }
 }
 
 unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
@@ -69,58 +68,6 @@ unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_
     }
 }
 
-fn lua_require(lua: &Lua, name: Option<StdString>) -> Result<Value> {
-    let name = name.ok_or_else(|| Error::runtime("invalid module name"))?;
-
-    // Find module in the cache
-    let state = lua.state();
-    let loaded = unsafe {
-        let _sg = StackGuard::new(state);
-        check_stack(state, 2)?;
-        protect_lua!(state, 0, 1, fn(state) {
-            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED"));
-        })?;
-        Table(lua.pop_ref())
-    };
-    if let Some(v) = loaded.raw_get(name.clone())? {
-        return Ok(v);
-    }
-
-    // Load file from filesystem
-    let mut search_path = std::env::var("LUAU_PATH").unwrap_or_default();
-    if search_path.is_empty() {
-        search_path = "?.luau;?.lua".into();
-    }
-
-    let (mut source, mut source_name) = (None, String::new());
-    for path in search_path.split(';') {
-        let file_path = path.replacen('?', &name, 1);
-        if let Ok(buf) = std::fs::read(&file_path) {
-            source = Some(buf);
-            source_name = file_path;
-            break;
-        }
-    }
-    let source = source.ok_or_else(|| Error::runtime(format!("cannot find '{name}'")))?;
-
-    let value = lua
-        .load(&source)
-        .set_name(&format!("={source_name}"))
-        .set_mode(ChunkMode::Text)
-        .call::<_, Value>(())?;
-
-    // Save in the cache
-    loaded.raw_set(
-        name,
-        match value.clone() {
-            Value::Nil => Value::Boolean(true),
-            v => v,
-        },
-    )?;
-
-    Ok(value)
-}
-
 // Luau vector datatype constructor
 unsafe extern "C-unwind" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
     let x = ffi::luaL_checknumber(state, 1) as c_float;
@@ -135,3 +82,7 @@ unsafe extern "C-unwind" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
     ffi::lua_pushvector(state, x, y, z, w);
     1
 }
+
+pub(crate) use package::register_package_module;
+
+mod package;

src/luau/package.rs

@@ -0,0 +1,269 @@
+use std::ffi::CStr;
+use std::fmt::Write;
+use std::os::raw::c_int;
+use std::path::{PathBuf, MAIN_SEPARATOR_STR};
+use std::string::String as StdString;
+use std::{env, fs};
+
+use crate::chunk::ChunkMode;
+use crate::error::Result;
+use crate::lua::Lua;
+use crate::table::Table;
+use crate::types::RegistryKey;
+use crate::value::{IntoLua, Value};
+
+#[cfg(unix)]
+use {libloading::Library, rustc_hash::FxHashMap};
+
+//
+// Luau package module
+//
+
+#[cfg(unix)]
+const TARGET_MLUA_LUAU_ABI_VERSION: u32 = 1;
+
+#[cfg(all(unix, feature = "module"))]
+#[no_mangle]
+#[used]
+pub static MLUA_LUAU_ABI_VERSION: u32 = TARGET_MLUA_LUAU_ABI_VERSION;
+
+// We keep reference to the `package` table in registry under this key
+struct PackageKey(RegistryKey);
+
+// We keep reference to the loaded dylibs in application data
+#[cfg(unix)]
+struct LoadedDylibs(FxHashMap<PathBuf, Library>);
+
+#[cfg(unix)]
+impl std::ops::Deref for LoadedDylibs {
+    type Target = FxHashMap<PathBuf, Library>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[cfg(unix)]
+impl std::ops::DerefMut for LoadedDylibs {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+pub(crate) fn register_package_module(lua: &Lua) -> Result<()> {
+    // Create the package table and store it in app_data for later use (bypassing globals lookup)
+    let package = lua.create_table()?;
+    lua.set_app_data(PackageKey(lua.create_registry_value(package.clone())?));
+
+    // Set `package.path`
+    let mut search_path = env::var("LUAU_PATH")
+        .or_else(|_| env::var("LUA_PATH"))
+        .unwrap_or_default();
+    if search_path.is_empty() {
+        search_path = "?.luau;?.lua".to_string();
+    }
+    package.raw_set("path", search_path)?;
+
+    // Set `package.cpath`
+    #[cfg(unix)]
+    {
+        let mut search_cpath = env::var("LUAU_CPATH")
+            .or_else(|_| env::var("LUA_CPATH"))
+            .unwrap_or_default();
+        if search_cpath.is_empty() {
+            if cfg!(any(target_os = "macos", target_os = "ios")) {
+                search_cpath = "?.dylib".to_string();
+            } else {
+                search_cpath = "?.so".to_string();
+            }
+        }
+        package.raw_set("cpath", search_cpath)?;
+    }
+
+    // Set `package.loaded` (table with a list of loaded modules)
+    let loaded = lua.create_table()?;
+    package.raw_set("loaded", loaded.clone())?;
+    lua.set_named_registry_value("_LOADED", loaded)?;
+
+    // Set `package.loaders`
+    let loaders = lua.create_sequence_from([lua.create_function(lua_loader)?])?;
+    package.raw_set("loaders", loaders.clone())?;
+    #[cfg(unix)]
+    {
+        loaders.push(lua.create_function(dylib_loader)?)?;
+        lua.set_app_data(LoadedDylibs(FxHashMap::default()));
+    }
+    lua.set_named_registry_value("_LOADERS", loaders)?;
+
+    // Register the module and `require` function in globals
+    let globals = lua.globals();
+    globals.raw_set("package", package)?;
+    globals.raw_set("require", unsafe { lua.create_c_function(lua_require)? })?;
+
+    Ok(())
+}
+
+#[allow(unused_variables)]
+pub(crate) fn disable_dylibs(lua: &Lua) {
+    // Presence of `LoadedDylibs` in app data is used as a flag
+    // to check whether binary modules are enabled
+    #[cfg(unix)]
+    lua.remove_app_data::<LoadedDylibs>();
+}
+
+unsafe extern "C-unwind" fn lua_require(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_settop(state, 1);
+    let name = ffi::luaL_checkstring(state, 1);
+    ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED")); // _LOADED is at index 2
+    if ffi::lua_rawgetfield(state, 2, name) != ffi::LUA_TNIL {
+        return 1; // module is already loaded
+    }
+    ffi::lua_pop(state, 1); // remove nil
+
+    // load the module
+    let err_buf = ffi::lua_newuserdata_t::<StdString>(state);
+    err_buf.write(StdString::new());
+    ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADERS")); // _LOADERS is at index 3
+    for i in 1.. {
+        if ffi::lua_rawgeti(state, -1, i) == ffi::LUA_TNIL {
+            // no more loaders?
+            if (*err_buf).is_empty() {
+                ffi::luaL_error(state, cstr!("module '%s' not found"), name);
+            } else {
+                let bytes = (*err_buf).as_bytes();
+                let extra = ffi::lua_pushlstring(state, bytes.as_ptr() as *const _, bytes.len());
+                ffi::luaL_error(state, cstr!("module '%s' not found:%s"), name, extra);
+            }
+        }
+        ffi::lua_pushvalue(state, 1); // name arg
+        ffi::lua_call(state, 1, 2); // call loader
+        match ffi::lua_type(state, -2) {
+            ffi::LUA_TFUNCTION => break, // loader found
+            ffi::LUA_TSTRING => {
+                // error message
+                let msg = ffi::lua_tostring(state, -2);
+                let msg = CStr::from_ptr(msg).to_string_lossy();
+                _ = write!(&mut *err_buf, "\n\t{msg}");
+            }
+            _ => {}
+        }
+        ffi::lua_pop(state, 2); // remove both results
+    }
+    ffi::lua_pushvalue(state, 1); // name is 1st argument to module loader
+    ffi::lua_rotate(state, -2, 1); // loader data <-> name
+
+    // stack: ...; loader function; module name; loader data
+    ffi::lua_call(state, 2, 1);
+    // stack: ...; result from loader function
+    if ffi::lua_isnil(state, -1) != 0 {
+        ffi::lua_pop(state, 1);
+        ffi::lua_pushboolean(state, 1); // use true as result
+    }
+    ffi::lua_pushvalue(state, -1); // make copy of entrypoint result
+    ffi::lua_setfield(state, 2, name); /* _LOADED[name] = returned value */
+    1
+}
+
+/// Searches for the given `name` in the given `path`.
+///
+/// `path` is a string containing a sequence of templates separated by semicolons.
+fn package_searchpath(name: &str, search_path: &str, try_prefix: bool) -> Option<PathBuf> {
+    let mut names = vec![name.replace('.', MAIN_SEPARATOR_STR)];
+    if try_prefix && name.contains('.') {
+        let prefix = name.split_once('.').map(|(prefix, _)| prefix).unwrap();
+        names.push(prefix.to_string());
+    }
+    for path in search_path.split(';') {
+        for name in &names {
+            let file_path = PathBuf::from(path.replace('?', name));
+            if let Ok(true) = fs::metadata(&file_path).map(|m| m.is_file()) {
+                return Some(file_path);
+            }
+        }
+    }
+    None
+}
+
+//
+// Module loaders
+//
+
+/// Tries to load a lua (text) file
+fn lua_loader(lua: &Lua, modname: StdString) -> Result<Value> {
+    let package = {
+        let key = lua.app_data_ref::<PackageKey>().unwrap();
+        lua.registry_value::<Table>(&key.0)
+    }?;
+    let search_path = package.get::<_, StdString>("path").unwrap_or_default();
+
+    if let Some(file_path) = package_searchpath(&modname, &search_path, false) {
+        match fs::read(&file_path) {
+            Ok(buf) => {
+                return lua
+                    .load(&buf)
+                    .set_name(&format!("={}", file_path.display()))
+                    .set_mode(ChunkMode::Text)
+                    .into_function()
+                    .map(Value::Function);
+            }
+            Err(err) => {
+                return format!("cannot open '{}': {err}", file_path.display()).into_lua(lua);
+            }
+        }
+    }
+
+    Ok(Value::Nil)
+}
+
+/// Tries to load a dynamic library
+#[cfg(unix)]
+fn dylib_loader(lua: &Lua, modname: StdString) -> Result<Value> {
+    let package = {
+        let key = lua.app_data_ref::<PackageKey>().unwrap();
+        lua.registry_value::<Table>(&key.0)
+    }?;
+    let search_cpath = package.get::<_, StdString>("cpath").unwrap_or_default();
+
+    let find_symbol = |lib: &Library| unsafe {
+        if let Ok(entry) = lib.get::<ffi::lua_CFunction>(format!("luaopen_{modname}\0").as_bytes())
+        {
+            return lua.create_c_function(*entry).map(Value::Function);
+        }
+        // Try all in one mode
+        if let Ok(entry) = lib.get::<ffi::lua_CFunction>(
+            format!("luaopen_{}\0", modname.replace('.', "_")).as_bytes(),
+        ) {
+            return lua.create_c_function(*entry).map(Value::Function);
+        }
+        "cannot find module entrypoint".into_lua(lua)
+    };
+
+    if let Some(file_path) = package_searchpath(&modname, &search_cpath, true) {
+        let file_path = file_path.canonicalize()?;
+        // Load the library and check for symbol
+        unsafe {
+            let mut loaded_dylibs = match lua.app_data_mut::<LoadedDylibs>() {
+                Some(loaded_dylibs) => loaded_dylibs,
+                None => return "dynamic libraries are disabled in safe mode".into_lua(lua),
+            };
+            // Check if it's already loaded
+            if let Some(lib) = loaded_dylibs.get(&file_path) {
+                return find_symbol(lib);
+            }
+            if let Ok(lib) = Library::new(&file_path) {
+                // Check version
+                let mod_version = lib.get::<*const u32>(b"MLUA_LUAU_ABI_VERSION");
+                let mod_version = mod_version.map(|v| **v).unwrap_or_default();
+                if mod_version != TARGET_MLUA_LUAU_ABI_VERSION {
+                    let err = format!("wrong module ABI version (expected {TARGET_MLUA_LUAU_ABI_VERSION}, got {mod_version})");
+                    return err.into_lua(lua);
+                }
+                let symbol = find_symbol(&lib);
+                loaded_dylibs.insert(file_path, lib);
+                return symbol;
+            }
+        }
+    }
+
+    Ok(Value::Nil)
+}

src/memory.rs

@@ -2,11 +2,9 @@ use std::alloc::{self, Layout};
 use std::os::raw::c_void;
 use std::ptr;
 
-#[cfg(feature = "luau")]
-use crate::lua::ExtraData;
-
 pub(crate) static ALLOCATOR: ffi::lua_Alloc = allocator;
 
+#[repr(C)]
 #[derive(Default)]
 pub(crate) struct MemoryState {
     used_memory: isize,
@@ -20,6 +18,21 @@ pub(crate) struct MemoryState {
 }
 
 impl MemoryState {
+    #[inline]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        #[cfg(feature = "luau")]
+        {
+            ffi::lua_getallocf(state, &mut mem_state);
+            mlua_assert!(!mem_state.is_null(), "Luau state has no allocator userdata");
+        }
+        #[cfg(not(feature = "luau"))]
+        if ffi::lua_getallocf(state, &mut mem_state) != ALLOCATOR {
+            mem_state = ptr::null_mut();
+        }
+        mem_state as *mut MemoryState
+    }
+
     #[inline]
     pub(crate) fn used_memory(&self) -> usize {
         self.used_memory as usize
@@ -37,36 +50,21 @@ impl MemoryState {
         prev_limit as usize
     }
 
-    // This function is used primarily for calling `lua_pushcfunction` in lua5.1/jit
+    // This function is used primarily for calling `lua_pushcfunction` in lua5.1/jit/luau
     // to bypass the memory limit (if set).
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
+    #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
     #[inline]
     pub(crate) unsafe fn relax_limit_with(state: *mut ffi::lua_State, f: impl FnOnce()) {
-        let mut mem_state: *mut c_void = ptr::null_mut();
-        if ffi::lua_getallocf(state, &mut mem_state) == ALLOCATOR {
-            (*(mem_state as *mut MemoryState)).ignore_limit = true;
+        let mem_state = Self::get(state);
+        if !mem_state.is_null() {
+            (*mem_state).ignore_limit = true;
             f();
-            (*(mem_state as *mut MemoryState)).ignore_limit = false;
+            (*mem_state).ignore_limit = false;
         } else {
             f();
         }
     }
 
-    // Same as the above but for Luau
-    // It does not have `lua_getallocf` function, so instead we use `lua_callbacks`
-    #[cfg(feature = "luau")]
-    #[inline]
-    pub(crate) unsafe fn relax_limit_with(state: *mut ffi::lua_State, f: impl FnOnce()) {
-        let extra = (*ffi::lua_callbacks(state)).userdata as *mut ExtraData;
-        if extra.is_null() {
-            return f();
-        }
-        let mem_state = (*extra).mem_state();
-        (*mem_state.as_ptr()).ignore_limit = true;
-        f();
-        (*mem_state.as_ptr()).ignore_limit = false;
-    }
-
     // Does nothing apart from calling `f()`, we don't need to bypass any limits
     #[cfg(any(feature = "lua52", feature = "lua53", feature = "lua54"))]
     #[inline]
@@ -76,12 +74,9 @@ impl MemoryState {
 
     // Returns `true` if the memory limit was reached on the last memory operation
     #[cfg(feature = "luau")]
+    #[inline]
     pub(crate) unsafe fn limit_reached(state: *mut ffi::lua_State) -> bool {
-        let extra = (*ffi::lua_callbacks(state)).userdata as *mut ExtraData;
-        if extra.is_null() {
-            return false;
-        }
-        (*(*extra).mem_state().as_ptr()).limit_reached
+        (*Self::get(state)).limit_reached
     }
 }
 

src/multi.rs

@@ -1,4 +1,3 @@
-use std::iter::FromIterator;
 use std::ops::{Deref, DerefMut};
 use std::os::raw::c_int;
 use std::result::Result as StdResult;
@@ -23,6 +22,20 @@ impl<'lua, T: IntoLua<'lua>, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<
         }
         Ok(result)
     }
+
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
+        match self {
+            Ok(v) => v.push_into_stack(lua).map(|_| 1),
+            Err(e) => {
+                let state = lua.state();
+                check_stack(state, 3)?;
+                ffi::lua_pushnil(state);
+                e.push_into_stack(lua)?;
+                Ok(2)
+            }
+        }
+    }
 }
 
 impl<'lua, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<(), E> {
@@ -38,6 +51,20 @@ impl<'lua, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<(), E> {
             }
         }
     }
+
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
+        match self {
+            Ok(_) => Ok(0),
+            Err(e) => {
+                let state = lua.state();
+                check_stack(state, 3)?;
+                ffi::lua_pushnil(state);
+                e.push_into_stack(lua)?;
+                Ok(2)
+            }
+        }
+    }
 }
 
 impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for T {

src/scope.rs

@@ -10,7 +10,7 @@ use serde::Serialize;
 use crate::error::{Error, Result};
 use crate::function::Function;
 use crate::lua::Lua;
-use crate::types::{Callback, CallbackUpvalue, LuaRef, MaybeSend};
+use crate::types::{Callback, CallbackUpvalue, LuaRef, MaybeSend, SubtypeId};
 use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
 };
@@ -19,7 +19,7 @@ use crate::util::{
     self, assert_stack, check_stack, init_userdata_metatable, push_string, push_table,
     rawset_field, short_type_name, take_userdata, StackGuard,
 };
-use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti};
 
 #[cfg(feature = "lua54")]
 use crate::userdata::USER_VALUE_MAXSLOT;
@@ -405,7 +405,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             let meta_methods_nrec = registry.meta_methods.len() + registry.meta_fields.len() + 1;
             push_table(state, 0, meta_methods_nrec, true)?;
             for (k, m) in registry.meta_methods {
-                lua.push_value(Value::Function(wrap_method(self, ud_ptr, &k, m)?))?;
+                lua.push(wrap_method(self, ud_ptr, &k, m)?)?;
                 rawset_field(state, -2, MetaMethod::validate(&k)?)?;
             }
             let mut has_name = false;
@@ -434,6 +434,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                             push_table(state, 0, fields_nrec, true)?;
                         }
                         for (k, f) in registry.fields {
+                            #[rustfmt::skip]
                             let NonStaticMethod::Function(f) = f else { unreachable!() };
                             mlua_assert!(f(lua, 0)? == 1, "field function must return one value");
                             rawset_field(state, -2, &k)?;
@@ -454,7 +455,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             if field_getters_nrec > 0 {
                 push_table(state, 0, field_getters_nrec, true)?;
                 for (k, m) in registry.field_getters {
-                    lua.push_value(Value::Function(wrap_method(self, ud_ptr, &k, m)?))?;
+                    lua.push(wrap_method(self, ud_ptr, &k, m)?)?;
                     rawset_field(state, -2, &k)?;
                 }
                 field_getters_index = Some(ffi::lua_absindex(state, -1));
@@ -465,7 +466,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             if field_setters_nrec > 0 {
                 push_table(state, 0, field_setters_nrec, true)?;
                 for (k, m) in registry.field_setters {
-                    lua.push_value(Value::Function(wrap_method(self, ud_ptr, &k, m)?))?;
+                    lua.push(wrap_method(self, ud_ptr, &k, m)?)?;
                     rawset_field(state, -2, &k)?;
                 }
                 field_setters_index = Some(ffi::lua_absindex(state, -1));
@@ -477,7 +478,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                 // Create table used for methods lookup
                 push_table(state, 0, methods_nrec, true)?;
                 for (k, m) in registry.methods {
-                    lua.push_value(Value::Function(wrap_method(self, ud_ptr, &k, m)?))?;
+                    lua.push(wrap_method(self, ud_ptr, &k, m)?)?;
                     rawset_field(state, -2, &k)?;
                 }
                 methods_index = Some(ffi::lua_absindex(state, -1));
@@ -510,7 +511,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             #[cfg(not(feature = "luau"))]
             std::ptr::write(ud_ptr as _, UserDataCell::new(data));
             ffi::lua_setmetatable(state, -2);
-            let ud = AnyUserData(lua.pop_ref());
+            let ud = AnyUserData(lua.pop_ref(), SubtypeId::None);
             lua.register_raw_userdata_metatable(mt_ptr, None);
 
             #[cfg(any(feature = "lua51", feature = "luajit"))]

src/serde/de.rs

@@ -1,5 +1,4 @@
 use std::cell::RefCell;
-use std::convert::TryInto;
 use std::os::raw::c_void;
 use std::rc::Rc;
 use std::result::Result as StdResult;
@@ -134,9 +133,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             Value::Nil => visitor.visit_unit(),
             Value::Boolean(b) => visitor.visit_bool(b),
             #[allow(clippy::useless_conversion)]
-            Value::Integer(i) => {
-                visitor.visit_i64(i.try_into().expect("cannot convert lua_Integer to i64"))
-            }
+            Value::Integer(i) => visitor.visit_i64(i.into()),
             #[allow(clippy::useless_conversion)]
             Value::Number(n) => visitor.visit_f64(n.into()),
             #[cfg(feature = "luau")]
@@ -151,6 +148,14 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             Value::UserData(ud) if ud.is_serializable() => {
                 serde_userdata(ud, |value| value.deserialize_any(visitor))
             }
+            #[cfg(feature = "luau")]
+            Value::UserData(ud) if ud.1 == crate::types::SubtypeId::Buffer => unsafe {
+                let mut size = 0usize;
+                let buf = ffi::lua_tobuffer(ud.0.lua.ref_thread(), ud.0.index, &mut size);
+                mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+                let buf = std::slice::from_raw_parts(buf as *const u8, size);
+                visitor.visit_bytes(buf)
+            },
             Value::Function(_)
             | Value::Thread(_)
             | Value::UserData(_)
@@ -655,14 +660,14 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
 
 // Adds `ptr` to the `visited` map and removes on drop
 // Used to track recursive tables but allow to traverse same tables multiple times
-struct RecursionGuard {
+pub(crate) struct RecursionGuard {
     ptr: *const c_void,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
 impl RecursionGuard {
     #[inline]
-    fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
+    pub(crate) fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
         let visited = Rc::clone(visited);
         let ptr = table.to_pointer();
         visited.borrow_mut().insert(ptr);

src/serde/ser.rs

@@ -3,7 +3,6 @@ use serde::{ser, Serialize};
 use super::LuaSerdeExt;
 use crate::error::{Error, Result};
 use crate::lua::Lua;
-use crate::string::String;
 use crate::table::Table;
 use crate::value::{IntoLua, Value};
 
@@ -43,6 +42,12 @@ pub struct Options {
     /// [`null`]: crate::LuaSerdeExt::null
     /// [`Nil`]: crate::Value::Nil
     pub serialize_unit_to_null: bool,
+
+    /// If true, serialize `serde_json::Number` with arbitrary_precision to a Lua number.
+    /// Otherwise it will be serialized as an object (what serde does).
+    ///
+    /// Default: **false**
+    pub detect_serde_json_arbitrary_precision: bool,
 }
 
 impl Default for Options {
@@ -58,6 +63,7 @@ impl Options {
             set_array_metatable: true,
             serialize_none_to_null: true,
             serialize_unit_to_null: true,
+            detect_serde_json_arbitrary_precision: false,
         }
     }
 
@@ -87,6 +93,20 @@ impl Options {
         self.serialize_unit_to_null = enabled;
         self
     }
+
+    /// Sets [`detect_serde_json_arbitrary_precision`] option.
+    ///
+    /// This option is used to serialize `serde_json::Number` with arbitrary precision to a Lua number.
+    /// Otherwise it will be serialized as an object (what serde does).
+    ///
+    /// This option is disabled by default.
+    ///
+    /// [`detect_serde_json_arbitrary_precision`]: #structfield.detect_serde_json_arbitrary_precision
+    #[must_use]
+    pub const fn detect_serde_json_arbitrary_precision(mut self, enabled: bool) -> Self {
+        self.detect_serde_json_arbitrary_precision = enabled;
+        self
+    }
 }
 
 impl<'lua> Serializer<'lua> {
@@ -121,7 +141,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     type SerializeTupleStruct = SerializeSeq<'lua>;
     type SerializeTupleVariant = SerializeTupleVariant<'lua>;
     type SerializeMap = SerializeMap<'lua>;
-    type SerializeStruct = SerializeMap<'lua>;
+    type SerializeStruct = SerializeStruct<'lua>;
     type SerializeStructVariant = SerializeStructVariant<'lua>;
 
     #[inline]
@@ -266,7 +286,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         _len: usize,
     ) -> Result<Self::SerializeTupleVariant> {
         Ok(SerializeTupleVariant {
-            name: self.lua.create_string(variant)?,
+            variant,
             table: self.lua.create_table()?,
             options: self.options,
         })
@@ -282,8 +302,23 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
-        self.serialize_map(Some(len))
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+        if self.options.detect_serde_json_arbitrary_precision
+            && name == "$serde_json::private::Number"
+            && len == 1
+        {
+            return Ok(SerializeStruct {
+                lua: self.lua,
+                inner: None,
+                options: self.options,
+            });
+        }
+
+        Ok(SerializeStruct {
+            lua: self.lua,
+            inner: Some(Value::Table(self.lua.create_table_with_capacity(0, len)?)),
+            options: self.options,
+        })
     }
 
     #[inline]
@@ -295,7 +330,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         len: usize,
     ) -> Result<Self::SerializeStructVariant> {
         Ok(SerializeStructVariant {
-            name: self.lua.create_string(variant)?,
+            variant,
             table: self.lua.create_table_with_capacity(0, len)?,
             options: self.options,
         })
@@ -402,7 +437,7 @@ impl<'lua> ser::SerializeTupleStruct for SerializeSeq<'lua> {
 
 #[doc(hidden)]
 pub struct SerializeTupleVariant<'lua> {
-    name: String<'lua>,
+    variant: &'static str,
     table: Table<'lua>,
     options: Options,
 }
@@ -422,7 +457,7 @@ impl<'lua> ser::SerializeTupleVariant for SerializeTupleVariant<'lua> {
     fn end(self) -> Result<Value<'lua>> {
         let lua = self.table.0.lua;
         let table = lua.create_table()?;
-        table.raw_set(self.name, self.table)?;
+        table.raw_set(self.variant, self.table)?;
         Ok(Value::Table(table))
     }
 }
@@ -465,7 +500,14 @@ impl<'lua> ser::SerializeMap for SerializeMap<'lua> {
     }
 }
 
-impl<'lua> ser::SerializeStruct for SerializeMap<'lua> {
+#[doc(hidden)]
+pub struct SerializeStruct<'lua> {
+    lua: &'lua Lua,
+    inner: Option<Value<'lua>>,
+    options: Options,
+}
+
+impl<'lua> ser::SerializeStruct for SerializeStruct<'lua> {
     type Ok = Value<'lua>;
     type Error = Error;
 
@@ -473,18 +515,44 @@ impl<'lua> ser::SerializeStruct for SerializeMap<'lua> {
     where
         T: Serialize + ?Sized,
     {
-        ser::SerializeMap::serialize_key(self, key)?;
-        ser::SerializeMap::serialize_value(self, value)
+        match self.inner {
+            Some(Value::Table(ref table)) => {
+                table.raw_set(key, self.lua.to_value_with(value, self.options)?)?;
+            }
+            None if self.options.detect_serde_json_arbitrary_precision => {
+                // A special case for `serde_json::Number` with arbitrary precision.
+                assert_eq!(key, "$serde_json::private::Number");
+                self.inner = Some(self.lua.to_value_with(value, self.options)?);
+            }
+            _ => unreachable!(),
+        }
+        Ok(())
     }
 
     fn end(self) -> Result<Value<'lua>> {
-        ser::SerializeMap::end(self)
+        match self.inner {
+            Some(table @ Value::Table(_)) => Ok(table),
+            Some(value) if self.options.detect_serde_json_arbitrary_precision => {
+                let number_s = value.as_str().expect("not an arbitrary precision number");
+                if number_s.contains(['.', 'e', 'E']) {
+                    if let Ok(number) = number_s.parse().map(Value::Number) {
+                        return Ok(number);
+                    }
+                }
+                Ok(number_s
+                    .parse()
+                    .map(Value::Integer)
+                    .or_else(|_| number_s.parse().map(Value::Number))
+                    .unwrap_or(value))
+            }
+            _ => unreachable!(),
+        }
     }
 }
 
 #[doc(hidden)]
 pub struct SerializeStructVariant<'lua> {
-    name: String<'lua>,
+    variant: &'static str,
     table: Table<'lua>,
     options: Options,
 }
@@ -505,8 +573,8 @@ impl<'lua> ser::SerializeStructVariant for SerializeStructVariant<'lua> {
 
     fn end(self) -> Result<Value<'lua>> {
         let lua = self.table.0.lua;
-        let table = lua.create_table()?;
-        table.raw_set(self.name, self.table)?;
+        let table = lua.create_table_with_capacity(0, 1)?;
+        table.raw_set(self.variant, self.table)?;
         Ok(Value::Table(table))
     }
 }

src/stdlib.rs

@@ -1,5 +1,4 @@
 use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};
-use std::u32;
 
 /// Flags describing the set of lua standard libraries to load.
 #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
@@ -16,32 +15,44 @@ impl StdLib {
         feature = "luau"
     ))]
     pub const COROUTINE: StdLib = StdLib(1);
+
     /// [`table`](https://www.lua.org/manual/5.4/manual.html#6.6) library
     pub const TABLE: StdLib = StdLib(1 << 1);
+
     /// [`io`](https://www.lua.org/manual/5.4/manual.html#6.8) library
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub const IO: StdLib = StdLib(1 << 2);
+
     /// [`os`](https://www.lua.org/manual/5.4/manual.html#6.9) library
     pub const OS: StdLib = StdLib(1 << 3);
+
     /// [`string`](https://www.lua.org/manual/5.4/manual.html#6.4) library
     pub const STRING: StdLib = StdLib(1 << 4);
+
     /// [`utf8`](https://www.lua.org/manual/5.4/manual.html#6.5) library
     ///
     /// Requires `feature = "lua54/lua53/luau"`
     #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
     pub const UTF8: StdLib = StdLib(1 << 5);
+
     /// [`bit`](https://www.lua.org/manual/5.2/manual.html#6.7) library
     ///
     /// Requires `feature = "lua52/luajit/luau"`
     #[cfg(any(feature = "lua52", feature = "luajit", feature = "luau", doc))]
     pub const BIT: StdLib = StdLib(1 << 6);
+
     /// [`math`](https://www.lua.org/manual/5.4/manual.html#6.7) library
     pub const MATH: StdLib = StdLib(1 << 7);
+
     /// [`package`](https://www.lua.org/manual/5.4/manual.html#6.3) library
-    #[cfg(not(feature = "luau"))]
-    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub const PACKAGE: StdLib = StdLib(1 << 8);
+
+    /// [`buffer`](https://luau-lang.org/library#buffer-library) library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub const BUFFER: StdLib = StdLib(1 << 9);
+
     /// [`jit`](http://luajit.org/ext_jit.html) library
     ///
     /// Requires `feature = "luajit"`
@@ -55,6 +66,7 @@ impl StdLib {
     #[cfg(any(feature = "luajit", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
     pub const FFI: StdLib = StdLib(1 << 30);
+
     /// (**unsafe**) [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10) library
     pub const DEBUG: StdLib = StdLib(1 << 31);
 

src/string.rs

@@ -132,7 +132,7 @@ impl<'lua> String<'lua> {
         }
     }
 
-    /// Converts the string to a generic C pointer.
+    /// Converts this string to a generic C pointer.
     ///
     /// There is no way to convert the pointer back to its original value.
     ///

src/table.rs

@@ -591,7 +591,7 @@ impl<'lua> Table<'lua> {
         unsafe { ffi::lua_getreadonly(ref_thread, self.0.index) != 0 }
     }
 
-    /// Converts the table to a generic C pointer.
+    /// Converts this table to a generic C pointer.
     ///
     /// Different tables will give different pointers.
     /// There is no way to convert the pointer back to its original value.
@@ -651,6 +651,34 @@ impl<'lua> Table<'lua> {
         }
     }
 
+    /// Iterates over the pairs of the table, invoking the given closure on each pair.
+    ///
+    /// This method is similar to [`Table::pairs`], but optimized for performance.
+    /// It does not invoke the `__pairs` metamethod.
+    pub fn for_each<K, V>(&self, mut f: impl FnMut(K, V) -> Result<()>) -> Result<()>
+    where
+        K: FromLua<'lua>,
+        V: FromLua<'lua>,
+    {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 5)?;
+
+            lua.push_ref(&self.0);
+            ffi::lua_pushnil(state);
+            while ffi::lua_next(state, -2) != 0 {
+                let k = K::from_stack(-2, lua)?;
+                let v = V::from_stack(-1, lua)?;
+                f(k, v)?;
+                // Keep key for next iteration
+                ffi::lua_pop(state, 1);
+            }
+        }
+        Ok(())
+    }
+
     /// 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
@@ -692,8 +720,7 @@ impl<'lua> Table<'lua> {
     pub fn sequence_values<V: FromLua<'lua>>(self) -> TableSequence<'lua, V> {
         TableSequence {
             table: self.0,
-            index: Some(1),
-            len: None,
+            index: 1,
             _phantom: PhantomData,
         }
     }
@@ -705,22 +732,30 @@ impl<'lua> Table<'lua> {
     }
 
     #[cfg(feature = "serialize")]
-    pub(crate) fn sequence_values_by_len<V: FromLua<'lua>>(
-        self,
-        len: Option<usize>,
-    ) -> TableSequence<'lua, V> {
-        let len = len.unwrap_or_else(|| self.raw_len()) as Integer;
-        TableSequence {
-            table: self.0,
-            index: Some(1),
-            len: Some(len),
-            _phantom: PhantomData,
+    pub(crate) fn for_each_value<V>(&self, mut f: impl FnMut(V) -> Result<()>) -> Result<()>
+    where
+        V: FromLua<'lua>,
+    {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
+
+            lua.push_ref(&self.0);
+            let len = ffi::lua_rawlen(state, -1);
+            for i in 1..=len {
+                ffi::lua_rawgeti(state, -1, i as _);
+                f(V::from_stack(-1, lua)?)?;
+                ffi::lua_pop(state, 1);
+            }
         }
+        Ok(())
     }
 
     /// 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<()> {
+    #[doc(hidden)]
+    pub fn raw_seti<V: IntoLua<'lua>>(&self, idx: usize, value: V) -> Result<()> {
         #[cfg(feature = "luau")]
         self.check_readonly_write()?;
 
@@ -1054,47 +1089,76 @@ impl<'a, 'lua> Serialize for SerializableTable<'a, 'lua> {
     where
         S: Serializer,
     {
-        use crate::serde::de::{check_value_for_skip, MapPairs};
+        use crate::serde::de::{check_value_for_skip, MapPairs, RecursionGuard};
         use crate::value::SerializableValue;
 
+        let convert_result = |res: Result<()>, serialize_err: Option<S::Error>| match res {
+            Ok(v) => Ok(v),
+            Err(Error::SerializeError(_)) if serialize_err.is_some() => Err(serialize_err.unwrap()),
+            Err(Error::SerializeError(msg)) => Err(serde::ser::Error::custom(msg)),
+            Err(err) => Err(serde::ser::Error::custom(err.to_string())),
+        };
+
         let options = self.options;
         let visited = &self.visited;
-        visited.borrow_mut().insert(self.table.to_pointer());
+        let _guard = RecursionGuard::new(self.table, visited);
 
         // Array
         let len = self.table.raw_len();
         if len > 0 || self.table.is_array() {
             let mut seq = serializer.serialize_seq(Some(len))?;
-            for value in self.table.clone().sequence_values_by_len::<Value>(None) {
-                let value = &value.map_err(serde::ser::Error::custom)?;
-                let skip = check_value_for_skip(value, self.options, &self.visited)
-                    .map_err(serde::ser::Error::custom)?;
+            let mut serialize_err = None;
+            let res = self.table.for_each_value::<Value>(|value| {
+                let skip = check_value_for_skip(&value, self.options, visited)
+                    .map_err(|err| Error::SerializeError(err.to_string()))?;
                 if skip {
-                    continue;
+                    // continue iteration
+                    return Ok(());
                 }
-                seq.serialize_element(&SerializableValue::new(value, options, Some(visited)))?;
-            }
+                seq.serialize_element(&SerializableValue::new(&value, options, Some(visited)))
+                    .map_err(|err| {
+                        serialize_err = Some(err);
+                        Error::SerializeError(String::new())
+                    })
+            });
+            convert_result(res, serialize_err)?;
             return seq.end();
         }
 
         // HashMap
         let mut map = serializer.serialize_map(None)?;
-        let pairs = MapPairs::new(self.table.clone(), self.options.sort_keys)
-            .map_err(serde::ser::Error::custom)?;
-        for kv in pairs {
-            let (key, value) = kv.map_err(serde::ser::Error::custom)?;
-            let skip_key = check_value_for_skip(&key, self.options, &self.visited)
-                .map_err(serde::ser::Error::custom)?;
-            let skip_value = check_value_for_skip(&value, self.options, &self.visited)
-                .map_err(serde::ser::Error::custom)?;
+        let mut serialize_err = None;
+        let mut process_pair = |key, value| {
+            let skip_key = check_value_for_skip(&key, self.options, visited)
+                .map_err(|err| Error::SerializeError(err.to_string()))?;
+            let skip_value = check_value_for_skip(&value, self.options, visited)
+                .map_err(|err| Error::SerializeError(err.to_string()))?;
             if skip_key || skip_value {
-                continue;
+                // continue iteration
+                return Ok(());
             }
             map.serialize_entry(
                 &SerializableValue::new(&key, options, Some(visited)),
                 &SerializableValue::new(&value, options, Some(visited)),
-            )?;
-        }
+            )
+            .map_err(|err| {
+                serialize_err = Some(err);
+                Error::SerializeError(String::new())
+            })
+        };
+
+        let res = if !self.options.sort_keys {
+            // Fast track
+            self.table.for_each(process_pair)
+        } else {
+            MapPairs::new(self.table.clone(), self.options.sort_keys)
+                .map_err(serde::ser::Error::custom)?
+                .try_for_each(|kv| {
+                    let (key, value) = kv?;
+                    process_pair(key, value)
+                })
+        };
+        convert_result(res, serialize_err)?;
         map.end()
     }
 }
@@ -1129,16 +1193,15 @@ where
                 lua.push_ref(&self.table);
                 lua.push_value(prev_key)?;
 
-                let next = protect_lua!(state, 2, ffi::LUA_MULTRET, |state| {
-                    ffi::lua_next(state, -2)
-                })?;
-                if next != 0 {
-                    let value = lua.pop_value();
-                    let key = lua.pop_value();
+                // It must be safe to call `lua_next` unprotected as deleting a key from a table is
+                // a permitted operation.
+                // It fails only if the key is not found (never existed) which seems impossible scenario.
+                if ffi::lua_next(state, -2) != 0 {
+                    let key = lua.stack_value(-2);
                     Ok(Some((
                         key.clone(),
                         K::from_lua(key, lua)?,
-                        V::from_lua(value, lua)?,
+                        V::from_stack(-1, lua)?,
                     )))
                 } else {
                     Ok(None)
@@ -1165,9 +1228,9 @@ where
 ///
 /// [`Table::sequence_values`]: crate::Table::sequence_values
 pub struct TableSequence<'lua, V> {
+    // TODO: Use `&Table`
     table: LuaRef<'lua>,
-    index: Option<Integer>,
-    len: Option<Integer>,
+    index: Integer,
     _phantom: PhantomData<V>,
 }
 
@@ -1178,31 +1241,22 @@ where
     type Item = Result<V>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if let Some(index) = self.index.take() {
-            let lua = self.table.lua;
-            let state = lua.state();
-
-            let res = (|| unsafe {
-                let _sg = StackGuard::new(state);
-                check_stack(state, 1)?;
-
-                lua.push_ref(&self.table);
-                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()))),
-                }
-            })();
-
-            match res {
-                Ok(Some((index, r))) => {
-                    self.index = Some(index + 1);
-                    Some(V::from_lua(r, lua))
-                }
-                Ok(None) => None,
-                Err(err) => Some(Err(err)),
+        let lua = self.table.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            if let Err(err) = check_stack(state, 1) {
+                return Some(Err(err));
+            }
+
+            lua.push_ref(&self.table);
+            match ffi::lua_rawgeti(state, -1, self.index) {
+                ffi::LUA_TNIL => None,
+                _ => {
+                    self.index += 1;
+                    Some(V::from_stack(-1, lua))
+                }
             }
-        } else {
-            None
         }
     }
 }

src/thread.rs

@@ -1,4 +1,4 @@
-use std::os::raw::c_int;
+use std::os::raw::{c_int, c_void};
 
 use crate::error::{Error, Result};
 #[allow(unused)]
@@ -15,7 +15,7 @@ use crate::{
 
 #[cfg(feature = "async")]
 use {
-    crate::{lua::ASYNC_POLL_PENDING, value::MultiValue},
+    crate::value::MultiValue,
     futures_util::stream::Stream,
     std::{
         future::Future,
@@ -142,6 +142,10 @@ impl<'lua> Thread<'lua> {
         A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
+        if self.status() != ThreadStatus::Resumable {
+            return Err(Error::CoroutineInactive);
+        }
+
         let lua = self.0.lua;
         let state = lua.state();
         let thread_state = self.state();
@@ -165,10 +169,6 @@ impl<'lua> Thread<'lua> {
         let state = lua.state();
         let thread_state = self.state();
 
-        if self.status() != ThreadStatus::Resumable {
-            return Err(Error::CoroutineInactive);
-        }
-
         let nargs = args.push_into_stack_multi(lua)?;
         if nargs > 0 {
             check_stack(thread_state, nargs)?;
@@ -196,6 +196,10 @@ impl<'lua> Thread<'lua> {
     /// Gets the status of the thread.
     pub fn status(&self) -> ThreadStatus {
         let thread_state = self.state();
+        if thread_state == self.0.lua.state() {
+            // The coroutine is currently running
+            return ThreadStatus::Unresumable;
+        }
         unsafe {
             let status = ffi::lua_status(thread_state);
             if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
@@ -239,10 +243,13 @@ impl<'lua> Thread<'lua> {
     ///
     /// [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"))))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua54", feature = "luau"))))]
     pub fn reset(&self, func: crate::function::Function<'lua>) -> Result<()> {
         let lua = self.0.lua;
         let thread_state = self.state();
+        if thread_state == lua.state() {
+            return Err(Error::runtime("cannot reset a running thread"));
+        }
         unsafe {
             #[cfg(all(feature = "lua54", not(feature = "vendored")))]
             let status = ffi::lua_resetthread(thread_state);
@@ -375,6 +382,16 @@ impl<'lua> Thread<'lua> {
         }
     }
 
+    /// Converts this thread to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
+
     /// Convert this handle to owned version.
     #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
     #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
@@ -530,12 +547,7 @@ where
 #[cfg(feature = "async")]
 #[inline(always)]
 unsafe fn is_poll_pending(state: *mut ffi::lua_State) -> bool {
-    if ffi::lua_islightuserdata(state, -1) != 0 {
-        let stack_ptr = ffi::lua_touserdata(state, -1) as *const u8;
-        let pending_ptr = &ASYNC_POLL_PENDING as *const u8;
-        return std::ptr::eq(stack_ptr, pending_ptr);
-    }
-    false
+    ffi::lua_tolightuserdata(state, -1) == Lua::poll_pending().0
 }
 
 #[cfg(feature = "async")]

src/types.rs

@@ -4,7 +4,7 @@ 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::atomic::{AtomicI32, Ordering};
 use std::sync::{Arc, Mutex};
 use std::{fmt, mem, ptr};
 
@@ -29,6 +29,16 @@ pub type Integer = ffi::lua_Integer;
 /// Type of Lua floating point numbers.
 pub type Number = ffi::lua_Number;
 
+// Represents different subtypes wrapped to AnyUserData
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub(crate) enum SubtypeId {
+    None,
+    #[cfg(feature = "luau")]
+    Buffer,
+    #[cfg(feature = "luajit")]
+    CData,
+}
+
 /// A "light" userdata value. Equivalent to an unmanaged raw pointer.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub struct LightUserData(pub *mut c_void);
@@ -194,26 +204,25 @@ pub(crate) struct DestructedUserdata;
 /// [`AnyUserData::set_user_value`]: crate::AnyUserData::set_user_value
 /// [`AnyUserData::user_value`]: crate::AnyUserData::user_value
 pub struct RegistryKey {
-    pub(crate) registry_id: c_int,
-    pub(crate) is_nil: AtomicBool,
+    pub(crate) registry_id: AtomicI32,
     pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
 }
 
 impl fmt::Debug for RegistryKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "RegistryKey({})", self.registry_id)
+        write!(f, "RegistryKey({})", self.id())
     }
 }
 
 impl Hash for RegistryKey {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.registry_id.hash(state)
+        self.id().hash(state)
     }
 }
 
 impl PartialEq for RegistryKey {
     fn eq(&self, other: &RegistryKey) -> bool {
-        self.registry_id == other.registry_id && Arc::ptr_eq(&self.unref_list, &other.unref_list)
+        self.id() == other.id() && Arc::ptr_eq(&self.unref_list, &other.unref_list)
     }
 }
 
@@ -221,50 +230,47 @@ impl Eq for RegistryKey {}
 
 impl Drop for RegistryKey {
     fn drop(&mut self) {
+        let registry_id = self.id();
         // We don't need to collect nil slot
-        if self.registry_id > ffi::LUA_REFNIL {
+        if registry_id > ffi::LUA_REFNIL {
             let mut unref_list = mlua_expect!(self.unref_list.lock(), "unref list poisoned");
             if let Some(list) = unref_list.as_mut() {
-                list.push(self.registry_id);
+                list.push(registry_id);
             }
         }
     }
 }
 
 impl RegistryKey {
-    // Creates a new instance of `RegistryKey`
+    /// Creates a new instance of `RegistryKey`
     pub(crate) const fn new(id: c_int, unref_list: Arc<Mutex<Option<Vec<c_int>>>>) -> Self {
         RegistryKey {
-            registry_id: id,
-            is_nil: AtomicBool::new(id == ffi::LUA_REFNIL),
+            registry_id: AtomicI32::new(id),
             unref_list,
         }
     }
 
-    // Destroys the `RegistryKey` without adding to the unref list
-    pub(crate) fn take(self) -> c_int {
-        let registry_id = self.registry_id;
+    /// Returns the underlying Lua reference of this `RegistryKey`
+    #[inline(always)]
+    pub fn id(&self) -> c_int {
+        self.registry_id.load(Ordering::Relaxed)
+    }
+
+    /// Sets the unique Lua reference key of this `RegistryKey`
+    #[inline(always)]
+    pub(crate) fn set_id(&self, id: c_int) {
+        self.registry_id.store(id, Ordering::Relaxed);
+    }
+
+    /// Destroys the `RegistryKey` without adding to the unref list
+    pub(crate) fn take(self) -> i32 {
+        let registry_id = self.id();
         unsafe {
             ptr::read(&self.unref_list);
             mem::forget(self);
         }
         registry_id
     }
-
-    // Returns true if this `RegistryKey` holds a nil value
-    #[inline(always)]
-    pub(crate) fn is_nil(&self) -> bool {
-        self.is_nil.load(Ordering::Relaxed)
-    }
-
-    // Marks value of this `RegistryKey` as `Nil`
-    #[inline(always)]
-    pub(crate) fn set_nil(&self, enabled: bool) {
-        // We cannot replace previous value with nil in as this will break
-        // Lua mechanism to find free keys.
-        // Instead, we set a special flag to mark value as nil.
-        self.is_nil.store(enabled, Ordering::Relaxed);
-    }
 }
 
 pub(crate) struct LuaRef<'lua> {

src/userdata.rs

@@ -5,7 +5,7 @@ use std::fmt;
 use std::hash::Hash;
 use std::mem;
 use std::ops::{Deref, DerefMut};
-use std::os::raw::{c_char, c_int};
+use std::os::raw::{c_char, c_int, c_void};
 use std::string::String as StdString;
 
 #[cfg(feature = "async")]
@@ -22,7 +22,7 @@ use crate::function::Function;
 use crate::lua::Lua;
 use crate::string::String;
 use crate::table::{Table, TablePairs};
-use crate::types::{LuaRef, MaybeSend};
+use crate::types::{LuaRef, MaybeSend, SubtypeId};
 use crate::util::{check_stack, get_userdata, take_userdata, StackGuard};
 use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 use crate::UserDataRegistry;
@@ -54,8 +54,8 @@ pub enum MetaMethod {
     /// The unary minus (`-`) operator.
     Unm,
     /// The floor division (//) operator.
-    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
+    /// Requires `feature = "lua54/lua53/luau"`
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
     IDiv,
     /// The bitwise AND (&) operator.
     /// Requires `feature = "lua54/lua53"`
@@ -180,7 +180,7 @@ impl MetaMethod {
             MetaMethod::Pow => "__pow",
             MetaMethod::Unm => "__unm",
 
-            #[cfg(any(feature = "lua54", feature = "lua53"))]
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
             MetaMethod::IDiv => "__idiv",
             #[cfg(any(feature = "lua54", feature = "lua53"))]
             MetaMethod::BAnd => "__band",
@@ -580,12 +580,12 @@ pub trait UserDataFields<'lua, T> {
 /// # use mlua::{Lua, Result, UserData};
 /// # fn main() -> Result<()> {
 /// # let lua = Lua::new();
-/// struct MyUserData(i32);
+/// struct MyUserData;
 ///
 /// impl UserData for MyUserData {}
 ///
 /// // `MyUserData` now implements `IntoLua`:
-/// lua.globals().set("myobject", MyUserData(123))?;
+/// lua.globals().set("myobject", MyUserData)?;
 ///
 /// lua.load("assert(type(myobject) == 'userdata')").exec()?;
 /// # Ok(())
@@ -791,7 +791,7 @@ impl<T> Deref for UserDataVariant<T> {
 /// [`is`]: crate::AnyUserData::is
 /// [`borrow`]: crate::AnyUserData::borrow
 #[derive(Clone, Debug)]
-pub struct AnyUserData<'lua>(pub(crate) LuaRef<'lua>);
+pub struct AnyUserData<'lua>(pub(crate) LuaRef<'lua>, pub(crate) SubtypeId);
 
 /// Owned handle to an internal Lua userdata.
 ///
@@ -801,25 +801,21 @@ pub struct AnyUserData<'lua>(pub(crate) LuaRef<'lua>);
 #[cfg(feature = "unstable")]
 #[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
 #[derive(Clone, Debug)]
-pub struct OwnedAnyUserData(pub(crate) crate::types::LuaOwnedRef);
+pub struct OwnedAnyUserData(pub(crate) crate::types::LuaOwnedRef, pub(crate) SubtypeId);
 
 #[cfg(feature = "unstable")]
 impl OwnedAnyUserData {
     /// Get borrowed handle to the underlying Lua userdata.
     #[cfg_attr(feature = "send", allow(unused))]
     pub const fn to_ref(&self) -> AnyUserData {
-        AnyUserData(self.0.to_ref())
+        AnyUserData(self.0.to_ref(), self.1)
     }
 }
 
 impl<'lua> AnyUserData<'lua> {
     /// Checks whether the type of this userdata is `T`.
     pub fn is<T: 'static>(&self) -> bool {
-        match self.inspect(|_: &UserDataCell<T>| Ok(())) {
-            Ok(()) => true,
-            Err(Error::UserDataTypeMismatch) => false,
-            Err(_) => unreachable!(),
-        }
+        self.inspect(|_: &UserDataCell<T>| Ok(())).is_ok()
     }
 
     /// Borrow this userdata immutably if it is of type `T`.
@@ -919,7 +915,7 @@ impl<'lua> AnyUserData<'lua> {
             check_stack(state, 5)?;
 
             lua.push_userdata_ref(&self.0)?;
-            lua.push_value(v.into_lua(lua)?)?;
+            lua.push(v)?;
 
             #[cfg(feature = "lua54")]
             if n < USER_VALUE_MAXSLOT {
@@ -1014,7 +1010,7 @@ impl<'lua> AnyUserData<'lua> {
             check_stack(state, 5)?;
 
             lua.push_userdata_ref(&self.0)?;
-            lua.push_value(v.into_lua(lua)?)?;
+            lua.push(v)?;
 
             // Multiple (extra) user values are emulated by storing them in a table
             protect_lua!(state, 2, 0, |state| {
@@ -1096,12 +1092,22 @@ impl<'lua> AnyUserData<'lua> {
         }
     }
 
+    /// Converts this userdata to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
+
     /// Convert this handle to owned version.
     #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
     #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
     #[inline]
     pub fn into_owned(self) -> OwnedAnyUserData {
-        OwnedAnyUserData(self.0.into_owned())
+        OwnedAnyUserData(self.0.into_owned(), self.1)
     }
 
     #[cfg(feature = "async")]
@@ -1112,6 +1118,14 @@ impl<'lua> AnyUserData<'lua> {
 
     /// Returns a type name of this `UserData` (from a metatable field).
     pub(crate) fn type_name(&self) -> Result<Option<StdString>> {
+        match self.1 {
+            SubtypeId::None => {}
+            #[cfg(feature = "luau")]
+            SubtypeId::Buffer => return Ok(Some("buffer".to_owned())),
+            #[cfg(feature = "luajit")]
+            SubtypeId::CData => return Ok(Some("cdata".to_owned())),
+        }
+
         let lua = self.0.lua;
         let state = lua.state();
         unsafe {
@@ -1326,6 +1340,19 @@ impl<'lua> Serialize for AnyUserData<'lua> {
         S: Serializer,
     {
         let lua = self.0.lua;
+
+        // Special case for Luau buffer type
+        #[cfg(feature = "luau")]
+        if self.1 == SubtypeId::Buffer {
+            let buf = unsafe {
+                let mut size = 0usize;
+                let buf = ffi::lua_tobuffer(lua.ref_thread(), self.0.index, &mut size);
+                mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+                std::slice::from_raw_parts(buf as *const u8, size)
+            };
+            return serializer.serialize_bytes(buf);
+        }
+
         let data = unsafe {
             let _ = lua
                 .get_userdata_ref_type_id(&self.0)
@@ -1344,7 +1371,7 @@ impl<'lua> Serialize for AnyUserData<'lua> {
 /// A wrapper type for an immutably borrowed value from a `AnyUserData`.
 ///
 /// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
-pub struct UserDataRef<'lua, T: 'static>(AnyUserData<'lua>, Ref<'lua, T>);
+pub struct UserDataRef<'lua, T: 'static>(#[allow(unused)] AnyUserData<'lua>, Ref<'lua, T>);
 
 impl<'lua, T: 'static> Deref for UserDataRef<'lua, T> {
     type Target = T;
@@ -1366,7 +1393,7 @@ impl<'lua, T: 'static> UserDataRef<'lua, T> {
 /// A wrapper type for a mutably borrowed value from a `AnyUserData`.
 ///
 /// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
-pub struct UserDataRefMut<'lua, T: 'static>(AnyUserData<'lua>, RefMut<'lua, T>);
+pub struct UserDataRefMut<'lua, T: 'static>(#[allow(unused)] AnyUserData<'lua>, RefMut<'lua, T>);
 
 impl<'lua, T: 'static> Deref for UserDataRefMut<'lua, T> {
     type Target = T;

src/userdata_impl.rs

@@ -218,7 +218,7 @@ impl<'lua, T: 'static> UserDataRegistry<'lua, T> {
         MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>,
     {
-        let name = get_function_name::<T>(name);
+        let name = Arc::new(get_function_name::<T>(name));
         let method = Arc::new(method);
 
         Box::new(move |lua, mut args| unsafe {
@@ -312,7 +312,7 @@ impl<'lua, T: 'static> UserDataRegistry<'lua, T> {
         MR: Future<Output = Result<R>> + 's,
         R: IntoLuaMulti<'lua>,
     {
-        let name = get_function_name::<T>(name);
+        let name = Arc::new(get_function_name::<T>(name));
         let method = Arc::new(method);
 
         Box::new(move |lua, mut args| unsafe {

src/util/mod.rs

@@ -6,7 +6,7 @@ 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, str};
+use std::{ptr, slice, str};
 
 use once_cell::sync::Lazy;
 use rustc_hash::FxHashMap;
@@ -253,6 +253,20 @@ pub unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect: bool) -
     }
 }
 
+// Uses 3 stack spaces (when protect), does not call checkstack.
+#[cfg(feature = "luau")]
+#[inline(always)]
+pub unsafe fn push_buffer(state: *mut ffi::lua_State, b: &[u8], protect: bool) -> Result<()> {
+    let data = if protect {
+        protect_lua!(state, 0, 1, |state| ffi::lua_newbuffer(state, b.len()))?
+    } else {
+        ffi::lua_newbuffer(state, b.len())
+    };
+    let buf = slice::from_raw_parts_mut(data as *mut u8, b.len());
+    buf.copy_from_slice(b);
+    Ok(())
+}
+
 // Uses 3 stack spaces, does not call checkstack.
 #[inline]
 pub unsafe fn push_table(
@@ -282,38 +296,23 @@ pub unsafe fn rawset_field(state: *mut ffi::lua_State, table: c_int, field: &str
 }
 
 // Internally uses 3 stack spaces, does not call checkstack.
-#[cfg(not(feature = "luau"))]
 #[inline]
 pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
+    #[cfg(not(feature = "luau"))]
     let ud = if protect {
         protect_lua!(state, 0, 1, |state| {
-            ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
+            ffi::lua_newuserdata(state, std::mem::size_of::<T>()) as *mut T
         })?
     } else {
-        ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
+        ffi::lua_newuserdata(state, std::mem::size_of::<T>()) as *mut T
     };
-    ptr::write(ud, t);
-    Ok(())
-}
-
-// Internally uses 3 stack spaces, does not call checkstack.
-#[cfg(feature = "luau")]
-#[inline]
-pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
-    unsafe extern "C-unwind" fn destructor<T>(ud: *mut c_void) {
-        ptr::drop_in_place(ud as *mut T);
-    }
-
-    let size = mem::size_of::<T>();
+    #[cfg(feature = "luau")]
     let ud = if protect {
-        protect_lua!(state, 0, 1, |state| {
-            ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
-        })?
+        protect_lua!(state, 0, 1, |state| { ffi::lua_newuserdata_t::<T>(state) })?
     } else {
-        ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
+        ffi::lua_newuserdata_t::<T>(state)
     };
     ptr::write(ud, t);
-
     Ok(())
 }
 
@@ -328,10 +327,10 @@ pub unsafe fn push_userdata_uv<T>(
 ) -> Result<()> {
     let ud = if protect {
         protect_lua!(state, 0, 1, |state| {
-            ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
+            ffi::lua_newuserdatauv(state, std::mem::size_of::<T>(), nuvalue) as *mut T
         })?
     } else {
-        ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
+        ffi::lua_newuserdatauv(state, std::mem::size_of::<T>(), nuvalue) as *mut T
     };
     ptr::write(ud, t);
     Ok(())
@@ -943,7 +942,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         "__mod",
         "__pow",
         "__unm",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
         "__idiv",
         #[cfg(any(feature = "lua54", feature = "lua53"))]
         "__band",
@@ -1009,16 +1008,10 @@ pub(crate) enum WrappedFailure {
 
 impl WrappedFailure {
     pub(crate) unsafe fn new_userdata(state: *mut ffi::lua_State) -> *mut Self {
-        let size = mem::size_of::<WrappedFailure>();
         #[cfg(feature = "luau")]
-        let ud = {
-            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
-        };
+        let ud = ffi::lua_newuserdata_t::<Self>(state);
         #[cfg(not(feature = "luau"))]
-        let ud = ffi::lua_newuserdata(state, size) as *mut Self;
+        let ud = ffi::lua_newuserdata(state, std::mem::size_of::<Self>()) as *mut Self;
         ptr::write(ud, WrappedFailure::None);
         ud
     }
@@ -1064,6 +1057,10 @@ pub(crate) unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> Stri
         ffi::LUA_TFUNCTION => format!("<function {:?}>", ffi::lua_topointer(state, index)),
         ffi::LUA_TUSERDATA => format!("<userdata {:?}>", ffi::lua_topointer(state, index)),
         ffi::LUA_TTHREAD => format!("<thread {:?}>", ffi::lua_topointer(state, index)),
+        #[cfg(feature = "luau")]
+        ffi::LUA_TBUFFER => format!("<buffer {:?}>", ffi::lua_topointer(state, index)),
+        #[cfg(feature = "luajit")]
+        ffi::LUA_TCDATA => format!("<cdata {:?}>", ffi::lua_topointer(state, index)),
         _ => "<unknown>".to_string(),
     }
 }

src/value.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::HashSet;
-use std::iter::{self, FromIterator};
+use std::iter;
 use std::ops::Index;
 use std::os::raw::{c_int, c_void};
 use std::string::String as StdString;
@@ -15,7 +15,7 @@ use {
     crate::table::SerializableTable,
     rustc_hash::FxHashSet,
     serde::ser::{self, Serialize, Serializer},
-    std::{cell::RefCell, convert::TryInto, rc::Rc, result::Result as StdResult},
+    std::{cell::RefCell, rc::Rc, result::Result as StdResult},
 };
 
 use crate::error::{Error, Result};
@@ -24,7 +24,7 @@ use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
-use crate::types::{Integer, LightUserData, Number};
+use crate::types::{Integer, LightUserData, Number, SubtypeId};
 use crate::userdata::AnyUserData;
 use crate::util::{check_stack, StackGuard};
 
@@ -88,7 +88,11 @@ impl<'lua> Value<'lua> {
             Value::Table(_) => "table",
             Value::Function(_) => "function",
             Value::Thread(_) => "thread",
-            Value::UserData(_) => "userdata",
+            Value::UserData(AnyUserData(_, SubtypeId::None)) => "userdata",
+            #[cfg(feature = "luau")]
+            Value::UserData(AnyUserData(_, SubtypeId::Buffer)) => "buffer",
+            #[cfg(feature = "luajit")]
+            Value::UserData(AnyUserData(_, SubtypeId::CData)) => "cdata",
             Value::Error(_) => "error",
         }
     }
@@ -126,7 +130,7 @@ impl<'lua> Value<'lua> {
             | Value::Table(Table(r))
             | Value::Function(Function(r))
             | Value::Thread(Thread(r, ..))
-            | Value::UserData(AnyUserData(r)) => r.to_pointer(),
+            | Value::UserData(AnyUserData(r, ..)) => r.to_pointer(),
             _ => ptr::null(),
         }
     }
@@ -148,7 +152,7 @@ impl<'lua> Value<'lua> {
             Value::Table(Table(r))
             | Value::Function(Function(r))
             | Value::Thread(Thread(r, ..))
-            | Value::UserData(AnyUserData(r)) => unsafe {
+            | Value::UserData(AnyUserData(r, ..)) => unsafe {
                 let state = r.lua.state();
                 let _guard = StackGuard::new(state);
                 check_stack(state, 3)?;
@@ -248,8 +252,7 @@ impl<'lua> Value<'lua> {
     /// If the value is a Lua [`Integer`], try to convert it to `i64` or return `None` otherwise.
     #[inline]
     pub fn as_i64(&self) -> Option<i64> {
-        #[allow(clippy::useless_conversion)]
-        self.as_integer().and_then(|i| i64::try_from(i).ok())
+        self.as_integer().map(i64::from)
     }
 
     /// Cast the value to `u64`.
@@ -410,6 +413,28 @@ impl<'lua> Value<'lua> {
         }
     }
 
+    /// Returns `true` if the value is a Buffer wrapped in [`AnyUserData`].
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    #[doc(hidden)]
+    #[inline]
+    pub fn is_buffer(&self) -> bool {
+        self.as_userdata()
+            .map(|ud| ud.1 == SubtypeId::Buffer)
+            .unwrap_or_default()
+    }
+
+    /// Returns `true` if the value is a CData wrapped in [`AnyUserData`].
+    #[cfg(any(feature = "luajit", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
+    #[doc(hidden)]
+    #[inline]
+    pub fn is_cdata(&self) -> bool {
+        self.as_userdata()
+            .map(|ud| ud.1 == SubtypeId::CData)
+            .unwrap_or_default()
+    }
+
     /// Wrap reference to this Value into [`SerializableValue`].
     ///
     /// This allows customizing serialization behavior using serde.
@@ -633,8 +658,7 @@ impl<'a, 'lua> Serialize for SerializableValue<'a, 'lua> {
             Value::Nil => serializer.serialize_unit(),
             Value::Boolean(b) => serializer.serialize_bool(*b),
             #[allow(clippy::useless_conversion)]
-            Value::Integer(i) => serializer
-                .serialize_i64((*i).try_into().expect("cannot convert Lua Integer to i64")),
+            Value::Integer(i) => serializer.serialize_i64((*i).into()),
             Value::Number(n) => serializer.serialize_f64(*n),
             #[cfg(feature = "luau")]
             Value::Vector(v) => v.serialize(serializer),

tests/async.rs

@@ -10,10 +10,17 @@ use mlua::{
     UserData, UserDataMethods, Value,
 };
 
+#[cfg(not(target_arch = "wasm32"))]
 async fn sleep_ms(ms: u64) {
     tokio::time::sleep(Duration::from_millis(ms)).await;
 }
 
+#[cfg(target_arch = "wasm32")]
+async fn sleep_ms(_ms: u64) {
+    // I was unable to make sleep() work in wasm32-emscripten target
+    tokio::task::yield_now().await;
+}
+
 #[tokio::test]
 async fn test_async_function() -> Result<()> {
     let lua = Lua::new();
@@ -436,7 +443,7 @@ async fn test_async_userdata() -> Result<()> {
     let globals = lua.globals();
 
     let userdata = lua.create_userdata(MyUserData(11))?;
-    globals.set("userdata", userdata.clone())?;
+    globals.set("userdata", &userdata)?;
 
     lua.load(
         r#"

tests/chunk.rs

@@ -7,6 +7,12 @@ use mlua::{Lua, Result};
 fn test_chunk_path() -> Result<()> {
     let lua = Lua::new();
 
+    if cfg!(target_arch = "wasm32") {
+        // TODO: figure out why emscripten fails on file operations
+        // Also see https://github.com/rust-lang/rust/issues/119250
+        return Ok(());
+    }
+
     let temp_dir = tempfile::tempdir().unwrap();
     fs::write(
         temp_dir.path().join("module.lua"),

tests/compile/async_any_userdata_method.stderr

@@ -4,7 +4,7 @@ error: lifetime may not live long enough
 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`
+   | |                                   |                    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(())
@@ -27,6 +27,8 @@ error[E0596]: cannot borrow `s` as mutable, as it is a captured variable in a `F
 error[E0597]: `s` does not live long enough
   --> tests/compile/async_any_userdata_method.rs:8:21
    |
+7  |           let s = String::new();
+   |               - binding `s` declared here
 8  |           let mut s = &s;
    |                       ^^ borrowed value does not live long enough
 9  | /         reg.add_async_method("t", |_, this: &String, ()| async {

tests/compile/lua_norefunwindsafe.stderr

@@ -7,14 +7,46 @@ error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior m
   |     required by a bound introduced by this call
   |
   = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
-  = note: required because it appears within the type `ArcInner<UnsafeCell<ExtraData>>`
-  = note: required because it appears within the type `PhantomData<ArcInner<UnsafeCell<ExtraData>>>`
-  = note: required because it appears within the type `Arc<UnsafeCell<ExtraData>>`
-  = note: required because it appears within the type `LuaInner`
-  = note: required because it appears within the type `ArcInner<LuaInner>`
-  = note: required because it appears within the type `PhantomData<ArcInner<LuaInner>>`
-  = note: required because it appears within the type `Arc<LuaInner>`
-  = note: required because it appears within the type `Lua`
+note: required because it appears within the type `ArcInner<UnsafeCell<ExtraData>>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | struct ArcInner<T: ?Sized> {
+  |        ^^^^^^^^
+note: required because it appears within the type `PhantomData<ArcInner<UnsafeCell<ExtraData>>>`
+ --> $RUST/core/src/marker.rs
+  |
+  | pub struct PhantomData<T: ?Sized>;
+  |            ^^^^^^^^^^^
+note: required because it appears within the type `Arc<UnsafeCell<ExtraData>>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | pub struct Arc<
+  |            ^^^
+note: required because it appears within the type `LuaInner`
+ --> src/lua.rs
+  |
+  | pub struct LuaInner {
+  |            ^^^^^^^^
+note: required because it appears within the type `ArcInner<LuaInner>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | struct ArcInner<T: ?Sized> {
+  |        ^^^^^^^^
+note: required because it appears within the type `PhantomData<ArcInner<LuaInner>>`
+ --> $RUST/core/src/marker.rs
+  |
+  | pub struct PhantomData<T: ?Sized>;
+  |            ^^^^^^^^^^^
+note: required because it appears within the type `Arc<LuaInner>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | pub struct Arc<
+  |            ^^^
+note: required because it appears within the type `Lua`
+ --> src/lua.rs
+  |
+  | pub struct Lua(Arc<LuaInner>);
+  |            ^^^
   = note: required for `&Lua` to implement `UnwindSafe`
 note: required because it's used within this closure
  --> tests/compile/lua_norefunwindsafe.rs:7:18

tests/compile/non_send.stderr

@@ -4,22 +4,25 @@ error[E0277]: `Rc<Cell<i32>>` cannot be sent between threads safely
 11 |       lua.create_function(move |_, ()| {
    |           --------------- ^-----------
    |           |               |
-   |  _________|_______________within this `[closure@$DIR/tests/compile/non_send.rs:11:25: 11:37]`
+   |  _________|_______________within this `{closure@$DIR/tests/compile/non_send.rs:11:25: 11:37}`
    | |         |
    | |         required by a bound introduced by this call
 12 | |         Ok(data.get())
 13 | |     })?
    | |_____^ `Rc<Cell<i32>>` cannot be sent between threads safely
    |
-   = help: within `[closure@$DIR/tests/compile/non_send.rs:11:25: 11:37]`, the trait `Send` is not implemented for `Rc<Cell<i32>>`
+   = help: within `{closure@$DIR/tests/compile/non_send.rs:11:25: 11:37}`, the trait `Send` is not implemented for `Rc<Cell<i32>>`
 note: required because it's used within this closure
   --> tests/compile/non_send.rs:11:25
    |
 11 |     lua.create_function(move |_, ()| {
    |                         ^^^^^^^^^^^^
-   = note: required for `[closure@$DIR/tests/compile/non_send.rs:11:25: 11:37]` to implement `mlua::types::MaybeSend`
+   = note: required for `{closure@$DIR/tests/compile/non_send.rs:11:25: 11:37}` to implement `mlua::types::MaybeSend`
 note: required by a bound in `Lua::create_function`
   --> src/lua.rs
    |
+   |     pub fn create_function<'lua, A, R, F>(&'lua self, func: F) -> Result<Function<'lua>>
+   |            --------------- required by a bound in this associated function
+...
    |         F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
    |                                            ^^^^^^^^^ required by this bound in `Lua::create_function`

tests/compile/ref_nounwindsafe.stderr

@@ -7,17 +7,57 @@ error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior m
   |     required by a bound introduced by this call
   |
   = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
-  = note: required because it appears within the type `ArcInner<UnsafeCell<ExtraData>>`
-  = note: required because it appears within the type `PhantomData<ArcInner<UnsafeCell<ExtraData>>>`
-  = note: required because it appears within the type `Arc<UnsafeCell<ExtraData>>`
-  = note: required because it appears within the type `LuaInner`
-  = note: required because it appears within the type `ArcInner<LuaInner>`
-  = note: required because it appears within the type `PhantomData<ArcInner<LuaInner>>`
-  = note: required because it appears within the type `Arc<LuaInner>`
-  = note: required because it appears within the type `Lua`
+note: required because it appears within the type `ArcInner<UnsafeCell<ExtraData>>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | struct ArcInner<T: ?Sized> {
+  |        ^^^^^^^^
+note: required because it appears within the type `PhantomData<ArcInner<UnsafeCell<ExtraData>>>`
+ --> $RUST/core/src/marker.rs
+  |
+  | pub struct PhantomData<T: ?Sized>;
+  |            ^^^^^^^^^^^
+note: required because it appears within the type `Arc<UnsafeCell<ExtraData>>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | pub struct Arc<
+  |            ^^^
+note: required because it appears within the type `LuaInner`
+ --> src/lua.rs
+  |
+  | pub struct LuaInner {
+  |            ^^^^^^^^
+note: required because it appears within the type `ArcInner<LuaInner>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | struct ArcInner<T: ?Sized> {
+  |        ^^^^^^^^
+note: required because it appears within the type `PhantomData<ArcInner<LuaInner>>`
+ --> $RUST/core/src/marker.rs
+  |
+  | pub struct PhantomData<T: ?Sized>;
+  |            ^^^^^^^^^^^
+note: required because it appears within the type `Arc<LuaInner>`
+ --> $RUST/alloc/src/sync.rs
+  |
+  | pub struct Arc<
+  |            ^^^
+note: required because it appears within the type `Lua`
+ --> src/lua.rs
+  |
+  | pub struct Lua(Arc<LuaInner>);
+  |            ^^^
   = note: required for `&Lua` to implement `UnwindSafe`
-  = note: required because it appears within the type `LuaRef<'_>`
-  = note: required because it appears within the type `Table<'_>`
+note: required because it appears within the type `LuaRef<'_>`
+ --> src/types.rs
+  |
+  | pub(crate) struct LuaRef<'lua> {
+  |                   ^^^^^^
+note: required because it appears within the type `Table<'_>`
+ --> src/table.rs
+  |
+  | pub struct Table<'lua>(pub(crate) LuaRef<'lua>);
+  |            ^^^^^
 note: required because it's used within this closure
  --> tests/compile/ref_nounwindsafe.rs:8:18
   |

tests/compile/scope_userdata_borrow.stderr

@@ -4,6 +4,8 @@ error[E0597]: `ibad` does not live long enough
 11 |     lua.scope(|scope| {
    |                ----- has type `&mlua::Scope<'_, '1>`
 ...
+14 |             let ibad = 42;
+   |                 ---- binding `ibad` declared here
 15 |             scope.create_nonstatic_userdata(MyUserData(&ibad)).unwrap();
    |             -------------------------------------------^^^^^--
    |             |                                          |

tests/compile/static_callback_args.stderr

@@ -1,35 +1,31 @@
 error[E0597]: `lua` does not live long enough
   --> tests/compile/static_callback_args.rs:12:5
    |
-10 |        let lua = Lua::new();
-   |            --- binding `lua` declared here
+10 |       let lua = Lua::new();
+   |           --- binding `lua` declared here
 11 |
-12 | /      lua.create_function(|_, table: Table| {
-13 | |/         BAD_TIME.with(|bt| {
-14 | ||             *bt.borrow_mut() = Some(table);
-15 | ||         });
-   | ||__________- argument requires that `lua` is borrowed for `'static`
-16 | |          Ok(())
-17 | |      })?
-   | |_______^ borrowed value does not live long enough
+12 |       lua.create_function(|_, table: Table| {
+   |       ^^^ borrowed value does not live long enough
+13 | /         BAD_TIME.with(|bt| {
+14 | |             *bt.borrow_mut() = Some(table);
+15 | |         });
+   | |__________- argument requires that `lua` is borrowed for `'static`
 ...
-32 |    }
-   |    - `lua` dropped here while still borrowed
+32 |   }
+   |   - `lua` dropped here while still borrowed
 
 error[E0505]: cannot move out of `lua` because it is borrowed
   --> tests/compile/static_callback_args.rs:22:10
    |
-10 |        let lua = Lua::new();
-   |            --- binding `lua` declared here
+10 |       let lua = Lua::new();
+   |           --- binding `lua` declared here
 11 |
-12 | /      lua.create_function(|_, table: Table| {
-13 | |/         BAD_TIME.with(|bt| {
-14 | ||             *bt.borrow_mut() = Some(table);
-15 | ||         });
-   | ||__________- argument requires that `lua` is borrowed for `'static`
-16 | |          Ok(())
-17 | |      })?
-   | |_______- borrow of `lua` occurs here
+12 |       lua.create_function(|_, table: Table| {
+   |       --- borrow of `lua` occurs here
+13 | /         BAD_TIME.with(|bt| {
+14 | |             *bt.borrow_mut() = Some(table);
+15 | |         });
+   | |__________- argument requires that `lua` is borrowed for `'static`
 ...
-22 |        drop(lua);
-   |             ^^^ move out of `lua` occurs here
+22 |       drop(lua);
+   |            ^^^ move out of `lua` occurs here

tests/conversion.rs

@@ -2,8 +2,280 @@ use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::{CStr, CString};
 
+use bstr::BString;
 use maplit::{btreemap, btreeset, hashmap, hashset};
-use mlua::{Error, Lua, Result};
+use mlua::{
+    AnyUserData, Error, Function, IntoLua, Lua, RegistryKey, Result, Table, Thread, UserDataRef,
+    Value,
+};
+
+#[test]
+fn test_value_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let v = Value::Boolean(true);
+    let v2 = (&v).into_lua(&lua)?;
+    assert_eq!(v, v2);
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("v", &v)?;
+    assert_eq!(v, table.get::<_, Value>("v")?);
+
+    Ok(())
+}
+
+#[test]
+fn test_string_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let s = lua.create_string("hello, world!")?;
+    let s2 = (&s).into_lua(&lua)?;
+    assert_eq!(s, s2.as_string().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("s", &s)?;
+    assert_eq!(s, table.get::<_, String>("s")?);
+
+    Ok(())
+}
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[test]
+fn test_owned_string_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let s = lua.create_string("hello, world")?.into_owned();
+    let s2 = (&s).into_lua(&lua)?;
+    assert_eq!(s.to_ref(), *s2.as_string().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("s", &s)?;
+    assert_eq!(s.to_ref(), table.get::<_, String>("s")?);
+
+    Ok(())
+}
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[test]
+fn test_owned_string_from_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    let s = lua.unpack::<mlua::OwnedString>(lua.pack("hello, world")?)?;
+    assert_eq!(s.to_ref(), "hello, world");
+
+    Ok(())
+}
+
+#[test]
+fn test_table_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let t = lua.create_table()?;
+    let t2 = (&t).into_lua(&lua)?;
+    assert_eq!(&t, t2.as_table().unwrap());
+
+    // Push into stack
+    let f = lua.create_function(|_, (t, s): (Table, String)| t.set("s", s))?;
+    f.call((&t, "hello"))?;
+    assert_eq!("hello", t.get::<_, String>("s")?);
+
+    Ok(())
+}
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[test]
+fn test_owned_table_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let t = lua.create_table()?.into_owned();
+    let t2 = (&t).into_lua(&lua)?;
+    assert_eq!(t.to_ref(), *t2.as_table().unwrap());
+
+    // Push into stack
+    let f = lua.create_function(|_, (t, s): (Table, String)| t.set("s", s))?;
+    f.call((&t, "hello"))?;
+    assert_eq!("hello", t.to_ref().get::<_, String>("s")?);
+
+    Ok(())
+}
+
+#[test]
+fn test_function_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let f = lua.create_function(|_, ()| Ok::<_, Error>(()))?;
+    let f2 = (&f).into_lua(&lua)?;
+    assert_eq!(&f, f2.as_function().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("f", &f)?;
+    assert_eq!(f, table.get::<_, Function>("f")?);
+
+    Ok(())
+}
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[test]
+fn test_owned_function_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let f = lua
+        .create_function(|_, ()| Ok::<_, Error>(()))?
+        .into_owned();
+    let f2 = (&f).into_lua(&lua)?;
+    assert_eq!(f.to_ref(), *f2.as_function().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("f", &f)?;
+    assert_eq!(f.to_ref(), table.get::<_, Function>("f")?);
+
+    Ok(())
+}
+
+#[test]
+fn test_thread_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let f = lua.create_function(|_, ()| Ok::<_, Error>(()))?;
+    let th = lua.create_thread(f)?;
+    let th2 = (&th).into_lua(&lua)?;
+    assert_eq!(&th, th2.as_thread().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("th", &th)?;
+    assert_eq!(th, table.get::<_, Thread>("th")?);
+
+    Ok(())
+}
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[test]
+fn test_owned_thread_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let f = lua.create_function(|_, ()| Ok::<_, Error>(()))?;
+    let th = lua.create_thread(f)?.into_owned();
+    let th2 = (&th).into_lua(&lua)?;
+    assert_eq!(&th.to_ref(), th2.as_thread().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("th", &th)?;
+    assert_eq!(th.to_ref(), table.get::<_, Thread>("th")?);
+
+    Ok(())
+}
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[test]
+fn test_owned_thread_from_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    let th = lua.unpack::<mlua::OwnedThread>(Value::Thread(lua.current_thread()))?;
+    assert_eq!(th.to_ref(), lua.current_thread());
+
+    Ok(())
+}
+
+#[test]
+fn test_anyuserdata_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let ud = lua.create_any_userdata(String::from("hello"))?;
+    let ud2 = (&ud).into_lua(&lua)?;
+    assert_eq!(&ud, ud2.as_userdata().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("ud", &ud)?;
+    assert_eq!(ud, table.get::<_, AnyUserData>("ud")?);
+    assert_eq!("hello", *table.get::<_, UserDataRef<String>>("ud")?);
+
+    Ok(())
+}
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[test]
+fn test_owned_anyuserdata_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let ud = lua.create_any_userdata(String::from("hello"))?.into_owned();
+    let ud2 = (&ud).into_lua(&lua)?;
+    assert_eq!(ud.to_ref(), *ud2.as_userdata().unwrap());
+
+    // Push into stack
+    let table = lua.create_table()?;
+    table.set("ud", &ud)?;
+    assert_eq!(ud.to_ref(), table.get::<_, AnyUserData>("ud")?);
+    assert_eq!("hello", *table.get::<_, UserDataRef<String>>("ud")?);
+
+    Ok(())
+}
+
+#[test]
+fn test_registry_value_into_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let s = lua.create_string("hello, world")?;
+    let r = lua.create_registry_value(&s)?;
+    let value1 = lua.pack(&r)?;
+    let value2 = lua.pack(r)?;
+    assert_eq!(value1.as_str(), Some("hello, world"));
+    assert_eq!(value2.to_pointer(), value2.to_pointer());
+
+    // Push into stack
+    let t = lua.create_table()?;
+    let r = lua.create_registry_value(&t)?;
+    let f = lua.create_function(|_, (t, k, v): (Table, Value, Value)| t.set(k, v))?;
+    f.call((&r, "hello", "world"))?;
+    f.call((r, "welcome", "to the jungle"))?;
+    assert_eq!(t.get::<_, String>("hello")?, "world");
+    assert_eq!(t.get::<_, String>("welcome")?, "to the jungle");
+
+    // Try to set nil registry key
+    let r_nil = lua.create_registry_value(Value::Nil)?;
+    t.set("hello", &r_nil)?;
+    assert_eq!(t.get::<_, Value>("hello")?, Value::Nil);
+
+    // Check non-owned registry key
+    let lua2 = Lua::new();
+    let r2 = lua2.create_registry_value("abc")?;
+    assert!(matches!(
+        f.call::<_, ()>(&r2),
+        Err(Error::MismatchedRegistryKey)
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn test_registry_key_from_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    let fkey = lua.load("function() return 1 end").eval::<RegistryKey>()?;
+    let f = lua.registry_value::<Function>(&fkey)?;
+    assert_eq!(f.call::<_, i32>(())?, 1);
+
+    Ok(())
+}
 
 #[test]
 fn test_conv_vec() -> Result<()> {
@@ -138,3 +410,64 @@ fn test_conv_array() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_bstring_from_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    let s = lua.create_string("hello, world")?;
+    let bstr = lua.unpack::<BString>(Value::String(s))?;
+    assert_eq!(bstr, "hello, world");
+
+    let bstr = lua.unpack::<BString>(Value::Integer(123))?;
+    assert_eq!(bstr, "123");
+
+    let bstr = lua.unpack::<BString>(Value::Number(-123.55))?;
+    assert_eq!(bstr, "-123.55");
+
+    // Test from stack
+    let f = lua.create_function(|_, bstr: BString| Ok(bstr))?;
+    let bstr = f.call::<_, BString>("hello, world")?;
+    assert_eq!(bstr, "hello, world");
+
+    let bstr = f.call::<_, BString>(-43.22)?;
+    assert_eq!(bstr, "-43.22");
+
+    Ok(())
+}
+
+#[cfg(feature = "luau")]
+#[test]
+fn test_bstring_from_lua_buffer() -> Result<()> {
+    let lua = Lua::new();
+
+    let b = lua.create_buffer("hello, world")?;
+    let bstr = lua.unpack::<BString>(Value::UserData(b))?;
+    assert_eq!(bstr, "hello, world");
+
+    // Test from stack
+    let f = lua.create_function(|_, bstr: BString| Ok(bstr))?;
+    let buf = lua.create_buffer("hello, world")?;
+    let bstr = f.call::<_, BString>(buf)?;
+    assert_eq!(bstr, "hello, world");
+
+    Ok(())
+}
+
+#[test]
+fn test_option_into_from_lua() -> Result<()> {
+    let lua = Lua::new();
+
+    // Direct conversion
+    let v = Some(42);
+    let v2 = v.into_lua(&lua)?;
+    assert_eq!(v, v2.as_i32());
+
+    // Push into stack / get from stack
+    let f = lua.create_function(|_, v: Option<i32>| Ok(v))?;
+    assert_eq!(f.call::<_, Option<i32>>(Some(42))?, Some(42));
+    assert_eq!(f.call::<_, Option<i32>>(Option::<i32>::None)?, None);
+    assert_eq!(f.call::<_, Option<i32>>(())?, None);
+
+    Ok(())
+}

tests/error.rs

@@ -41,7 +41,9 @@ fn test_error_context() -> Result<()> {
         .context("some new context")
     })?;
     let res = func3.call::<_, ()>(()).err().unwrap();
-    let Error::CallbackError { cause, .. } = &res else { unreachable!() };
+    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());

tests/function.rs

@@ -231,6 +231,40 @@ fn test_function_info() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_function_pointer() -> Result<()> {
+    let lua = Lua::new();
+
+    let func1 = lua.load("return function() end").into_function()?;
+    let func2 = func1.call::<_, Function>(())?;
+
+    assert_eq!(func1.to_pointer(), func1.clone().to_pointer());
+    assert_ne!(func1.to_pointer(), func2.to_pointer());
+
+    Ok(())
+}
+
+#[cfg(feature = "luau")]
+#[test]
+fn test_function_deep_clone() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.globals().set("a", 1)?;
+    let func1 = lua.load("a += 1; return a").into_function()?;
+    let func2 = func1.deep_clone();
+
+    assert_ne!(func1.to_pointer(), func2.to_pointer());
+    assert_eq!(func1.call::<_, i32>(())?, 2);
+    assert_eq!(func2.call::<_, i32>(())?, 3);
+
+    // Check that for Rust functions deep_clone is just a clone
+    let rust_func = lua.create_function(|_, ()| Ok(42))?;
+    let rust_func2 = rust_func.deep_clone();
+    assert_eq!(rust_func.to_pointer(), rust_func2.to_pointer());
+
+    Ok(())
+}
+
 #[test]
 fn test_function_wrap() -> Result<()> {
     use mlua::Error;

tests/hooks.rs

@@ -1,6 +1,5 @@
 #![cfg(not(feature = "luau"))]
 
-use std::cell::RefCell;
 use std::ops::Deref;
 use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::{Arc, Mutex};
@@ -170,10 +169,13 @@ fn test_hook_removal() -> Result<()> {
     Ok(())
 }
 
+// Having the code compiled (even not run) on macos and luajit causes a memory reference issue
+// See https://github.com/LuaJIT/LuaJIT/issues/1099
+#[cfg(not(all(feature = "luajit", target_os = "macos")))]
 #[test]
 fn test_hook_swap_within_hook() -> Result<()> {
     thread_local! {
-        static TL_LUA: RefCell<Option<Lua>> = RefCell::new(None);
+        static TL_LUA: std::cell::RefCell<Option<Lua>> = Default::default();
     }
 
     TL_LUA.with(|tl| {

tests/luau.rs

@@ -1,6 +1,5 @@
 #![cfg(feature = "luau")]
 
-use std::env;
 use std::fmt::Debug;
 use std::fs;
 use std::panic::{catch_unwind, AssertUnwindSafe};
@@ -8,7 +7,8 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 
 use mlua::{
-    Compiler, CoverageInfo, Error, Lua, Result, Table, ThreadStatus, Value, Vector, VmState,
+    Compiler, CoverageInfo, Error, Lua, LuaOptions, Result, StdLib, Table, ThreadStatus, Value,
+    Vector, VmState,
 };
 
 #[test]
@@ -23,7 +23,18 @@ fn test_version() -> Result<()> {
 
 #[test]
 fn test_require() -> Result<()> {
-    let lua = Lua::new();
+    // Ensure that require() is not available if package module is not loaded
+    let mut lua = Lua::new_with(StdLib::NONE, LuaOptions::default())?;
+    assert!(lua.globals().get::<_, Option<Value>>("require")?.is_none());
+    assert!(lua.globals().get::<_, Option<Value>>("package")?.is_none());
+
+    if cfg!(target_arch = "wasm32") {
+        // TODO: figure out why emscripten fails on file operations
+        // Also see https://github.com/rust-lang/rust/issues/119250
+        return Ok(());
+    }
+
+    lua = Lua::new();
 
     let temp_dir = tempfile::tempdir().unwrap();
     fs::write(
@@ -37,7 +48,10 @@ fn test_require() -> Result<()> {
     "#,
     )?;
 
-    env::set_var("LUAU_PATH", temp_dir.path().join("?.luau"));
+    lua.globals()
+        .get::<_, Table>("package")?
+        .set("path", temp_dir.path().join("?.luau").to_string_lossy())?;
+
     lua.load(
         r#"
         local module = require("module")
@@ -49,7 +63,28 @@ fn test_require() -> Result<()> {
         assert(not ok and string.find(err, "module.luau") ~= nil)
     "#,
     )
-    .exec()
+    .exec()?;
+
+    // Require non-existent module
+    match lua.load("require('non-existent')").exec() {
+        Err(Error::RuntimeError(e)) if e.contains("module 'non-existent' not found") => {}
+        r => panic!("expected RuntimeError(...) with a specific message, got {r:?}"),
+    }
+
+    // Require binary module in safe mode
+    lua.globals()
+        .get::<_, Table>("package")?
+        .set("cpath", temp_dir.path().join("?.so").to_string_lossy())?;
+    fs::write(temp_dir.path().join("dylib.so"), "")?;
+    match lua.load("require('dylib')").exec() {
+        Err(Error::RuntimeError(e)) if cfg!(unix) && e.contains("module 'dylib' not found") => {
+            assert!(e.contains("dynamic libraries are disabled in safe mode"))
+        }
+        Err(Error::RuntimeError(e)) if e.contains("module 'dylib' not found") => {}
+        r => panic!("expected RuntimeError(...) with a specific message, got {r:?}"),
+    }
+
+    Ok(())
 }
 
 #[cfg(not(feature = "luau-vector4"))]
@@ -240,6 +275,22 @@ fn test_sandbox() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_sandbox_nolibs() -> Result<()> {
+    let lua = Lua::new_with(StdLib::NONE, LuaOptions::default()).unwrap();
+
+    lua.sandbox(true)?;
+    lua.load("global = 123").exec()?;
+    let n: i32 = lua.load("return global").eval()?;
+    assert_eq!(n, 123);
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(123));
+
+    lua.sandbox(false)?;
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, None);
+
+    Ok(())
+}
+
 #[test]
 fn test_sandbox_threads() -> Result<()> {
     let lua = Lua::new();
@@ -407,3 +458,35 @@ fn test_coverage() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_buffer() -> Result<()> {
+    let lua = Lua::new();
+
+    let buf1 = lua
+        .load(
+            r#"
+        local buf = buffer.fromstring("hello")
+        assert(buffer.len(buf) == 5)
+        return buf
+    "#,
+        )
+        .eval::<Value>()?;
+    assert!(buf1.is_userdata() && buf1.is_buffer());
+    assert_eq!(buf1.type_name(), "buffer");
+
+    let buf2 = lua.load("buffer.fromstring('hello')").eval::<Value>()?;
+    assert_ne!(buf1, buf2);
+
+    // Check that we can pass buffer type to Lua
+    let func = lua.create_function(|_, buf: Value| return buf.to_string())?;
+    assert!(func.call::<_, String>(buf1)?.starts_with("buffer:"));
+
+    Ok(())
+}
+
+#[test]
+fn test_fflags() {
+    // We cannot really on any particular feature flag to be present
+    assert!(Lua::set_fflag("UnknownFlag", true).is_err());
+}

tests/memory.rs

@@ -84,7 +84,7 @@ fn test_gc_control() -> Result<()> {
 
     assert_eq!(lua.gc_inc(200, 100, 13), GCMode::Incremental);
 
-    struct MyUserdata(Arc<()>);
+    struct MyUserdata(#[allow(unused)] Arc<()>);
     impl UserData for MyUserdata {}
 
     let rc = Arc::new(());

tests/module/Cargo.toml

@@ -18,6 +18,7 @@ lua53 = ["mlua/lua53"]
 lua52 = ["mlua/lua52"]
 lua51 = ["mlua/lua51"]
 luajit = ["mlua/luajit"]
+luau = ["mlua/luau"]
 
 [dependencies]
 mlua = { path = "../..", features = ["module"] }

tests/module/loader/Cargo.toml

@@ -10,6 +10,7 @@ lua53 = ["mlua/lua53"]
 lua52 = ["mlua/lua52"]
 lua51 = ["mlua/lua51"]
 luajit = ["mlua/luajit"]
+luau = ["mlua/luau"]
 vendored = ["mlua/vendored"]
 
 [dependencies]

tests/module/loader/tests/load.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 use mlua::{Lua, Result};
 
 #[test]
-fn test_module() -> Result<()> {
+fn test_module_simple() -> Result<()> {
     let lua = make_lua()?;
     lua.load(
         r#"
@@ -59,7 +59,8 @@ fn test_module_from_thread() -> Result<()> {
             assert(mod.sum(a, b) == a + b)
         end)
 
-        coroutine.resume(co, 3, 5)
+        local ok, err = coroutine.resume(co, 3, 5)
+        assert(ok, err)
         collectgarbage()
 
         assert(mod.used_memory() > 0)
@@ -68,6 +69,29 @@ fn test_module_from_thread() -> Result<()> {
     .exec()
 }
 
+#[cfg(any(
+    feature = "lua54",
+    feature = "lua53",
+    feature = "lua52",
+    feature = "lua51"
+))]
+#[test]
+fn test_module_multi_from_thread() -> Result<()> {
+    let lua = make_lua()?;
+    lua.load(
+        r#"
+        local mod = require("test_module")
+        local co = coroutine.create(function()
+            local mod2 = require("test_module.second")
+            assert(mod2.userdata ~= nil)
+        end)
+        local ok, err = coroutine.resume(co)
+        assert(ok, err)
+    "#,
+    )
+    .exec()
+}
+
 fn make_lua() -> Result<Lua> {
     let (dylib_path, dylib_ext, separator);
     if cfg!(target_os = "macos") {

tests/multi.rs

@@ -0,0 +1,60 @@
+use mlua::{Error, ExternalError, IntoLuaMulti, Lua, Result, String, Value};
+
+#[test]
+fn test_result_conversions() -> Result<()> {
+    let lua = Lua::new();
+    let globals = lua.globals();
+
+    let ok = lua.create_function(|_, ()| Ok(Ok::<(), Error>(())))?;
+    let err = lua.create_function(|_, ()| Ok(Err::<(), _>("failure1".into_lua_err())))?;
+    let ok2 = lua.create_function(|_, ()| Ok(Ok::<_, Error>("!".to_owned())))?;
+    let err2 = lua.create_function(|_, ()| Ok(Err::<String, _>("failure2".into_lua_err())))?;
+
+    globals.set("ok", ok)?;
+    globals.set("ok2", ok2)?;
+    globals.set("err", err)?;
+    globals.set("err2", err2)?;
+
+    lua.load(
+        r#"
+        local r, e = ok()
+        assert(r == nil and e == nil)
+
+        local r, e = err()
+        assert(r == nil)
+        assert(tostring(e):find("failure1") ~= nil)
+
+        local r, e = ok2()
+        assert(r == "!")
+        assert(e == nil)
+
+        local r, e = err2()
+        assert(r == nil)
+        assert(tostring(e):find("failure2") ~= nil)
+    "#,
+    )
+    .exec()?;
+
+    // Try to convert Result into MultiValue
+    let ok1 = Ok::<(), Error>(());
+    let multi_ok1 = ok1.into_lua_multi(&lua)?;
+    assert_eq!(multi_ok1.len(), 0);
+    let err1 = Err::<(), _>("failure1");
+    let multi_err1 = err1.into_lua_multi(&lua)?;
+    assert_eq!(multi_err1.len(), 2);
+    assert_eq!(multi_err1[0], Value::Nil);
+    assert_eq!(multi_err1[1].as_str().unwrap(), "failure1");
+
+    let ok2 = Ok::<_, Error>("!");
+    let multi_ok2 = ok2.into_lua_multi(&lua)?;
+    assert_eq!(multi_ok2.len(), 1);
+    assert_eq!(multi_ok2[0].as_str().unwrap(), "!");
+    let err2 = Err::<String, _>("failure2".into_lua_err());
+    let multi_err2 = err2.into_lua_multi(&lua)?;
+    assert_eq!(multi_err2.len(), 2);
+    assert_eq!(multi_err2[0], Value::Nil);
+    assert!(matches!(multi_err2[1], Value::Error(_)));
+    assert_eq!(multi_err2[1].to_string()?, "failure2");
+
+    Ok(())
+}

tests/scope.rs

@@ -155,14 +155,14 @@ fn test_scope_userdata_functions() -> Result<()> {
 
     impl<'a> UserData for MyUserData<'a> {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_meta_function(MetaMethod::Add, |lua, ()| {
+            methods.add_meta_method(MetaMethod::Add, |lua, this, ()| {
                 let globals = lua.globals();
-                globals.set("i", globals.get::<_, i64>("i")? + 1)?;
+                globals.set("i", globals.get::<_, i64>("i")? + this.0)?;
                 Ok(())
             });
-            methods.add_meta_function(MetaMethod::Sub, |lua, ()| {
+            methods.add_meta_method(MetaMethod::Sub, |lua, this, ()| {
                 let globals = lua.globals();
-                globals.set("i", globals.get::<_, i64>("i")? + 1)?;
+                globals.set("i", globals.get::<_, i64>("i")? + this.0)?;
                 Ok(())
             });
         }
@@ -170,7 +170,7 @@ fn test_scope_userdata_functions() -> Result<()> {
 
     let lua = Lua::new();
 
-    let dummy = 0;
+    let dummy = 1;
     let f = lua
         .load(
             r#"
@@ -178,7 +178,7 @@ fn test_scope_userdata_functions() -> Result<()> {
             return function(u)
                 _ = u + u
                 _ = u - 1
-                _ = 1 + u
+                _ = u + 1
             end
         "#,
         )
@@ -257,7 +257,7 @@ fn test_scope_userdata_mismatch() -> Result<()> {
 fn test_scope_userdata_drop() -> Result<()> {
     let lua = Lua::new();
 
-    struct MyUserData(Rc<()>);
+    struct MyUserData(#[allow(unused)] Rc<()>);
 
     impl UserData for MyUserData {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
@@ -265,7 +265,7 @@ fn test_scope_userdata_drop() -> Result<()> {
         }
     }
 
-    struct MyUserDataArc(Arc<()>);
+    struct MyUserDataArc(#[allow(unused)] Arc<()>);
 
     impl UserData for MyUserDataArc {}
 
@@ -315,7 +315,7 @@ fn test_scope_userdata_drop() -> Result<()> {
 fn test_scope_nonstatic_userdata_drop() -> Result<()> {
     let lua = Lua::new();
 
-    struct MyUserData<'a>(&'a Cell<i64>, Arc<()>);
+    struct MyUserData<'a>(&'a Cell<i64>, #[allow(unused)] Arc<()>);
 
     impl<'a> UserData for MyUserData<'a> {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
@@ -326,7 +326,7 @@ fn test_scope_nonstatic_userdata_drop() -> Result<()> {
         }
     }
 
-    struct MyUserDataArc(Arc<()>);
+    struct MyUserDataArc(#[allow(unused)] Arc<()>);
 
     impl UserData for MyUserDataArc {}
 

tests/serde.rs

@@ -99,7 +99,7 @@ fn test_serialize_in_scope() -> LuaResult<()> {
         Err(e) => panic!("expected destructed error, got {}", e),
     }
 
-    struct MyUserDataRef<'a>(&'a ());
+    struct MyUserDataRef<'a>(#[allow(unused)] &'a ());
 
     impl<'a> UserData for MyUserDataRef<'a> {}
 
@@ -115,6 +115,21 @@ fn test_serialize_in_scope() -> LuaResult<()> {
     Ok(())
 }
 
+#[test]
+fn test_serialize_any_userdata() -> Result<(), Box<dyn StdError>> {
+    let lua = Lua::new();
+
+    let json_val = serde_json::json!({
+        "a": 1,
+        "b": "test",
+    });
+    let json_ud = lua.create_ser_any_userdata(json_val)?;
+    let json_str = serde_json::to_string_pretty(&json_ud)?;
+    assert_eq!(json_str, "{\n  \"a\": 1,\n  \"b\": \"test\"\n}");
+
+    Ok(())
+}
+
 #[test]
 fn test_serialize_failure() -> Result<(), Box<dyn StdError>> {
     #[derive(Serialize)]
@@ -254,6 +269,27 @@ fn test_serialize_globals() -> LuaResult<()> {
     Ok(())
 }
 
+#[test]
+fn test_serialize_same_table_twice() -> LuaResult<()> {
+    let lua = Lua::new();
+
+    let value = lua
+        .load(
+            r#"
+        local foo = {}
+        return {
+            a = foo,
+            b = foo,
+        }
+    "#,
+        )
+        .eval::<Value>()?;
+    let json = serde_json::to_string(&value.to_serializable().sort_keys(true)).unwrap();
+    assert_eq!(json, r#"{"a":{},"b":{}}"#);
+
+    Ok(())
+}
+
 #[test]
 fn test_to_value_struct() -> LuaResult<()> {
     let lua = Lua::new();
@@ -598,7 +634,7 @@ fn test_from_value_with_options() -> Result<(), Box<dyn StdError>> {
 
     // Check recursion when using `Serialize` impl
     let t = lua.create_table()?;
-    t.set("t", t.clone())?;
+    t.set("t", &t)?;
     assert!(serde_json::to_string(&t).is_err());
 
     // Serialize Lua globals table
@@ -697,3 +733,61 @@ fn test_from_value_sorted() -> Result<(), Box<dyn StdError>> {
 
     Ok(())
 }
+
+#[test]
+fn test_arbitrary_precision() {
+    let lua = Lua::new();
+
+    let opts = SerializeOptions::new().detect_serde_json_arbitrary_precision(true);
+
+    // Number
+    let num = serde_json::Value::Number(serde_json::Number::from_f64(1.244e2).unwrap());
+    let num = lua.to_value_with(&num, opts).unwrap();
+    assert_eq!(num, Value::Number(1.244e2));
+
+    // Integer
+    let num = serde_json::Value::Number(serde_json::Number::from_f64(123.0).unwrap());
+    let num = lua.to_value_with(&num, opts).unwrap();
+    assert_eq!(num, Value::Integer(123));
+
+    // Max u64
+    let num = serde_json::Value::Number(serde_json::Number::from(i64::MAX));
+    let num = lua.to_value_with(&num, opts).unwrap();
+    assert_eq!(num, Value::Number(i64::MAX as f64));
+
+    // Check that the option is disabled by default
+    let num = serde_json::Value::Number(serde_json::Number::from_f64(1.244e2).unwrap());
+    let num = lua.to_value(&num).unwrap();
+    assert_eq!(num.type_name(), "table");
+    assert_eq!(
+        format!("{:#?}", num),
+        "{\n  [\"$serde_json::private::Number\"] = \"124.4\",\n}"
+    );
+}
+
+#[cfg(feature = "luau")]
+#[test]
+fn test_buffer_serialize() {
+    let lua = Lua::new();
+
+    let buf = lua.create_buffer(&[1, 2, 3, 4]).unwrap();
+    let val = serde_value::to_value(&buf).unwrap();
+    assert_eq!(val, serde_value::Value::Bytes(vec![1, 2, 3, 4]));
+
+    // Try empty buffer
+    let buf = lua.create_buffer(&[]).unwrap();
+    let val = serde_value::to_value(&buf).unwrap();
+    assert_eq!(val, serde_value::Value::Bytes(vec![]));
+}
+
+#[cfg(feature = "luau")]
+#[test]
+fn test_buffer_from_value() {
+    let lua = Lua::new();
+
+    let buf = lua.create_buffer(&[1, 2, 3, 4]).unwrap();
+    let val = lua
+        .from_value::<serde_value::Value>(Value::UserData(buf))
+        .unwrap();
+    assert_eq!(val, serde_value::Value::Bytes(vec![1, 2, 3, 4]));
+}

tests/static.rs

@@ -73,13 +73,22 @@ fn test_static_lua_coroutine() -> Result<()> {
 async fn test_static_async() -> Result<()> {
     let lua = Lua::new().into_static();
 
+    #[cfg(not(target_arch = "wasm32"))]
+    async fn sleep_ms(ms: u64) {
+        tokio::time::sleep(std::time::Duration::from_millis(ms)).await;
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    async fn sleep_ms(_ms: u64) {
+        tokio::task::yield_now().await;
+    }
+
     let timer =
         lua.create_async_function(|_, (i, n, f): (u64, u64, mlua::Function)| async move {
             tokio::task::spawn_local(async move {
-                let dur = std::time::Duration::from_millis(i);
                 for _ in 0..n {
                     tokio::task::spawn_local(f.call_async::<(), ()>(()));
-                    tokio::time::sleep(dur).await;
+                    sleep_ms(i).await;
                 }
             });
             Ok(())

tests/string.rs

@@ -99,6 +99,19 @@ fn test_string_debug() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_string_pointer() -> Result<()> {
+    let lua = Lua::new();
+
+    let str1 = lua.create_string("hello")?;
+    let str2 = lua.create_string("hello")?;
+
+    // Lua uses string interning, so these should be the same
+    assert_eq!(str1.to_pointer(), str2.to_pointer());
+
+    Ok(())
+}
+
 #[cfg(all(feature = "unstable", not(feature = "send")))]
 #[test]
 fn test_owned_string() -> Result<()> {

tests/table.rs

@@ -217,6 +217,74 @@ fn test_table_sequence_from() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_table_pairs() -> Result<()> {
+    let lua = Lua::new();
+
+    let table = lua
+        .load(
+            r#"
+    {
+        foo = "bar",
+        baz = "baf",
+        [123] = 456,
+        [789] = 101112,
+        5,
+    }
+    "#,
+        )
+        .eval::<Table>()?;
+
+    let table2 = table.clone();
+    for (i, kv) in table.pairs::<String, Value>().enumerate() {
+        let (k, _v) = kv.unwrap();
+        match i {
+            // Try to add a new key
+            0 => table2.set("new_key", "new_value")?,
+            // Try to delete the 2nd key
+            1 => {
+                table2.set(k, Value::Nil)?;
+                lua.gc_collect()?;
+            }
+            _ => {}
+        }
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_table_for_each() -> Result<()> {
+    let lua = Lua::new();
+
+    let table = lua
+        .load(
+            r#"
+    {
+        foo = "bar",
+        baz = "baf",
+        [123] = 456,
+        [789] = 101112,
+        5,
+    }
+    "#,
+        )
+        .eval::<Table>()?;
+
+    let mut i = 0;
+    table.for_each::<String, Value>(|k, _| {
+        if i == 0 {
+            // Delete first key
+            table.set(k, Value::Nil)?;
+            lua.gc_collect()?;
+        }
+        Ok(i += 1)
+    })?;
+    assert_eq!(i, 5);
+
+    Ok(())
+}
+
 #[test]
 fn test_table_scope() -> Result<()> {
     let lua = Lua::new();
@@ -301,6 +369,19 @@ fn test_table_eq() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_table_pointer() -> Result<()> {
+    let lua = Lua::new();
+
+    let table1 = lua.create_table()?;
+    let table2 = lua.create_table()?;
+
+    assert_eq!(table1.to_pointer(), table1.clone().to_pointer());
+    assert_ne!(table1.to_pointer(), table2.to_pointer());
+
+    Ok(())
+}
+
 #[test]
 fn test_table_error() -> Result<()> {
     let lua = Lua::new();

tests/tests.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+#[cfg(not(target_arch = "wasm32"))]
 use std::iter::FromIterator;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::string::String as StdString;
@@ -312,30 +313,29 @@ fn test_error() -> Result<()> {
     globals.set("rust_error_function", rust_error_function)?;
 
     let no_error = globals.get::<_, Function>("no_error")?;
-    let lua_error = globals.get::<_, Function>("lua_error")?;
-    let rust_error = globals.get::<_, Function>("rust_error")?;
-    let return_error = globals.get::<_, Function>("return_error")?;
-    let return_string_error = globals.get::<_, Function>("return_string_error")?;
-    let test_pcall = globals.get::<_, Function>("test_pcall")?;
-    let understand_recursion = globals.get::<_, Function>("understand_recursion")?;
-
     assert!(no_error.call::<_, ()>(()).is_ok());
+
+    let lua_error = globals.get::<_, Function>("lua_error")?;
     match lua_error.call::<_, ()>(()) {
         Err(Error::RuntimeError(_)) => {}
         Err(e) => panic!("error is not RuntimeError kind, got {:?}", e),
         _ => panic!("error not returned"),
     }
+
+    let rust_error = globals.get::<_, Function>("rust_error")?;
     match rust_error.call::<_, ()>(()) {
         Err(Error::CallbackError { .. }) => {}
         Err(e) => panic!("error is not CallbackError kind, got {:?}", e),
         _ => panic!("error not returned"),
     }
 
+    let return_error = globals.get::<_, Function>("return_error")?;
     match return_error.call::<_, Value>(()) {
         Ok(Value::Error(_)) => {}
         _ => panic!("Value::Error not returned"),
     }
 
+    let return_string_error = globals.get::<_, Function>("return_string_error")?;
     assert!(return_string_error.call::<_, Error>(()).is_ok());
 
     match lua
@@ -358,9 +358,14 @@ fn test_error() -> Result<()> {
         _ => panic!("error not returned"),
     }
 
+    let test_pcall = globals.get::<_, Function>("test_pcall")?;
     test_pcall.call::<_, ()>(())?;
 
-    assert!(understand_recursion.call::<_, ()>(()).is_err());
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let understand_recursion = globals.get::<_, Function>("understand_recursion")?;
+        assert!(understand_recursion.call::<_, ()>(()).is_err());
+    }
 
     Ok(())
 }
@@ -499,44 +504,6 @@ fn test_panic() -> Result<()> {
     Ok(())
 }
 
-#[test]
-fn test_result_conversions() -> Result<()> {
-    let lua = Lua::new();
-    let globals = lua.globals();
-
-    let ok = lua.create_function(|_, ()| Ok(Ok::<(), Error>(())))?;
-    let err = lua.create_function(|_, ()| Ok(Err::<(), _>("failure1".into_lua_err())))?;
-    let ok2 = lua.create_function(|_, ()| Ok(Ok::<_, Error>("!".to_owned())))?;
-    let err2 = lua.create_function(|_, ()| Ok(Err::<String, _>("failure2".into_lua_err())))?;
-
-    globals.set("ok", ok)?;
-    globals.set("ok2", ok2)?;
-    globals.set("err", err)?;
-    globals.set("err2", err2)?;
-
-    lua.load(
-        r#"
-        local r, e = ok()
-        assert(r == nil and e == nil)
-
-        local r, e = err()
-        assert(r == nil)
-        assert(tostring(e):find("failure1") ~= nil)
-
-        local r, e = ok2()
-        assert(r == "!")
-        assert(e == nil)
-
-        local r, e = err2()
-        assert(r == nil)
-        assert(tostring(e):find("failure2") ~= nil)
-    "#,
-    )
-    .exec()?;
-
-    Ok(())
-}
-
 #[test]
 fn test_num_conversion() -> Result<()> {
     let lua = Lua::new();
@@ -776,7 +743,7 @@ fn test_registry_value() -> Result<()> {
 
 #[test]
 fn test_drop_registry_value() -> Result<()> {
-    struct MyUserdata(Arc<()>);
+    struct MyUserdata(#[allow(unused)] Arc<()>);
 
     impl UserData for MyUserdata {}
 
@@ -808,12 +775,11 @@ fn test_replace_registry_value() -> Result<()> {
     lua.replace_registry_value(&key, 123)?;
     assert_eq!(lua.registry_value::<i32>(&key)?, 123);
 
-    // It should be impossible to replace (initial) nil value with non-nil
     let key2 = lua.create_registry_value(Value::Nil)?;
-    match lua.replace_registry_value(&key2, "abc") {
-        Err(Error::RuntimeError(_)) => {}
-        r => panic!("expected RuntimeError, got {r:?}"),
-    }
+    lua.replace_registry_value(&key2, Value::Nil)?;
+    assert_eq!(lua.registry_value::<Value>(&key2)?, Value::Nil);
+    lua.replace_registry_value(&key2, "abc")?;
+    assert_eq!(lua.registry_value::<String>(&key2)?, "abc");
 
     Ok(())
 }
@@ -947,6 +913,7 @@ fn test_application_data() -> Result<()> {
 }
 
 #[test]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_recursion() -> Result<()> {
     let lua = Lua::new();
 
@@ -959,21 +926,23 @@ fn test_recursion() -> Result<()> {
         Ok(())
     })?;
 
-    lua.globals().set("f", f.clone())?;
+    lua.globals().set("f", &f)?;
     f.call::<_, ()>(1)?;
 
     Ok(())
 }
 
 #[test]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_too_many_returns() -> Result<()> {
     let lua = Lua::new();
     let f = lua.create_function(|_, ()| Ok(Variadic::from_iter(1..1000000)))?;
-    assert!(f.call::<_, Vec<u32>>(()).is_err());
+    assert!(f.call::<_, Variadic<u32>>(()).is_err());
     Ok(())
 }
 
 #[test]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_too_many_arguments() -> Result<()> {
     let lua = Lua::new();
     lua.load("function test(...) end").exec()?;
@@ -988,19 +957,21 @@ fn test_too_many_arguments() -> Result<()> {
 
 #[test]
 #[cfg(not(feature = "luajit"))]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_too_many_recursions() -> Result<()> {
     let lua = Lua::new();
 
     let f = lua
         .create_function(move |lua, ()| lua.globals().get::<_, Function>("f")?.call::<_, ()>(()))?;
 
-    lua.globals().set("f", f.clone())?;
+    lua.globals().set("f", &f)?;
     assert!(f.call::<_, ()>(()).is_err());
 
     Ok(())
 }
 
 #[test]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_too_many_binds() -> Result<()> {
     let lua = Lua::new();
     let globals = lua.globals();
@@ -1022,6 +993,7 @@ fn test_too_many_binds() -> Result<()> {
 }
 
 #[test]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_ref_stack_exhaustion() {
     match catch_unwind(AssertUnwindSafe(|| -> Result<()> {
         let lua = Lua::new();
@@ -1325,10 +1297,10 @@ fn test_warnings() -> Result<()> {
 
 #[test]
 #[cfg(feature = "luajit")]
-#[should_panic]
-fn test_luajit_cdata() {
+fn test_luajit_cdata() -> Result<()> {
     let lua = unsafe { Lua::unsafe_new() };
-    let _v: Result<Value> = lua
+
+    let cdata = lua
         .load(
             r#"
         local ffi = require("ffi")
@@ -1341,11 +1313,17 @@ fn test_luajit_cdata() {
         return ptr
     "#,
         )
-        .eval();
+        .eval::<Value>()?;
+    assert!(cdata.is_userdata() && cdata.is_cdata());
+    assert_eq!(cdata.type_name(), "cdata");
+    assert!(cdata.to_string()?.starts_with("cdata<void *>:"));
+
+    Ok(())
 }
 
 #[test]
 #[cfg(feature = "send")]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_send() {
     let lua = Lua::new();
     std::thread::spawn(move || {

tests/thread.rs

@@ -90,6 +90,19 @@ fn test_thread() -> Result<()> {
         _ => panic!("resuming dead coroutine did not return error"),
     }
 
+    // Already running thread must be unresumable
+    let thread = lua.create_thread(lua.create_function(|lua, ()| {
+        assert_eq!(lua.current_thread().status(), ThreadStatus::Unresumable);
+        let result = lua.current_thread().resume::<_, ()>(());
+        assert!(
+            matches!(result, Err(Error::CoroutineInactive)),
+            "unexpected result: {result:?}",
+        );
+        Ok(())
+    })?)?;
+    let result = thread.resume::<_, ()>(());
+    assert!(result.is_ok(), "unexpected result: {result:?}");
+
     Ok(())
 }
 
@@ -101,7 +114,7 @@ fn test_thread_reset() -> Result<()> {
 
     let lua = Lua::new();
 
-    struct MyUserData(Arc<()>);
+    struct MyUserData(#[allow(unused)] Arc<()>);
     impl UserData for MyUserData {}
 
     let arc = Arc::new(());
@@ -146,6 +159,21 @@ fn test_thread_reset() -> Result<()> {
         assert_eq!(thread.status(), ThreadStatus::Resumable);
     }
 
+    // Try reset running thread
+    let thread = lua.create_thread(lua.create_function(|lua, ()| {
+        let this = lua.current_thread();
+        this.reset(lua.create_function(|_, ()| Ok(()))?)?;
+        Ok(())
+    })?)?;
+    let result = thread.resume::<_, ()>(());
+    assert!(
+        matches!(result, Err(Error::CallbackError{ ref cause, ..})
+            if matches!(cause.as_ref(), Error::RuntimeError(ref err)
+                if err == "cannot reset a running thread")
+        ),
+        "unexpected result: {result:?}",
+    );
+
     Ok(())
 }
 
@@ -182,7 +210,7 @@ fn test_coroutine_panic() {
         let thrd_main = lua.create_function(|_, ()| -> Result<()> {
             panic!("test_panic");
         })?;
-        lua.globals().set("main", thrd_main.clone())?;
+        lua.globals().set("main", &thrd_main)?;
         let thrd: Thread = lua.create_thread(thrd_main)?;
         thrd.resume(())
     }) {
@@ -191,6 +219,19 @@ fn test_coroutine_panic() {
     }
 }
 
+#[test]
+fn test_thread_pointer() -> Result<()> {
+    let lua = Lua::new();
+
+    let func = lua.load("return 123").into_function()?;
+    let thread = lua.create_thread(func.clone())?;
+
+    assert_eq!(thread.to_pointer(), thread.clone().to_pointer());
+    assert_ne!(thread.to_pointer(), lua.current_thread().to_pointer());
+
+    Ok(())
+}
+
 #[cfg(all(feature = "unstable", not(feature = "send")))]
 #[test]
 fn test_owned_thread() -> Result<()> {

tests/userdata.rs

@@ -58,7 +58,7 @@ fn test_methods() -> Result<()> {
 
     fn check_methods(lua: &Lua, userdata: AnyUserData) -> Result<()> {
         let globals = lua.globals();
-        globals.set("userdata", userdata.clone())?;
+        globals.set("userdata", &userdata)?;
         lua.load(
             r#"
             function get_it()
@@ -342,7 +342,7 @@ fn test_userdata_take() -> Result<()> {
     }
 
     fn check_userdata_take(lua: &Lua, userdata: AnyUserData, rc: Arc<i64>) -> Result<()> {
-        lua.globals().set("userdata", userdata.clone())?;
+        lua.globals().set("userdata", &userdata)?;
         assert_eq!(Arc::strong_count(&rc), 3);
         {
             let _value = userdata.borrow::<MyUserdata>()?;
@@ -370,6 +370,8 @@ fn test_userdata_take() -> Result<()> {
             r => panic!("improper return for destructed userdata: {:?}", r),
         }
 
+        assert!(!userdata.is::<MyUserdata>());
+
         drop(userdata);
         lua.globals().raw_remove("userdata")?;
         lua.gc_collect()?;
@@ -400,7 +402,7 @@ fn test_userdata_take() -> Result<()> {
 
 #[test]
 fn test_userdata_destroy() -> Result<()> {
-    struct MyUserdata(Arc<()>);
+    struct MyUserdata(#[allow(unused)] Arc<()>);
 
     impl UserData for MyUserdata {}
 
@@ -474,7 +476,7 @@ fn test_functions() -> Result<()> {
     let lua = Lua::new();
     let globals = lua.globals();
     let userdata = lua.create_userdata(MyUserData(42))?;
-    globals.set("userdata", userdata.clone())?;
+    globals.set("userdata", &userdata)?;
     lua.load(
         r#"
         function get_it()
@@ -506,6 +508,9 @@ fn test_functions() -> Result<()> {
 
 #[test]
 fn test_fields() -> Result<()> {
+    let lua = Lua::new();
+    let globals = lua.globals();
+
     #[derive(Copy, Clone)]
     struct MyUserData(i64);
 
@@ -533,8 +538,6 @@ fn test_fields() -> Result<()> {
         }
     }
 
-    let lua = Lua::new();
-    let globals = lua.globals();
     globals.set("ud", MyUserData(7))?;
     lua.load(
         r#"
@@ -555,6 +558,33 @@ fn test_fields() -> Result<()> {
     )
     .exec()?;
 
+    // Case: fields + __index metamethod (function)
+    struct MyUserData2(i64);
+
+    impl UserData for MyUserData2 {
+        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field("z", 0);
+            fields.add_field_method_get("x", |_, data| Ok(data.0));
+        }
+
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_meta_method(MetaMethod::Index, |_, _, name: StdString| match &*name {
+                "y" => Ok(Some(-1)),
+                _ => Ok(None),
+            });
+        }
+    }
+
+    globals.set("ud", MyUserData2(1))?;
+    lua.load(
+        r#"
+        assert(ud.x == 1)
+        assert(ud.y == -1)
+        assert(ud.z == 0)
+    "#,
+    )
+    .exec()?;
+
     Ok(())
 }
 
@@ -923,6 +953,20 @@ fn test_userdata_method_errors() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_userdata_pointer() -> Result<()> {
+    let lua = Lua::new();
+
+    let ud1 = lua.create_any_userdata("hello")?;
+    let ud2 = lua.create_any_userdata("hello")?;
+
+    assert_eq!(ud1.to_pointer(), ud1.clone().to_pointer());
+    // Different userdata objects with the same value should have different pointers
+    assert_ne!(ud1.to_pointer(), ud2.to_pointer());
+
+    Ok(())
+}
+
 #[cfg(all(feature = "unstable", not(feature = "send")))]
 #[test]
 fn test_owned_userdata() -> Result<()> {
@@ -963,9 +1007,9 @@ fn test_userdata_derive() -> Result<()> {
     // More complex struct where generics and where clause
 
     #[derive(Clone, Copy, mlua::FromLua)]
-    struct MyUserData2<'a, T>(&'a T)
+    struct MyUserData2<'a, T: ?Sized>(&'a T)
     where
-        T: ?Sized;
+        T: Copy;
 
     lua.register_userdata_type::<MyUserData2<'static, i32>>(|reg| {
         reg.add_function("val", |_, this: MyUserData2<'static, i32>| Ok(*this.0));