v0.10.4

If passed type is non-userdata we try to get a pointer (which will be null) that triggers an assertion.
Having a check also allow us to generate right error message.
Fixes #569

.github/workflows/coverage.yml

@@ -6,18 +6,18 @@ jobs:
     name: coverage
     runs-on: ubuntu-latest
     container:
-      image: xd009642/tarpaulin
+      image: xd009642/tarpaulin:develop-nightly
       options: --security-opt seccomp=unconfined
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@main
 
       - name: Generate coverage report
         run: |
-          cargo tarpaulin --out xml --tests --exclude-files benches/* --exclude-files mlua-sys/src/*/*
+          cargo +nightly tarpaulin --verbose --out xml --tests --exclude-files benches/* --exclude-files mlua-sys/src/*/*
 
       - name: Upload report to codecov.io
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         with:
           token: ${{secrets.CODECOV_TOKEN}}
           fail_ci_if_error: false

.github/workflows/main.yml

@@ -7,18 +7,18 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-22.04, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         rust: [stable]
         lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
         include:
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
           - os: macos-latest
             target: x86_64-apple-darwin
           - os: windows-latest
             target: x86_64-pc-windows-msvc
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -27,10 +27,11 @@ jobs:
       - name: Build ${{ matrix.lua }} vendored
         run: |
           cargo build --features "${{ matrix.lua }},vendored"
-          cargo build --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+          cargo build --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers"
+          cargo build --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers,send"
         shell: bash
       - name: Build ${{ matrix.lua }} pkg-config
-        if: ${{ matrix.os == 'ubuntu-22.04' }}
+        if: ${{ matrix.os == 'ubuntu-latest' }}
         run: |
           sudo apt-get update
           sudo apt-get install -y --no-install-recommends liblua5.4-dev liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
@@ -44,23 +45,23 @@ jobs:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
           target: aarch64-apple-darwin
       - name: Cross-compile
-        run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+        run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
 
   build_aarch64_cross_ubuntu:
     name: Cross-compile to aarch64-unknown-linux-gnu
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
@@ -71,18 +72,18 @@ jobs:
           sudo apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu libc6-dev-arm64-cross
         shell: bash
       - name: Cross-compile
-        run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+        run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
         shell: bash
 
   build_armv7_cross_ubuntu:
     name: Cross-compile to armv7-unknown-linux-gnueabihf
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
@@ -93,7 +94,7 @@ jobs:
           sudo apt-get install -y --no-install-recommends gcc-arm-linux-gnueabihf libc-dev-armhf-cross
         shell: bash
       - name: Cross-compile
-        run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+        run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
         shell: bash
 
   test:
@@ -102,18 +103,18 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-22.04, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         rust: [stable, nightly]
         lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau, luau-jit, luau-vector4]
         include:
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
           - os: macos-latest
             target: x86_64-apple-darwin
           - os: windows-latest
             target: x86_64-pc-windows-msvc
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -122,14 +123,14 @@ jobs:
       - name: Run ${{ matrix.lua }} tests
         run: |
           cargo test --features "${{ matrix.lua }},vendored"
-          cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
-          cargo test --features "${{ matrix.lua }},vendored,async,serialize,macros,parking_lot,unstable"
+          cargo test --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers"
+          cargo test --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers,send"
         shell: bash
       - name: Run compile tests (macos lua54)
         if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua54' }}
         run: |
           TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored" -- --ignored
-          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable" -- --ignored
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros" -- --ignored
         shell: bash
 
   test_with_sanitizer:
@@ -138,14 +139,14 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-22.04]
+        os: [ubuntu-latest]
         rust: [nightly]
         lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
         include:
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -153,27 +154,54 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - name: Run ${{ matrix.lua }} tests with address sanitizer
         run: |
-            cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers,send" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
         shell: bash
         env:
           RUSTFLAGS: -Z sanitizer=address
 
+  test_with_memory_limit:
+    name: Test with memory limit
+    runs-on: ${{ matrix.os }}
+    needs: build
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        rust: [nightly]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+    steps:
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Run ${{ matrix.lua }} tests with forced memory limit
+        run: |
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
+        shell: bash
+        env:
+          RUSTFLAGS: --cfg=force_memory_limit
+
   test_modules:
     name: Test modules
     runs-on: ${{ matrix.os }}
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-22.04, macos-latest]
+        os: [ubuntu-latest, macos-latest]
         rust: [stable]
         lua: [lua54, lua53, lua52, lua51, luajit, luau]
         include:
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
           - os: macos-latest
             target: x86_64-apple-darwin
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ matrix.rust }}
@@ -197,7 +225,7 @@ jobs:
         shell: msys2 {0}
     steps:
       - uses: msys2/setup-msys2@v2
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - 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
@@ -208,13 +236,13 @@ jobs:
 
   test_wasm32_emscripten:
     name: Test on wasm32-unknown-emscripten
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luau]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
@@ -226,28 +254,26 @@ jobs:
       - 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"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,anyhow,userdata-wrappers"
 
   rustfmt:
     name: Rustfmt
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@nightly
         with:
-          toolchain: stable
           components: rustfmt
       - run: cargo fmt -- --check
 
   clippy:
     name: Clippy
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: nightly
@@ -255,4 +281,4 @@ jobs:
       - uses: giraffate/clippy-action@v1
         with:
           reporter: 'github-pr-review'
-          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,anyhow,userdata-wrappers"

CHANGELOG.md

@@ -1,3 +1,99 @@
+## v0.10.4 (May 5th, 2025)
+
+- Luau updated to 0.672
+- New serde option `encode_empty_tables_as_array` to serialize empty tables as arrays
+- Added `WeakLua` and `Lua::weak()` to create weak references to Lua state
+- Trigger abort when Luau userdata destructors are panic (Luau GC does not support it)
+- Added `AnyUserData::type_id()` method to get the type id of the userdata
+- Added `Chunk::name()`, `Chunk::environment()` and `Chunk::mode()` functions
+- Support borrowing underlying wrapped types for `UserDataRef` and `UserDataRefMut` (under `userdata-wrappers` feature)
+- Added large (52bit) integers support for Luau
+- Enable `serde` for `bstr` if `serialize` feature flag is enabled
+- Recursive warnings (Lua 5.4) are no longer allowed
+- Implemented `IntoLua`/`FromLua` for `BorrowedString` and `BorrowedBytes`
+- Implemented `IntoLua`/`FromLua` for `char`
+- Enable `Thread::reset()` for all Lua versions (limited support for 5.1-5.3)
+- Bugfixes and improvements
+
+## v0.10.3 (Jan 27th, 2025)
+
+- Set `Default` for `Value` to be `Nil`
+- Allow exhaustive match on `Value` (#502)
+- Add `Table::set_safeenv` method (Luau)
+
+## v0.10.2 (Dec 1st, 2024)
+
+- Switch proc-macro-error to proc-macro-error2 (#493)
+- Do not allow Lua to run GC finalizers on ref thread (#491)
+- Fix chunks loading in Luau when memory limit is enforced (#488)
+- Added `String::wrap` method to wrap arbitrary `AsRef<[u8]>` into `impl IntoLua`
+- Better FreeBSD/OpenBSD support (thanks to cos)
+- Delay "any" userdata metatable creation until first instance is created (#482)
+- Reduce amount of generated code for `UserData` (less generics)
+
+## v0.10.1 (Nov 9th, 2024)
+
+- Minimal Luau updated to 0.650
+- Added Luau native vector library support (this can change behavior if you use `vector` function!)
+- Added Lua `String::display` method
+- Improved pretty-printing for Lua tables (#478)
+- Added `Scope::create_any_userdata` to create Lua objects from any non-`'static` Rust types
+- Added `AnyUserData::destroy` method
+- New `userdata-wrappers` feature to `impl UserData` for `Rc<T>`/`Arc<T>`/`Rc<RefCell<T>>`/`Arc<Mutex<T>>` (similar to v0.9)
+- `UserDataRef` in `send` mode now uses shared lock if `T: Sync` (and exclusive lock otherwise)
+- Added `Scope::add_destructor` to attach custom destructors
+- Added `Lua::try_app_data_ref` and `Lua::try_app_data_mut` methods
+- Added `From<Vec>` and `Into<Vec>` support to `MultiValue` and `Variadic` types
+- Bug fixes and improvements (#477 #479)
+
+## v0.10.0 (Oct 25th, 2024)
+
+Changes since v0.10.0-rc.1
+
+- Added `error-send` feature flag (disabled by default) to require `Send + Sync` for `Error`
+- Some performance improvements
+
+## v0.10.0-rc.1
+
+- `Lua::scope` is back
+- Support yielding from hooks for Lua 5.3+
+- Support setting metatable for Lua builtin types (number/string/function/etc)
+- Added `LuaNativeFn`/`LuaNativeFnMut`/`LuaNativeAsyncFn` traits for using in `Function::wrap`
+- Added `Error::chain` method to return iterator over nested errors
+- Added `Lua::exec_raw` helper to execute low-level Lua C API code
+- Added `Either<L, R>` enum to combine two types into a single one
+- Added a new `Buffer` type for Luau
+- Added `Value::is_error` and `Value::as_error` helpers
+- Added `Value::Other` variant to represent unknown Lua types (eg LuaJIT CDATA)
+- Added (optional) `anyhow` feature to implement `IntoLua` for `anyhow::Error`
+- Added `IntoLua`/`FromLua` for `OsString`/`OsStr` and `PathBuf`/`Path`
+
+## v0.10.0-beta.2
+
+- Updated `ThreadStatus` enum to include `Running` and `Finished` variants.
+- `Error::CoroutineInactive` renamed to `Error::CoroutineUnresumable`.
+- `IntoLua`/`IntoLuaMulti` now uses `impl trait` syntax for args (shorten from `a.get::<_, T>` to `a.get::<T>`).
+- Removed undocumented `Lua::into_static`/`from_static` methods.
+- Futures now require `Send` bound if `send` feature is enabled.
+- Dropped lifetime from `UserDataMethods` and `UserDataFields` traits.
+- `Compiler::compile()` now returns `Result` (Luau).
+- Removed `Clone` requirement from `UserDataFields::add_field()`.
+- `TableExt` and `AnyUserDataExt` traits were combined into `ObjectLike` trait.
+- Disabled `send` feature in module mode (since we don't have exclusive access to Lua).
+- `Chunk::set_environment()` takes `Table` instead of `IntoLua` type.
+- Reduced the compile time contribution of `next_key_seed` and `next_value_seed`.
+- Reduced the compile time contribution of `serde_userdata`.
+- Performance improvements.
+
+## v0.10.0-beta.1
+
+- Dropped `'lua` lifetime (subtypes now store a weak reference to Lua)
+- Removed (experimental) owned types (they no longer needed)
+- Make Lua types truly `Send` and `Sync` (when enabling `send` feature flag)
+- Removed `UserData` impl for Rc/Arc types ("any" userdata functions can be used instead)
+- `Lua::replace_registry_value` takes `&mut RegistryKey`
+- `Lua::scope` temporary disabled (will be re-added in the next release)
+
 ## v0.9.9
 
 - Minimal Luau updated to 0.629
@@ -225,7 +321,7 @@ Other:
 
 ## v0.8.0
 Changes since 0.7.4
-- Roblox Luau support
+- Luau support
 - Removed C glue
 - Added async support to `__index` and `__newindex` metamethods
 - Added `Function::info()` to get information about functions (#149).
@@ -275,7 +371,7 @@ Breaking changes:
 
 ## v0.8.0-beta.1
 
-- Roblox Luau support
+- Luau support
 - Refactored ffi module. C glue is no longer required
 - Added async support to `__index` and `__newindex` metamethods
 
@@ -388,7 +484,7 @@ Breaking changes:
 - [**Breaking**] Removed `AnyUserData::has_metamethod()`
 - Added `Thread::reset()` for luajit/lua54 to recycle threads.
   It's possible to attach a new function to a thread (coroutine).
-- Added `chunk!` macro support to load chunks of Lua code using the Rust tokenizer and optinally capturing Rust variables.
+- Added `chunk!` macro support to load chunks of Lua code using the Rust tokenizer and optionally capturing Rust variables.
 - Improved error reporting (`Error`'s `__tostring` method formats full stacktraces). This is useful in the module mode.
 
 ## v0.6.0-beta.1
@@ -444,7 +540,7 @@ Breaking changes:
 
 - Lua 5.4 support with `MetaMethod::Close`.
 - `lua53` feature is disabled by default. Now preferred Lua version have to be chosen explicitly.
-- Provide safety guaraness for Lua state, which means that potenially unsafe operations, like loading C modules (using `require` or `package.loadlib`) are disabled. Equalient for the previous `Lua::new()` function is `Lua::unsafe_new()`.
+- Provide safety guarantees for Lua state, which means that potentially unsafe operations, like loading C modules (using `require` or `package.loadlib`) are disabled. Equivalent to the previous `Lua::new()` function is `Lua::unsafe_new()`.
 - New `send` feature to require `Send`.
 - New `module` feature, that disables linking to Lua Core Libraries. Required for modules.
 - Don't allow `'callback` outlive `'lua` in `Lua::create_function()` to fix [the unsoundness](tests/compile/static_callback_args.rs).

Cargo.toml

@@ -1,22 +1,22 @@
 [package]
 name = "mlua"
-version = "0.9.9" # remember to update mlua_derive
+version = "0.10.4" # remember to update mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
-rust-version = "1.71"
+rust-version = "1.79.0"
 edition = "2021"
-repository = "https://github.com/khvzak/mlua"
+repository = "https://github.com/mlua-rs/mlua"
 documentation = "https://docs.rs/mlua"
 readme = "README.md"
 keywords = ["lua", "luajit", "luau", "async", "scripting"]
 categories = ["api-bindings", "asynchronous"]
 license = "MIT"
 description = """
-High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau
 with async/await features and support of writing native Lua modules in Rust.
 """
 
 [package.metadata.docs.rs]
-features = ["lua54", "vendored", "async", "send", "serialize", "macros", "parking_lot", "unstable"]
+features = ["lua54", "vendored", "async", "send", "serialize", "macros"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [workspace]
@@ -38,31 +38,34 @@ luau-vector4 = ["luau", "ffi/luau-vector4"]
 vendored = ["ffi/vendored"]
 module = ["dep:mlua_derive", "ffi/module"]
 async = ["dep:futures-util"]
-send = []
-serialize = ["dep:serde", "dep:erased-serde", "dep:serde-value"]
+send = ["parking_lot/send_guard", "error-send"]
+error-send = []
+serialize = ["dep:serde", "dep:erased-serde", "dep:serde-value", "bstr/serde"]
 macros = ["mlua_derive/macros"]
-unstable = []
+anyhow = ["dep:anyhow", "error-send"]
+userdata-wrappers = []
 
 [dependencies]
-mlua_derive = { version = "=0.9.3", optional = true, path = "mlua_derive" }
+mlua_derive = { version = "=0.10.1", optional = true, path = "mlua_derive" }
 bstr = { version = "1.0", features = ["std"], default-features = false }
-once_cell = { version = "1.0" }
+either = "1.0"
 num-traits = { version = "0.2.14" }
 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.4", optional = true }
 serde-value = { version = "0.7", optional = true }
-parking_lot = { version = "0.12", optional = true }
+parking_lot = { version = "0.12", features = ["arc_lock"] }
+anyhow = { version = "1.0", optional = true }
+rustversion = "1.0"
 
-ffi = { package = "mlua-sys", version = "0.6.1", path = "mlua-sys" }
+ffi = { package = "mlua-sys", version = "0.7.0", path = "mlua-sys" }
 
 [target.'cfg(unix)'.dependencies]
 libloading = { version = "0.8", optional = true }
 
 [dev-dependencies]
 trybuild = "1.0"
-futures = "0.3.5"
 hyper = { version = "1.2", features = ["full"] }
 hyper-util = { version = "0.1.3", features = ["full"] }
 http-body-util = "0.1.1"
@@ -76,7 +79,7 @@ static_assertions = "1.0"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 criterion = { version = "0.5", features = ["async_tokio"] }
-rustyline = "14.0"
+rustyline = "15.0"
 tokio = { version = "1.0", features = ["full"] }
 
 [lints.rust]
@@ -102,11 +105,11 @@ required-features = ["async", "serialize", "macros"]
 
 [[example]]
 name = "async_http_server"
-required-features = ["async", "macros"]
+required-features = ["async", "macros", "send"]
 
 [[example]]
 name = "async_tcp_server"
-required-features = ["async", "macros"]
+required-features = ["async", "macros", "send"]
 
 [[example]]
 name = "guided_tour"

README.md

@@ -1,15 +1,15 @@
 # mlua
 [![Build Status]][github-actions] [![Latest Version]][crates.io] [![API Documentation]][docs.rs] [![Coverage Status]][codecov.io] ![MSRV]
 
-[Build Status]: https://github.com/khvzak/mlua/workflows/CI/badge.svg
-[github-actions]: https://github.com/khvzak/mlua/actions
+[Build Status]: https://github.com/mlua-rs/mlua/workflows/CI/badge.svg
+[github-actions]: https://github.com/mlua-rs/mlua/actions
 [Latest Version]: https://img.shields.io/crates/v/mlua.svg
 [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/mlua-rs/mlua/branch/main/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
+[MSRV]: https://img.shields.io/badge/rust-1.79+-brightgreen.svg?&logo=rust
 
 [Guided Tour] | [Benchmarks] | [FAQ]
 
@@ -19,19 +19,19 @@
 
 > **Note**
 >
-> See v0.9 [release notes](https://github.com/khvzak/mlua/blob/main/docs/release_notes/v0.9.md).
+> See v0.10 [release notes](https://github.com/mlua-rs/mlua/blob/main/docs/release_notes/v0.10.md).
 
 `mlua` is bindings to [Lua](https://www.lua.org) programming language for Rust with a goal to provide
 _safe_ (as far as it's possible), high level, easy to use, practical and flexible API.
 
-Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Roblox Luau] and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.
+Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Luau] and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.
 
 `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.
+WebAssembly (WASM) is supported through `wasm32-unknown-emscripten` target for all Lua/Luau versions excluding JIT.
 
-[GitHub Actions]: https://github.com/khvzak/mlua/actions
-[Roblox Luau]: https://luau-lang.org
+[GitHub Actions]: https://github.com/mlua-rs/mlua/actions
+[Luau]: https://luau.org
 
 ## Usage
 
@@ -40,37 +40,37 @@ WebAssembly (WASM) is supported through `wasm32-unknown-emscripten` target for a
 `mlua` uses feature flags to reduce the amount of dependencies, compiled code and allow to choose only required set of features.
 Below is a list of the available feature flags. By default `mlua` does not enable any features.
 
-* `lua54`: activate Lua [5.4] support
-* `lua53`: activate Lua [5.3] support
-* `lua52`: activate Lua [5.2] support
-* `lua51`: activate Lua [5.1] support
-* `luajit`: activate [LuaJIT] support
-* `luajit52`: activate [LuaJIT] support with partial compatibility with Lua 5.2
-* `luau`: activate [Luau] support (auto vendored mode)
-* `luau-jit`: activate [Luau] support with JIT backend.
-* `luau-vector4`: activate [Luau] support with 4-dimensional vector.
+* `lua54`: enable Lua [5.4] support
+* `lua53`: enable Lua [5.3] support
+* `lua52`: enable Lua [5.2] support
+* `lua51`: enable Lua [5.1] support
+* `luajit`: enable [LuaJIT] support
+* `luajit52`: enable [LuaJIT] support with partial compatibility with Lua 5.2
+* `luau`: enable [Luau] support (auto vendored mode)
+* `luau-jit`: enable [Luau] support with JIT backend.
+* `luau-vector4`: enable [Luau] support with 4-dimensional vector.
 * `vendored`: build static Lua(JIT) library from sources during `mlua` compilation using [lua-src] or [luajit-src] crates
 * `module`: enable module mode (building loadable `cdylib` library for Lua)
 * `async`: enable async/await support (any executor can be used, eg. [tokio] or [async-std])
-* `send`: make `mlua::Lua` transferable across thread boundaries (adds [`Send`] requirement to `mlua::Function` and `mlua::UserData`)
+* `send`: make `mlua::Lua: Send + Sync` (adds [`Send`] requirement to `mlua::Function` and `mlua::UserData`)
+* `error-send`: make `mlua:Error: Send + Sync`
 * `serialize`: add serialization and deserialization support to `mlua` types using [serde] framework
 * `macros`: enable procedural macros (such as `chunk!`)
-* `parking_lot`: support UserData types wrapped in [parking_lot]'s primitives (`Arc<Mutex>` and `Arc<RwLock>`)
-* `unstable`: enable **unstable** features. The public API of these features may break between releases.
+* `anyhow`: enable `anyhow::Error` conversion into Lua
+* `userdata-wrappers`: opt into `impl UserData` for `Rc<T>`/`Arc<T>`/`Rc<RefCell<T>>`/`Arc<Mutex<T>>` where `T: UserData`
 
 [5.4]: https://www.lua.org/manual/5.4/manual.html
 [5.3]: https://www.lua.org/manual/5.3/manual.html
 [5.2]: https://www.lua.org/manual/5.2/manual.html
 [5.1]: https://www.lua.org/manual/5.1/manual.html
 [LuaJIT]: https://luajit.org/
-[Luau]: https://github.com/Roblox/luau
-[lua-src]: https://github.com/khvzak/lua-src-rs
-[luajit-src]: https://github.com/khvzak/luajit-src-rs
+[Luau]: https://github.com/luau-lang/luau
+[lua-src]: https://github.com/mlua-rs/lua-src-rs
+[luajit-src]: https://github.com/mlua-rs/luajit-src-rs
 [tokio]: https://github.com/tokio-rs/tokio
 [async-std]: https://github.com/async-rs/async-std
 [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
 [serde]: https://github.com/serde-rs/serde
-[parking_lot]: https://github.com/Amanieu/parking_lot
 
 ### Async/await support
 
@@ -94,7 +94,7 @@ cargo run --example async_http_client --features=lua54,async,macros
 cargo run --example async_http_reqwest --features=lua54,async,macros,serialize
 
 # async http server
-cargo run --example async_http_server --features=lua54,async,macros
+cargo run --example async_http_server --features=lua54,async,macros,send
 curl -v http://localhost:3000
 ```
 
@@ -133,7 +133,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.9.9", features = ["lua54", "vendored"] }
+mlua = { version = "0.10", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -168,7 +168,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.9.9", features = ["lua54", "module"] }
+mlua = { version = "0.10", features = ["lua54", "module"] }
 ```
 
 `lib.rs` :
@@ -198,7 +198,7 @@ $ lua5.4 -e 'require("my_module").hello("world")'
 hello, world!
 ```
 
-On macOS, you need to set additional linker arguments. One option is to compile with `cargo rustc --release -- -C link-arg=-undefined -C link-arg=dynamic_lookup`, the other is to create a `.cargo/config` with the following content:
+On macOS, you need to set additional linker arguments. One option is to compile with `cargo rustc --release -- -C link-arg=-undefined -C link-arg=dynamic_lookup`, the other is to create a `.cargo/config.toml` with the following content:
 ``` toml
 [target.x86_64-apple-darwin]
 rustflags = [
@@ -291,7 +291,7 @@ Please check the [Luau Sandboxing] page if you are interested in running untrust
 
 `mlua` provides `Lua::sandbox` method for enabling sandbox mode (Luau only).
 
-[Luau Sandboxing]: https://luau-lang.org/sandbox
+[Luau Sandboxing]: https://luau.org/sandbox
 
 ## License
 

benches/benchmark.rs

@@ -74,7 +74,7 @@ fn table_get_set(c: &mut Criterion) {
                     .enumerate()
                 {
                     table.raw_set(s, i).unwrap();
-                    assert_eq!(table.raw_get::<_, usize>(s).unwrap(), i);
+                    assert_eq!(table.raw_get::<usize>(s).unwrap(), i);
                 }
             },
             BatchSize::SmallInput,
@@ -153,7 +153,7 @@ fn function_call_sum(c: &mut Criterion) {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                assert_eq!(sum.call::<_, i64>((10, 20, 30)).unwrap(), 0);
+                assert_eq!(sum.call::<i64>((10, 20, 30)).unwrap(), 0);
             },
             BatchSize::SmallInput,
         );
@@ -172,7 +172,7 @@ fn function_call_lua_sum(c: &mut Criterion) {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                assert_eq!(sum.call::<_, i64>((10, 20, 30)).unwrap(), 0);
+                assert_eq!(sum.call::<i64>((10, 20, 30)).unwrap(), 0);
             },
             BatchSize::SmallInput,
         );
@@ -183,9 +183,7 @@ 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()?))
-        })
+        .create_function(|_, (a, b): (LuaString, LuaString)| Ok(format!("{}{}", a.to_str()?, b.to_str()?)))
         .unwrap();
     let i = AtomicUsize::new(0);
 
@@ -196,10 +194,7 @@ fn function_call_concat(c: &mut Criterion) {
                 i.fetch_add(1, Ordering::Relaxed)
             },
             |i| {
-                assert_eq!(
-                    concat.call::<_, LuaString>(("num:", i)).unwrap(),
-                    format!("num:{i}")
-                );
+                assert_eq!(concat.call::<LuaString>(("num:", i)).unwrap(), format!("num:{i}"));
             },
             BatchSize::SmallInput,
         );
@@ -222,10 +217,7 @@ fn function_call_lua_concat(c: &mut Criterion) {
                 i.fetch_add(1, Ordering::Relaxed)
             },
             |i| {
-                assert_eq!(
-                    concat.call::<_, LuaString>(("num:", i)).unwrap(),
-                    format!("num:{i}")
-                );
+                assert_eq!(concat.call::<LuaString>(("num:", i)).unwrap(), format!("num:{i}"));
             },
             BatchSize::SmallInput,
         );
@@ -248,7 +240,7 @@ fn function_async_call_sum(c: &mut Criterion) {
         b.to_async(rt).iter_batched(
             || collect_gc_twice(&lua),
             |_| async {
-                assert_eq!(sum.call_async::<_, i64>((10, 20, 30)).await.unwrap(), 0);
+                assert_eq!(sum.call_async::<i64>((10, 20, 30)).await.unwrap(), 0);
             },
             BatchSize::SmallInput,
         );
@@ -305,7 +297,7 @@ fn userdata_create(c: &mut Criterion) {
 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) {
+        fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
             methods.add_meta_method(LuaMetaMethod::Index, move |_, _, key: LuaString| Ok(key));
         }
     }
@@ -321,7 +313,7 @@ fn userdata_call_index(c: &mut Criterion) {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                assert_eq!(index.call::<_, LuaString>(&ud).unwrap(), "test");
+                assert_eq!(index.call::<LuaString>(&ud).unwrap(), "test");
             },
             BatchSize::SmallInput,
         );
@@ -331,7 +323,7 @@ fn userdata_call_index(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) {
+        fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
             methods.add_method("add", |_, this, i: i64| Ok(this.0 + i));
         }
     }
@@ -351,7 +343,7 @@ fn userdata_call_method(c: &mut Criterion) {
                 i.fetch_add(1, Ordering::Relaxed)
             },
             |i| {
-                assert_eq!(method.call::<_, usize>((&ud, i)).unwrap(), 123 + i);
+                assert_eq!(method.call::<usize>((&ud, i)).unwrap(), 123 + i);
             },
             BatchSize::SmallInput,
         );
@@ -361,7 +353,7 @@ fn userdata_call_method(c: &mut Criterion) {
 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) {
+        fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
             methods.add_async_method("add", |_, this, i: i64| async move {
                 task::yield_now().await;
                 Ok(this.0 + i)
@@ -383,17 +375,10 @@ fn userdata_async_call_method(c: &mut Criterion) {
         b.to_async(rt).iter_batched(
             || {
                 collect_gc_twice(&lua);
-                (
-                    method.clone(),
-                    ud.clone(),
-                    i.fetch_add(1, Ordering::Relaxed),
-                )
+                (method.clone(), ud.clone(), i.fetch_add(1, Ordering::Relaxed))
             },
             |(method, ud, i)| async move {
-                assert_eq!(
-                    method.call_async::<_, usize>((ud, i)).await.unwrap(),
-                    123 + i
-                );
+                assert_eq!(method.call_async::<usize>((ud, i)).await.unwrap(), 123 + i);
             },
             BatchSize::SmallInput,
         );

benches/serde.rs

@@ -37,7 +37,7 @@ fn encode_json(c: &mut Criterion) {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                encode.call::<_, LuaString>(&table).unwrap();
+                encode.call::<LuaString>(&table).unwrap();
             },
             BatchSize::SmallInput,
         );
@@ -69,7 +69,7 @@ fn decode_json(c: &mut Criterion) {
         b.iter_batched(
             || collect_gc_twice(&lua),
             |_| {
-                decode.call::<_, LuaTable>(json).unwrap();
+                decode.call::<LuaTable>(json).unwrap();
             },
             BatchSize::SmallInput,
         );

docs/release_notes/v0.10.md

@@ -0,0 +1,195 @@
+## mlua v0.10 release notes
+
+The v0.10 version of mlua has goal to improve the user experience while keeping the same performance and safety guarantees.
+This document highlights the most notable features. For a full list of changes, see the [CHANGELOG].
+
+[CHANGELOG]: https://github.com/mlua-rs/mlua/blob/main/CHANGELOG.md
+
+### New features
+
+#### `'static` Lua types
+
+In previous mlua versions, it was required to have a `'lua` lifetime attached to every Lua value. v0.9 introduced (experimental) owned types that are `'static` without a lifetime attached, but they kept strong references to the Lua instance.
+In v0.10 all Lua types are `'static` and have only weak reference to the Lua instance. It means they are more flexible and can be used in more places without worrying about memory leaks.
+
+#### Truly `send` feature
+
+In this version Lua is `Send + Sync` when the `send` feature flag is enabled (previously was only `Send`). It means Lua instance and their values can be safely shared between threads and used in multi threaded async contexts.
+
+```rust
+let lua = Lua::new();
+
+lua.globals().set("i", 0)?;
+let func = lua.load("i = i + ...").into_function()?;
+
+std::thread::scope(|s| {
+    s.spawn(|| {
+        for i in 0..5 {
+            func.call::<()>(i).unwrap();
+        }
+    });
+    s.spawn(|| {
+        for i in 0..5 {
+            func.call::<()>(i).unwrap();
+        }
+    });
+});
+
+assert_eq!(lua.globals().get::<i32>("i")?, 20);
+```
+
+Under the hood, to synchronize access to the Lua state, mlua uses [`ReentrantMutex`] which can be recursively locked by a single thread. Only one thread can execute Lua code at a time, but it's possible to share Lua values between threads.
+
+This has some performance penalties (about 10-20%) compared to the lock free mode. This flag is disabled by default and does not supported in module mode.
+
+[`ReentrantMutex`]: https://docs.rs/parking_lot/latest/parking_lot/type.ReentrantMutex.html
+
+#### Register Rust functions with variable number of arguments
+
+The new traits `LuaNativeFn`/`LuaNativeFnMut`/`LuaNativeAsyncFn` have been introduced to provide a way to register Rust functions with variable number of arguments in Lua, without needing to pass all arguments as a tuple.
+
+They are used by `Function::wrap`/`Function::wrap_mut`/`Function::wrap_async` methods:
+
+```rust
+let add = Function::wrap(|a: i64, b: i64| Ok(a + b));
+
+lua.globals().set("add", add).unwrap();
+
+// Prints 50
+lua.load(r#"print(add(5, 45))"#).exec().unwrap();
+```
+
+To wrap functions that return direct value (non-`Result`) you can use `Function::wrap_raw` method.
+
+#### Setting metatable for Lua builtin types
+
+For Lua builtin types (like `string`, `function`, `number`, etc.) that have a shared metatable for all instances, it's now possible to set a custom metatable for them.
+
+```rust
+let mt = lua.create_table()?;
+mt.set("__tostring", lua.create_function(|_, b: bool| Ok(if b { "2" } else { "0" }))?)?;
+lua.set_type_metatable::<bool>(Some(mt));
+lua.load("assert(tostring(true) == '2')").exec().unwrap();
+```
+
+### Improvements
+
+#### New `ObjectLike` trait
+
+The `ObjectLike` trait is a combination of the `AnyUserDataExt` and `TableExt` traits used in previous versions. It provides a unified interface for working with Lua tables and userdata.
+
+#### `Either<L, R>` enum
+
+The `Either<L, R>` enum is a simple enum that can hold either `L` or `R` value. It's useful when you need to return or receive one of two types in a function.
+This type implements `IntoLua` and `FromLua` traits and can generate a meaningful error message when conversion fails.
+
+```rust
+let func = Function::wrap(|x: Either<i32, String>| Ok(format!("received: {x}")));
+
+lua.globals().set("func", func).unwrap();
+
+// Prints: received: 123
+lua.load(r#"print(func(123))"#).exec().unwrap();
+
+// Prints: bad argument #1: error converting Lua table to Either<i32, String>
+lua.load(r#"print(pcall(func, {}))"#).exec().unwrap();
+```
+
+#### `Lua::exec_raw` helper to execute low-level Lua C API code
+
+For advanced users, it's now possible to execute low-level Lua C API code using the `Lua::exec_raw` method.
+
+```rust
+let t = lua.create_sequence_from([1, 2, 3, 4, 5])?;
+let sum: i64 = unsafe {
+    lua.exec_raw(&t, |state| {
+        // top of the stack: table `t`
+        let mut sum = 0;
+        // push nil as the first key
+        mlua::ffi::lua_pushnil(state);
+        while mlua::ffi::lua_next(state, -2) != 0 {
+            sum += mlua::ffi::lua_tointeger(state, -1);
+            // Remove the value, keep the key for the next iteration
+            mlua::ffi::lua_pop(state, 1);
+        }
+        mlua::ffi::lua_pop(state, 1);
+        mlua::ffi::lua_pushinteger(state, sum);
+        // top of the stack: sum
+    })
+}?;
+assert_eq!(sum, 15);
+```
+
+The `exec_raw` method is longjmp-safe. It's not recommended to move `Drop` types into the closure to avoid possible memory leaks.
+
+#### `anyhow` feature flag
+
+The new `anyhow` feature flag adds `IntoLua` and `Into<mlua::Error>` implementation for the `anyhow::Error` type.
+
+```rust
+let f = lua.create_function(|_, ()| {
+    Err(anyhow!("error message"))?;
+    Ok(())
+})?;
+```
+
+### Breaking changes
+
+#### Scope changes
+
+The following `Scope` methods were changed:
+- Removed `Scope::create_any_userdata`
+- `Scope::create_nonstatic_userdata` is renamed to `Scope::create_userdata`
+
+Instead, scope has comprehensive support for borrowed userdata: `create_any_userdata_ref`, `create_any_userdata_ref_mut`, `create_userdata_ref`, `create_userdata_ref_mut`.
+
+`UserDataRef` and `UserDataRefMut` are no longer acceptable for scoped userdata access as they require owned underlying data.
+In mlua v0.9 this can cause read-after-free bug in some edge cases.
+
+To temporarily borrow underlying data, the `AnyUserData::borrow_scoped` and `AnyUserData::borrow_mut_scoped` methods were introduced:
+
+```rust
+let data = "hello".to_string();
+lua.scope(|scope| {
+    let ud = scope.create_any_userdata_ref(&data)?;
+
+    // We can only borrow scoped userdata using this method
+    ud.borrow_scoped::<String, ()>(|s| {
+        assert_eq!(s, "hello");
+    })?;
+
+    Ok(())
+})?;
+```
+
+Those methods work for scoped and regular userdata objects (but still require `T: 'static`).
+
+#### String changes
+
+Since `mlua::String` holds a weak reference to Lua without any guarantees about the lifetime of the underlying data, getting a `&str` or `&[u8]` from it is no longer safe.
+Lua instance can be destroyed while reference to the data is still alive:
+
+```rust
+let lua = Lua::new();
+let s: mlua::String = lua.create_string("hello, world")?; // only weak reference to Lua!
+let s_ref: &str = s.to_str()?; // this is not safe!
+drop(lua);
+println!("{s_ref}"); // use after free!
+```
+
+To solve this issue, return types of `mlua::String::to_str` and `mlua::String::as_bytes` methods changed to `BorrowedStr` and `BorrowedBytes` respectively.
+
+These new types hold a strong reference to the Lua instance and can be safely converted to `&str` or `&[u8]`:
+
+```rust
+let lua = Lua::new();
+let s: mlua::String = lua.create_string("hello, world")?;
+let s_ref: mlua::BorrowedStr = s.to_str()?; // The strong reference to Lua is held here
+drop(lua);
+println!("{s_ref}"); // ok
+```
+
+The good news is that `BorrowedStr` implements `Deref<Target = str>`/`AsRef<str>` as well as `Display`, `Debug`, `Eq`, `PartialEq` and other traits for easy usage.
+The same applies to `BorrowedBytes`.
+
+Unfortunately, `mlua::String::to_string_lossy` cannot return `Cow<'a, str>` anymore, because it requires a strong reference to Lua. It now returns Rust `String` instead.

docs/release_notes/v0.9.md

@@ -3,7 +3,7 @@
 The v0.9 version of mlua is a major release that includes a number of API changes and improvements. This release is a stepping stone towards the v1.0.
 This document highlights the most important changes. For a full list of changes, see the [CHANGELOG].
 
-[CHANGELOG]: https://github.com/khvzak/mlua/blob/main/CHANGELOG.md
+[CHANGELOG]: https://github.com/mlua-rs/mlua/blob/main/CHANGELOG.md
 
 ### New features
 
@@ -304,7 +304,7 @@ assert_eq!(f.call::<_, mlua::String>(())?, "hello");
 
 The new mlua version has a number of performance improvements. Please check the [benchmarks results] to see how mlua compares to rlua and rhai.
 
-[benchmarks results]: https://github.com/khvzak/script-bench-rs
+[benchmarks results]: https://github.com/mlua-rs/script-bench-rs
 
 ### Changes in `module` mode
 

examples/async_http_client.rs

@@ -10,9 +10,9 @@ use mlua::{chunk, ExternalResult, Lua, Result, UserData, UserDataMethods};
 struct BodyReader(Incoming);
 
 impl UserData for BodyReader {
-    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+    fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
         // Every call returns a next chunk
-        methods.add_async_method_mut("read", |lua, reader, ()| async move {
+        methods.add_async_method_mut("read", |lua, mut reader, ()| async move {
             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();

examples/async_http_server.rs

@@ -1,27 +1,23 @@
 use std::convert::Infallible;
 use std::future::Future;
 use std::net::SocketAddr;
-use std::rc::Rc;
+use std::pin::Pin;
 
-use futures::future::LocalBoxFuture;
-use http_body_util::{combinators::BoxBody, BodyExt as _, Empty, Full};
+use http_body_util::combinators::BoxBody;
+use http_body_util::{BodyExt as _, Empty, Full};
 use hyper::body::{Bytes, Incoming};
+use hyper::server::conn::http1;
 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, RegistryKey, String as LuaString, Table, UserData,
-    UserDataMethods,
-};
+use mlua::{chunk, Error as LuaError, Function, Lua, String as LuaString, Table, UserData, UserDataMethods};
 
 /// 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) {
+    fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
         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()));
@@ -31,50 +27,43 @@ impl UserData for LuaRequest {
 /// Service that handles incoming requests
 #[derive(Clone)]
 pub struct Svc {
-    lua: Rc<Lua>,
-    handler: Rc<RegistryKey>,
+    handler: Function,
     peer_addr: SocketAddr,
 }
 
 impl Svc {
-    pub fn new(lua: Rc<Lua>, handler: Rc<RegistryKey>, peer_addr: SocketAddr) -> Self {
-        Self {
-            lua,
-            handler,
-            peer_addr,
-        }
+    pub fn new(handler: Function, peer_addr: SocketAddr) -> Self {
+        Self { handler, peer_addr }
     }
 }
 
 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>>;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
 
     fn call(&self, req: Request<Incoming>) -> Self::Future {
         // If handler returns an error then generate 5xx response
-        let lua = self.lua.clone();
-        let handler_key = self.handler.clone();
+        let handler = self.handler.clone();
         let lua_req = LuaRequest(self.peer_addr, req);
         Box::pin(async move {
-            let handler: Function = lua.registry_value(&handler_key)?;
-            match handler.call_async::<_, Table>(lua_req).await {
+            match handler.call_async::<Table>(lua_req).await {
                 Ok(lua_resp) => {
-                    let status = lua_resp.get::<_, Option<u16>>("status")?.unwrap_or(200);
+                    let status = lua_resp.get::<Option<u16>>("status")?.unwrap_or(200);
                     let mut resp = Response::builder().status(status);
 
                     // Set headers
-                    if let Some(headers) = lua_resp.get::<_, Option<Table>>("headers")? {
+                    if let Some(headers) = lua_resp.get::<Option<Table>>("headers")? {
                         for pair in headers.pairs::<String, LuaString>() {
                             let (h, v) = pair?;
-                            resp = resp.header(&h, v.as_bytes());
+                            resp = resp.header(&h, &*v.as_bytes());
                         }
                     }
 
                     // Set body
                     let body = lua_resp
-                        .get::<_, Option<LuaString>>("body")?
-                        .map(|b| Full::new(Bytes::copy_from_slice(b.as_bytes())).boxed())
+                        .get::<Option<LuaString>>("body")?
+                        .map(|b| Full::new(Bytes::copy_from_slice(&b.as_bytes())).boxed())
                         .unwrap_or_else(|| Empty::<Bytes>::new().boxed());
 
                     Ok(resp.body(body).unwrap())
@@ -93,10 +82,10 @@ impl hyper::service::Service<Request<Incoming>> for Svc {
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
-    let lua = Rc::new(Lua::new());
+    let lua = Lua::new();
 
     // Create Lua handler function
-    let handler: RegistryKey = lua
+    let handler = lua
         .load(chunk! {
             function(req)
                 return {
@@ -110,15 +99,13 @@ async fn main() {
                 }
             end
         })
-        .eval()
+        .eval::<Function>()
         .expect("Failed to create Lua handler");
-    let handler = Rc::new(handler);
 
     let listen_addr = "127.0.0.1:3000";
     let listener = TcpListener::bind(listen_addr).await.unwrap();
     println!("Listening on http://{listen_addr}");
 
-    let local = LocalSet::new();
     loop {
         let (stream, peer_addr) = match listener.accept().await {
             Ok(x) => x,
@@ -128,29 +115,14 @@ async fn main() {
             }
         };
 
-        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;
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-struct LocalExec;
-
-impl<F> hyper::rt::Executor<F> for LocalExec
-where
-    F: Future + 'static, // not requiring `Send`
-{
-    fn execute(&self, fut: F) {
-        tokio::task::spawn_local(fut);
+        let svc = Svc::new(handler.clone(), peer_addr);
+        tokio::task::spawn(async move {
+            if let Err(err) = http1::Builder::new()
+                .serve_connection(TokioIo::new(stream), svc)
+                .await
+            {
+                eprintln!("Error serving connection: {:?}", err);
+            }
+        });
     }
 }

examples/async_tcp_server.rs

@@ -1,48 +1,42 @@
 use std::io;
 use std::net::SocketAddr;
-use std::rc::Rc;
 
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
-use tokio::task;
 
-use mlua::{chunk, Function, Lua, RegistryKey, String as LuaString, UserData, UserDataMethods};
+use mlua::{chunk, BString, Function, Lua, UserData, UserDataMethods};
 
 struct LuaTcpStream(TcpStream);
 
 impl UserData for LuaTcpStream {
-    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("peer_addr", |_, this, ()| {
-            Ok(this.0.peer_addr()?.to_string())
-        });
+    fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
+        methods.add_method("peer_addr", |_, this, ()| Ok(this.0.peer_addr()?.to_string()));
 
-        methods.add_async_method_mut("read", |lua, this, size| async move {
+        methods.add_async_method_mut("read", |lua, mut this, size| async move {
             let mut buf = vec![0; size];
             let n = this.0.read(&mut buf).await?;
             buf.truncate(n);
             lua.create_string(&buf)
         });
 
-        methods.add_async_method_mut("write", |_, this, data: LuaString| async move {
-            let n = this.0.write(&data.as_bytes()).await?;
+        methods.add_async_method_mut("write", |_, mut this, data: BString| async move {
+            let n = this.0.write(&data).await?;
             Ok(n)
         });
 
-        methods.add_async_method_mut("close", |_, this, ()| async move {
+        methods.add_async_method_mut("close", |_, mut this, ()| async move {
             this.0.shutdown().await?;
             Ok(())
         });
     }
 }
 
-async fn run_server(lua: Lua, handler: RegistryKey) -> io::Result<()> {
+async fn run_server(handler: Function) -> io::Result<()> {
     let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
     let listener = TcpListener::bind(addr).await.expect("cannot bind addr");
 
     println!("Listening on {}", addr);
 
-    let lua = Rc::new(lua);
-    let handler = Rc::new(handler);
     loop {
         let (stream, _) = match listener.accept().await {
             Ok(res) => res,
@@ -50,15 +44,10 @@ async fn run_server(lua: Lua, handler: RegistryKey) -> io::Result<()> {
             Err(err) => return Err(err),
         };
 
-        let lua = lua.clone();
         let handler = handler.clone();
-        task::spawn_local(async move {
-            let handler: Function = lua
-                .registry_value(&handler)
-                .expect("cannot get Lua handler");
-
+        tokio::task::spawn(async move {
             let stream = LuaTcpStream(stream);
-            if let Err(err) = handler.call_async::<_, ()>(stream).await {
+            if let Err(err) = handler.call_async::<()>(stream).await {
                 eprintln!("{}", err);
             }
         });
@@ -70,7 +59,7 @@ async fn main() {
     let lua = Lua::new();
 
     // Create Lua handler function
-    let handler_fn = lua
+    let handler = lua
         .load(chunk! {
             function(stream)
                 local peer_addr = stream:peer_addr()
@@ -92,15 +81,7 @@ async fn main() {
         .eval::<Function>()
         .expect("cannot create Lua handler");
 
-    // Store it in the Registry
-    let handler = lua
-        .create_registry_value(handler_fn)
-        .expect("cannot store Lua handler");
-
-    task::LocalSet::new()
-        .run_until(run_server(lua, handler))
-        .await
-        .expect("cannot run server")
+    run_server(handler).await.expect("cannot run server")
 }
 
 fn is_transient_error(e: &io::Error) -> bool {

examples/guided_tour.rs

@@ -1,9 +1,7 @@
 use std::f32;
 use std::iter::FromIterator;
 
-use mlua::{
-    chunk, FromLua, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Value, Variadic,
-};
+use mlua::{chunk, FromLua, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Value, Variadic};
 
 fn main() -> Result<()> {
     // You can create a new Lua state with `Lua::new()`. This loads the default Lua std library
@@ -19,8 +17,8 @@ fn main() -> Result<()> {
     globals.set("string_var", "hello")?;
     globals.set("int_var", 42)?;
 
-    assert_eq!(globals.get::<_, String>("string_var")?, "hello");
-    assert_eq!(globals.get::<_, i64>("int_var")?, 42);
+    assert_eq!(globals.get::<String>("string_var")?, "hello");
+    assert_eq!(globals.get::<i64>("int_var")?, 42);
 
     // 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
@@ -34,7 +32,7 @@ fn main() -> Result<()> {
     )
     .set_name("example code")
     .exec()?;
-    assert_eq!(globals.get::<_, String>("global")?, "foobar");
+    assert_eq!(globals.get::<String>("global")?, "foobar");
 
     assert_eq!(lua.load("1 + 1").eval::<i32>()?, 2);
     assert_eq!(lua.load("false == false").eval::<bool>()?, true);
@@ -87,16 +85,16 @@ fn main() -> Result<()> {
     // You can load Lua functions
 
     let print: Function = globals.get("print")?;
-    print.call::<_, ()>("hello from rust")?;
+    print.call::<()>("hello from rust")?;
 
     // This API generally handles variadic using tuples. This is one way to call a function with
     // multiple parameters:
 
-    print.call::<_, ()>(("hello", "again", "from", "rust"))?;
+    print.call::<()>(("hello", "again", "from", "rust"))?;
 
     // But, you can also pass variadic arguments with the `Variadic` type.
 
-    print.call::<_, ()>(Variadic::from_iter(
+    print.call::<()>(Variadic::from_iter(
         ["hello", "yet", "again", "from", "rust"].iter().cloned(),
     ))?;
 
@@ -154,8 +152,8 @@ fn main() -> Result<()> {
     struct Vec2(f32, f32);
 
     // We can implement `FromLua` trait for our `Vec2` to return a copy
-    impl<'lua> FromLua<'lua> for Vec2 {
-        fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    impl FromLua for Vec2 {
+        fn from_lua(value: Value, _: &Lua) -> Result<Self> {
             match value {
                 Value::UserData(ud) => Ok(*ud.borrow::<Self>()?),
                 _ => unreachable!(),
@@ -164,7 +162,7 @@ fn main() -> Result<()> {
     }
 
     impl UserData for Vec2 {
-        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+        fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
             methods.add_method("magnitude", |_, vec, ()| {
                 let mag_squared = vec.0 * vec.0 + vec.1 * vec.1;
                 Ok(mag_squared.sqrt())
@@ -179,19 +177,15 @@ fn main() -> Result<()> {
     let vec2_constructor = lua.create_function(|_, (x, y): (f32, f32)| Ok(Vec2(x, y)))?;
     globals.set("vec2", vec2_constructor)?;
 
-    assert!(
-        (lua.load("(vec2(1, 2) + vec2(2, 2)):magnitude()")
-            .eval::<f32>()?
-            - 5.0)
-            .abs()
-            < f32::EPSILON
-    );
+    assert!((lua.load("(vec2(1, 2) + vec2(2, 2)):magnitude()").eval::<f32>()? - 5.0).abs() < f32::EPSILON);
 
     // Normally, Rust types passed to `Lua` must be `'static`, because there is no way to be
     // sure of their lifetime inside the Lua state. There is, however, a limited way to lift this
     // requirement. You can call `Lua::scope` to create userdata and callbacks types that only live
     // for as long as the call to scope, but do not have to be `'static` (and `Send`).
 
+    // TODO: Re-enable this
+    /*
     {
         let mut rust_val = 0;
 
@@ -213,6 +207,7 @@ fn main() -> Result<()> {
 
         assert_eq!(rust_val, 42);
     }
+    */
 
     // We were able to run our 'sketchy' function inside the scope just fine. However, if we
     // try to run our 'sketchy' function outside of the scope, the function we created will have

examples/serialize.rs

@@ -28,9 +28,14 @@ fn main() -> Result<()> {
     let globals = lua.globals();
 
     // Create Car struct from a Lua table
-    let car: Car = lua.from_value(lua.load(r#"
+    let car: Car = lua.from_value(
+        lua.load(
+            r#"
         {active = true, model = "Volkswagen Golf", transmission = "Automatic", engine = {v = 1499, kw = 90}}
-    "#).eval()?)?;
+    "#,
+        )
+        .eval()?,
+    )?;
 
     // Set it as (serializable) userdata
     globals.set("null", lua.null())?;

examples/userdata.rs

@@ -7,7 +7,7 @@ struct Rectangle {
 }
 
 impl UserData for Rectangle {
-    fn add_fields<'lua, F: mlua::UserDataFields<'lua, Self>>(fields: &mut F) {
+    fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
         fields.add_field_method_get("length", |_, this| Ok(this.length));
         fields.add_field_method_set("length", |_, this, val| {
             this.length = val;
@@ -20,7 +20,7 @@ impl UserData for Rectangle {
         });
     }
 
-    fn add_methods<'lua, M: mlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
+    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
         methods.add_method("area", |_, this, ()| Ok(this.length * this.width));
         methods.add_method("diagonal", |_, this, ()| {
             Ok((this.length.pow(2) as f64 + this.width.pow(2) as f64).sqrt())

mlua-sys/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "mlua-sys"
-version = "0.6.2"
+version = "0.7.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 rust-version = "1.71"
 edition = "2021"
-repository = "https://github.com/khvzak/mlua"
+repository = "https://github.com/mlua-rs/mlua"
 documentation = "https://docs.rs/mlua-sys"
 readme = "README.md"
 categories = ["external-ffi-bindings"]
@@ -12,7 +12,7 @@ license = "MIT"
 links = "lua"
 build = "build/main.rs"
 description = """
-Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau
 """
 
 [package.metadata.docs.rs]
@@ -38,9 +38,9 @@ module = []
 cc = "1.0"
 cfg-if = "1.0"
 pkg-config = "0.3.17"
-lua-src = { version = ">= 547.0.0, < 547.1.0", optional = true }
-luajit-src = { version = ">= 210.5.0, < 210.6.0", optional = true }
-luau0-src = { version = "0.10.0", optional = true }
+lua-src = { version = ">= 547.1.0, < 547.2.0", optional = true }
+luajit-src = { version = ">= 210.6.0, < 210.7.0", optional = true }
+luau0-src = { version = "0.14.2", optional = true }
 
 [lints.rust]
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(raw_dylib)'] }

mlua-sys/README.md

@@ -1,8 +1,8 @@
 # mlua-sys
 
-Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox [Luau].
+Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and [Luau].
 
 Intended to be consumed by the [mlua] crate.
 
-[Luau]: https://github.com/Roblox/luau
+[Luau]: https://github.com/luau-lang/luau
 [mlua]: https://crates.io/crates/mlua

mlua-sys/build/find_normal.rs

@@ -32,15 +32,19 @@ pub fn probe_lua() {
     // Find using `pkg-config`
 
     #[cfg(feature = "lua54")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", Some("lua5.4"), "5.4");
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.4", "5.5", ["lua5.4", "lua-5.4", "lua54"], "5.4");
     #[cfg(feature = "lua53")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", Some("lua5.3"), "5.3");
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.3", "5.4", ["lua5.3", "lua-5.3", "lua53"], "5.3");
     #[cfg(feature = "lua52")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", Some("lua5.2"), "5.2");
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.2", "5.3", ["lua5.2", "lua-5.2", "lua52"], "5.2");
     #[cfg(feature = "lua51")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", Some("lua5.1"), "5.1");
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.1", "5.2", ["lua5.1", "lua-5.1", "lua51"], "5.1");
     #[cfg(feature = "luajit")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("2.0.4", "2.2", None, "JIT");
+    let (incl_bound, excl_bound, alt_probe, ver) = ("2.0.4", "2.2", [], "JIT");
 
     #[rustfmt::skip]
     let mut lua = pkg_config::Config::new()
@@ -48,10 +52,16 @@ pub fn probe_lua() {
         .cargo_metadata(true)
         .probe(if cfg!(feature = "luajit") { "luajit" } else { "lua" });
 
-    if lua.is_err() && alt_probe.is_some() {
-        lua = pkg_config::Config::new()
-            .cargo_metadata(true)
-            .probe(alt_probe.unwrap());
+    if lua.is_err() {
+        for pkg in alt_probe {
+            lua = pkg_config::Config::new()
+                .cargo_metadata(true)
+                .probe(pkg);
+
+            if lua.is_ok() {
+                break;
+            }
+        }
     }
 
     lua.unwrap_or_else(|err| panic!("cannot find Lua{ver} using `pkg-config`: {err}"));

mlua-sys/src/lib.rs

@@ -1,4 +1,4 @@
-//! Low level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau.
+//! Low level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau.
 
 #![allow(non_camel_case_types, non_snake_case, dead_code)]
 #![allow(clippy::missing_safety_doc)]
@@ -54,10 +54,7 @@ pub const LUA_TRACEBACK_STACK: c_int = 11;
     target_arch = "sparc",
     target_arch = "wasm32",
     target_arch = "hexagon",
-    all(
-        target_arch = "riscv32",
-        not(any(target_os = "espidf", target_os = "zkvm"))
-    ),
+    all(target_arch = "riscv32", not(any(target_os = "espidf", target_os = "zkvm"))),
     all(target_arch = "xtensa", not(target_os = "espidf")),
 ))]
 #[doc(hidden)]

mlua-sys/src/lua51/compat.rs

@@ -2,9 +2,8 @@
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3
 
-use std::mem;
 use std::os::raw::{c_char, c_int, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 use super::lauxlib::*;
 use super::lua::*;
@@ -91,7 +90,7 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
             } else if compat53_findfield(L, objidx, level - 1) != 0 {
                 // try recursively
                 lua_remove(L, -2); // remove table (but keep name)
-                lua_pushliteral(L, ".");
+                lua_pushliteral(L, c".");
                 lua_insert(L, -2); // place '.' between the two names
                 lua_concat(L, 3);
                 return 1;
@@ -122,13 +121,13 @@ unsafe fn compat53_pushfuncname(L: *mut lua_State, ar: *mut lua_Debug) {
         lua_pushfstring(L, cstr!("function '%s'"), (*ar).name);
     } else if *(*ar).what == b'm' as c_char {
         // main?
-        lua_pushliteral(L, "main chunk");
+        lua_pushliteral(L, c"main chunk");
     } else if *(*ar).what == b'C' as c_char {
         if compat53_pushglobalfuncname(L, ar) != 0 {
             lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
             lua_remove(L, -2); // remove name
         } else {
-            lua_pushliteral(L, "?");
+            lua_pushliteral(L, c"?");
         }
     } else {
         lua_pushfstring(
@@ -177,7 +176,7 @@ pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
 #[inline(always)]
 pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {
     let abs_to = lua_absindex(L, toidx);
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_pushvalue(L, fromidx);
     lua_replace(L, abs_to);
 }
@@ -315,7 +314,7 @@ pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
 #[inline(always)]
 pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
     let abs_i = lua_absindex(L, idx);
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_pushlightuserdata(L, p as *mut c_void);
     lua_insert(L, -2);
     lua_rawset(L, abs_i);
@@ -328,12 +327,7 @@ pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) {
 }
 
 #[inline(always)]
-pub unsafe fn lua_dump(
-    L: *mut lua_State,
-    writer: lua_Writer,
-    data: *mut c_void,
-    _strip: c_int,
-) -> c_int {
+pub unsafe fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, _strip: c_int) -> c_int {
     lua_dump_(L, writer, data)
 }
 
@@ -365,12 +359,7 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
 }
 
 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    _from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+pub unsafe fn lua_resume(L: *mut lua_State, _from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
     let ret = lua_resume_(L, narg);
     if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
         *nres = lua_gettop(L);
@@ -388,7 +377,7 @@ pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char)
         if !msg.is_null() {
             luaL_error(L, cstr!("stack overflow (%s)"), msg);
         } else {
-            lua_pushliteral(L, "stack overflow");
+            lua_pushliteral(L, c"stack overflow");
             lua_error(L);
         }
     }
@@ -414,6 +403,25 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
     }
 }
 
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == LUA_OK && env != 0 {
+        lua_pushvalue(L, env);
+        lua_setfenv(L, -2);
+    }
+    status
+}
+
 #[inline(always)]
 pub unsafe fn luaL_loadbufferx(
     L: *mut lua_State,
@@ -436,7 +444,7 @@ pub unsafe fn luaL_loadbufferx(
 #[inline(always)]
 pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
     let mut isnum = 0;
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_len(L, idx);
     let res = lua_tointegerx(L, -1, &mut isnum);
     lua_pop(L, 1);
@@ -446,12 +454,7 @@ pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
     res
 }
 
-pub unsafe fn luaL_traceback(
-    L: *mut lua_State,
-    L1: *mut lua_State,
-    msg: *const c_char,
-    mut level: c_int,
-) {
+pub unsafe fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, mut level: c_int) {
     let mut ar: lua_Debug = mem::zeroed();
     let top = lua_gettop(L);
     let numlevels = compat53_countlevels(L1);
@@ -464,12 +467,12 @@ pub unsafe fn luaL_traceback(
     if !msg.is_null() {
         lua_pushfstring(L, cstr!("%s\n"), msg);
     }
-    lua_pushliteral(L, "stack traceback:");
+    lua_pushliteral(L, c"stack traceback:");
     while lua_getstack(L1, level, &mut ar) != 0 {
         level += 1;
         if level == mark {
             // too many levels?
-            lua_pushliteral(L, "\n\t..."); // add a '...'
+            lua_pushliteral(L, c"\n\t..."); // add a '...'
             level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
         } else {
             lua_getinfo(L1, cstr!("Slnt"), &mut ar);
@@ -477,7 +480,7 @@ pub unsafe fn luaL_traceback(
             if ar.currentline > 0 {
                 lua_pushfstring(L, cstr!("%d:"), ar.currentline);
             }
-            lua_pushliteral(L, " in ");
+            lua_pushliteral(L, c" in ");
             compat53_pushfuncname(L, &mut ar);
             lua_concat(L, lua_gettop(L) - top);
         }
@@ -490,16 +493,16 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
         match lua_type(L, idx) {
             LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
             }
             LUA_TSTRING | LUA_TNUMBER => {
                 lua_pushvalue(L, idx);
             }
             LUA_TBOOLEAN => {
                 if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                 } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                 }
             }
             t => {
@@ -523,14 +526,14 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
 
 #[inline(always)]
 pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     luaL_getmetatable(L, tname);
     lua_setmetatable(L, -2);
 }
 
 pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int {
     let abs_i = lua_absindex(L, idx);
-    luaL_checkstack(L, 3, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
     lua_pushstring_(L, fname);
     if lua_gettable(L, abs_i) == LUA_TTABLE {
         return 1;
@@ -543,14 +546,9 @@ pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_ch
     0
 }
 
-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
     luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
     if lua_getfield(L, -1, modname) == LUA_TNIL {
         lua_pop(L, 1);
         lua_pushcfunction(L, openf);

mlua-sys/src/lua51/lauxlib.rs

@@ -8,6 +8,9 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 // Extra error code for 'luaL_load'
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
+
 #[repr(C)]
 pub struct luaL_Reg {
     pub name: *const c_char,
@@ -63,12 +66,7 @@ extern "C-unwind" {
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
     pub fn luaL_loadfile(L: *mut lua_State, filename: *const c_char) -> c_int;
-    pub fn luaL_loadbuffer(
-        L: *mut lua_State,
-        buff: *const c_char,
-        sz: usize,
-        name: *const c_char,
-    ) -> c_int;
+    pub fn luaL_loadbuffer(L: *mut lua_State, buff: *const c_char, sz: usize, name: *const c_char) -> c_int;
     pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
 
     pub fn luaL_newstate() -> *mut lua_State;

mlua-sys/src/lua51/lua.rs

@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_void};
 use std::ptr;
@@ -83,10 +84,10 @@ pub type lua_Reader =
 pub type lua_Writer =
     unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
 extern "C-unwind" {
@@ -312,10 +313,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring_(L, s.as_ptr());
 }
 
 #[inline(always)]
@@ -379,12 +378,7 @@ extern "C-unwind" {
     pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
     pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
 
-    pub fn lua_sethook(
-        L: *mut lua_State,
-        func: Option<lua_Hook>,
-        mask: c_int,
-        count: c_int,
-    ) -> 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/lua51/lualib.rs

@@ -1,24 +1,24 @@
 //! Contains definitions from `lualib.h`.
 
-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};
 
 use super::lua::lua_State;
 
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");
 
 #[cfg(feature = "luajit")]
-pub const LUA_BITLIBNAME: &str = "bit";
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit");
 #[cfg(feature = "luajit")]
-pub const LUA_JITLIBNAME: &str = "jit";
+pub const LUA_JITLIBNAME: *const c_char = cstr!("jit");
 #[cfg(feature = "luajit")]
-pub const LUA_FFILIBNAME: &str = "ffi";
+pub const LUA_FFILIBNAME: *const c_char = cstr!("ffi");
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
 extern "C-unwind" {

mlua-sys/src/lua52/compat.rs

@@ -157,22 +157,12 @@ pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
 }
 
 #[inline(always)]
-pub unsafe fn lua_dump(
-    L: *mut lua_State,
-    writer: lua_Writer,
-    data: *mut c_void,
-    _strip: c_int,
-) -> c_int {
+pub unsafe fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, _strip: c_int) -> c_int {
     lua_dump_(L, writer, data)
 }
 
 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+pub unsafe fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
     let ret = lua_resume_(L, from, narg);
     if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
         *nres = lua_gettop(L);
@@ -209,16 +199,16 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
         match lua_type(L, idx) {
             LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
             }
             LUA_TSTRING | LUA_TNUMBER => {
                 lua_pushvalue(L, idx);
             }
             LUA_TBOOLEAN => {
                 if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                 } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                 }
             }
             t => {
@@ -240,14 +230,9 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
     lua_tolstring(L, -1, len)
 }
 
-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
     luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
     if lua_getfield(L, -1, modname) == LUA_TNIL {
         lua_pop(L, 1);
         lua_pushcfunction(L, openf);
@@ -262,3 +247,22 @@ pub unsafe fn luaL_requiref(
     }
     lua_replace(L, -2);
 }
+
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == LUA_OK && env != 0 {
+        lua_pushvalue(L, env);
+        lua_setupvalue(L, -2, 1);
+    }
+    status
+}

mlua-sys/src/lua52/lauxlib.rs

@@ -8,6 +8,12 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Un
 // Extra error code for 'luaL_load'
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
+
 #[repr(C)]
 pub struct luaL_Reg {
     pub name: *const c_char,
@@ -25,12 +31,8 @@ extern "C-unwind" {
     pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
     pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
     pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
-    pub fn luaL_optlstring(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        l: *mut usize,
-    ) -> *const c_char;
+    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
+        -> *const c_char;
     pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
     pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
     pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -71,8 +73,7 @@ extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }
 
 #[inline(always)]
@@ -109,12 +110,7 @@ extern "C-unwind" {
     pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
 
     #[link_name = "luaL_requiref"]
-    pub fn luaL_requiref_(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
+    pub fn luaL_requiref_(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }
 
 //
@@ -173,12 +169,7 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
 // luaL_opt would be implemented here but it is undocumented, so it's omitted
 
 #[inline(always)]
-pub unsafe fn luaL_loadbuffer(
-    L: *mut lua_State,
-    s: *const c_char,
-    sz: usize,
-    n: *const c_char,
-) -> c_int {
+pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
     luaL_loadbufferx(L, s, sz, n, ptr::null())
 }
 

mlua-sys/src/lua52/lua.rs

@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_uint, c_void};
 use std::ptr;
@@ -88,10 +89,10 @@ pub type lua_Reader =
 pub type lua_Writer =
     unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
 extern "C-unwind" {
@@ -222,13 +223,7 @@ extern "C-unwind" {
     //
     // 'load' and 'call' functions (load and run Lua code)
     //
-    pub fn lua_callk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    );
+    pub fn lua_callk(L: *mut lua_State, nargs: c_int, nresults: c_int, ctx: c_int, k: Option<lua_CFunction>);
     pub fn lua_pcallk(
         L: *mut lua_State,
         nargs: c_int,
@@ -266,12 +261,7 @@ extern "C-unwind" {
     //
     // Coroutine functions
     //
-    pub fn lua_yieldk(
-        L: *mut lua_State,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    ) -> c_int;
+    pub fn lua_yieldk(L: *mut lua_State, nresults: c_int, ctx: c_int, k: Option<lua_CFunction>) -> c_int;
     #[link_name = "lua_resume"]
     pub fn lua_resume_(L: *mut lua_State, from: *mut lua_State, narg: c_int) -> c_int;
     pub fn lua_status(L: *mut lua_State) -> c_int;
@@ -406,10 +396,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }
 
 #[inline(always)]
@@ -471,12 +459,7 @@ 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,
-    ) -> 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/lua52/lualib.rs

@@ -1,18 +1,18 @@
 //! Contains definitions from `lualib.h`.
 
-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};
 
 use super::lua::lua_State;
 
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
 extern "C-unwind" {

mlua-sys/src/lua53/compat.rs

@@ -1,19 +1,34 @@
 //! MLua compatibility layer for Lua 5.3
 
-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};
 
+use super::lauxlib::*;
 use super::lua::*;
 
 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+pub unsafe fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
     let ret = lua_resume_(L, from, narg);
     if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
         *nres = lua_gettop(L);
     }
     ret
 }
+
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == LUA_OK && env != 0 {
+        lua_pushvalue(L, env);
+        lua_setupvalue(L, -2, 1);
+    }
+    status
+}

mlua-sys/src/lua53/lauxlib.rs

@@ -9,10 +9,10 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
 // Key, in the registry, for table of loaded modules
-pub const LUA_LOADED_TABLE: &str = "_LOADED";
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
 
 // Key, in the registry, for table of preloaded loaders
-pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
 
 #[repr(C)]
 pub struct luaL_Reg {
@@ -30,12 +30,8 @@ extern "C-unwind" {
     pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
     pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
     pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
-    pub fn luaL_optlstring(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        l: *mut usize,
-    ) -> *const c_char;
+    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
+        -> *const c_char;
     pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
     pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
     pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -73,8 +69,7 @@ extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }
 
 #[inline(always)]
@@ -110,12 +105,7 @@ extern "C-unwind" {
 
     pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
 
-    pub fn luaL_requiref(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
+    pub fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }
 
 //
@@ -179,12 +169,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
 // luaL_opt would be implemented here but it is undocumented, so it's omitted
 
 #[inline(always)]
-pub unsafe fn luaL_loadbuffer(
-    L: *mut lua_State,
-    s: *const c_char,
-    sz: usize,
-    n: *const c_char,
-) -> c_int {
+pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
     luaL_loadbufferx(L, s, sz, n, ptr::null())
 }
 

mlua-sys/src/lua53/lua.rs

@@ -1,9 +1,9 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
-use std::mem;
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 // Mark for precompiled code (`<esc>Lua`)
 pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
@@ -96,10 +96,10 @@ pub type lua_Reader =
 pub type lua_Writer =
     unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
 extern "C-unwind" {
@@ -251,12 +251,7 @@ extern "C-unwind" {
         mode: *const c_char,
     ) -> c_int;
 
-    pub fn lua_dump(
-        L: *mut lua_State,
-        writer: lua_Writer,
-        data: *mut c_void,
-        strip: c_int,
-    ) -> c_int;
+    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, strip: c_int) -> c_int;
 }
 
 #[inline(always)]
@@ -413,10 +408,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }
 
 #[inline(always)]

mlua-sys/src/lua53/lualib.rs

@@ -1,19 +1,19 @@
 //! Contains definitions from `lualib.h`.
 
-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};
 
 use super::lua::lua_State;
 
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
 extern "C-unwind" {

mlua-sys/src/lua54/lauxlib.rs

@@ -9,10 +9,10 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
 // Key, in the registry, for table of loaded modules
-pub const LUA_LOADED_TABLE: &str = "_LOADED";
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
 
 // Key, in the registry, for table of preloaded loaders
-pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
 
 #[repr(C)]
 pub struct luaL_Reg {
@@ -29,12 +29,8 @@ extern "C-unwind" {
     pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
     pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
     pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
-    pub fn luaL_optlstring(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        l: *mut usize,
-    ) -> *const c_char;
+    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
+        -> *const c_char;
     pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
     pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
     pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -72,8 +68,7 @@ extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }
 
 #[inline(always)]
@@ -111,12 +106,7 @@ extern "C-unwind" {
 
     pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
 
-    pub fn luaL_requiref(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
+    pub fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }
 
 //
@@ -175,15 +165,29 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
 // luaL_opt would be implemented here but it is undocumented, so it's omitted
 
 #[inline(always)]
-pub unsafe fn luaL_loadbuffer(
-    L: *mut lua_State,
-    s: *const c_char,
-    sz: usize,
-    n: *const c_char,
-) -> c_int {
+pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
     luaL_loadbufferx(L, s, sz, n, ptr::null())
 }
 
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua::lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == lua::LUA_OK && env != 0 {
+        lua::lua_pushvalue(L, env);
+        lua::lua_setupvalue(L, -2, 1);
+    }
+    status
+}
+
 //
 // TODO: Generic Buffer Manipulation
 //

mlua-sys/src/lua54/lua.rs

@@ -1,9 +1,9 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
-use std::mem;
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_ushort, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 // Mark for precompiled code (`<esc>Lua`)
 pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
@@ -95,14 +95,13 @@ pub type lua_Reader =
 pub type lua_Writer =
     unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
+/// Type for memory-allocation functions (no unwinding)
 #[rustfmt::skip]
 pub type lua_Alloc =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
 /// Type for warning functions
-pub type lua_WarnFunction =
-    unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
+pub type lua_WarnFunction = unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
 extern "C-unwind" {
@@ -266,12 +265,7 @@ extern "C-unwind" {
         mode: *const c_char,
     ) -> c_int;
 
-    pub fn lua_dump(
-        L: *mut lua_State,
-        writer: lua_Writer,
-        data: *mut c_void,
-        strip: c_int,
-    ) -> c_int;
+    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, strip: c_int) -> c_int;
 }
 
 #[inline(always)]
@@ -295,12 +289,7 @@ extern "C-unwind" {
         ctx: lua_KContext,
         k: Option<lua_KFunction>,
     ) -> c_int;
-    pub fn lua_resume(
-        L: *mut lua_State,
-        from: *mut lua_State,
-        narg: c_int,
-        nres: *mut c_int,
-    ) -> c_int;
+    pub fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int;
     pub fn lua_status(L: *mut lua_State) -> c_int;
     pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
 }
@@ -446,10 +435,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }
 
 #[inline(always)]

mlua-sys/src/lua54/lualib.rs

@@ -1,18 +1,18 @@
 //! Contains definitions from `lualib.h`.
 
-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};
 
 use super::lua::lua_State;
 
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");
 
 #[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
 extern "C-unwind" {

mlua-sys/src/luau/compat.rs

@@ -1,16 +1,17 @@
-//! MLua compatibility layer for Roblox Luau.
+//! MLua compatibility layer for Luau.
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3
 
 use std::ffi::CStr;
-use std::mem;
 use std::os::raw::{c_char, c_int, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 use super::lauxlib::*;
 use super::lua::*;
 use super::luacode::*;
 
+pub const LUA_RESUMEERROR: c_int = -1;
+
 unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
     while a < b {
         lua_pushvalue(L, a);
@@ -42,7 +43,7 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
             } else if compat53_findfield(L, objidx, level - 1) != 0 {
                 // try recursively
                 lua_remove(L, -2); // remove table (but keep name)
-                lua_pushliteral(L, ".");
+                lua_pushliteral(L, c".");
                 lua_insert(L, -2); // place '.' between the two names
                 lua_concat(L, 3);
                 return 1;
@@ -53,11 +54,7 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
     0 // not found
 }
 
-unsafe fn compat53_pushglobalfuncname(
-    L: *mut lua_State,
-    level: c_int,
-    ar: *mut lua_Debug,
-) -> c_int {
+unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int {
     let top = lua_gettop(L);
     // push function
     lua_getinfo(L, level, cstr!("f"), ar);
@@ -80,7 +77,7 @@ unsafe fn compat53_pushfuncname(L: *mut lua_State, level: c_int, ar: *mut lua_De
         lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
         lua_remove(L, -2); // remove name
     } else {
-        lua_pushliteral(L, "?");
+        lua_pushliteral(L, c"?");
     }
 }
 
@@ -113,7 +110,7 @@ pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
 #[inline(always)]
 pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {
     let abs_to = lua_absindex(L, toidx);
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_pushvalue(L, fromidx);
     lua_replace(L, abs_to);
 }
@@ -130,6 +127,11 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
     0
 }
 
+#[inline(always)]
+pub unsafe fn lua_pushinteger(L: *mut lua_State, i: lua_Integer) {
+    lua_pushnumber(L, i as lua_Number);
+}
+
 #[inline(always)]
 pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
     lua_tointegerx(L, i, ptr::null_mut())
@@ -181,6 +183,7 @@ pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_i
 
 #[inline(always)]
 pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
+    let n = n.try_into().expect("cannot convert index from lua_Integer");
     lua_rawgeti_(L, idx, n)
 }
 
@@ -195,7 +198,7 @@ pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_
 pub unsafe fn lua_getuservalue(L: *mut lua_State, mut idx: c_int) -> c_int {
     luaL_checkstack(L, 2, cstr!("not enough stack slots available"));
     idx = lua_absindex(L, idx);
-    lua_pushliteral(L, "__mlua_uservalues");
+    lua_pushliteral(L, c"__mlua_uservalues");
     if lua_rawget(L, LUA_REGISTRYINDEX) != LUA_TTABLE {
         return LUA_TNIL;
     }
@@ -216,13 +219,14 @@ pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
 
 #[inline(always)]
 pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
+    let n = n.try_into().expect("cannot convert index from lua_Integer");
     lua_rawseti_(L, idx, n)
 }
 
 #[inline(always)]
 pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
     let abs_i = lua_absindex(L, idx);
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_pushlightuserdata(L, p as *mut c_void);
     lua_insert(L, -2);
     lua_rawset(L, abs_i);
@@ -232,13 +236,13 @@ pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
 pub unsafe fn lua_setuservalue(L: *mut lua_State, mut idx: c_int) {
     luaL_checkstack(L, 4, cstr!("not enough stack slots available"));
     idx = lua_absindex(L, idx);
-    lua_pushliteral(L, "__mlua_uservalues");
+    lua_pushliteral(L, c"__mlua_uservalues");
     lua_pushvalue(L, -1);
     if lua_rawget(L, LUA_REGISTRYINDEX) != LUA_TTABLE {
         lua_pop(L, 1);
         lua_createtable(L, 0, 2); // main table
         lua_createtable(L, 0, 1); // metatable
-        lua_pushliteral(L, "k");
+        lua_pushliteral(L, c"k");
         lua_setfield(L, -2, cstr!("__mode"));
         lua_setmetatable(L, -2);
         lua_pushvalue(L, -2);
@@ -281,12 +285,7 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
 }
 
 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+pub unsafe fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
     let ret = lua_resume_(L, from, narg);
     if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
         *nres = lua_gettop(L);
@@ -294,6 +293,19 @@ pub unsafe fn lua_resume(
     ret
 }
 
+#[inline(always)]
+pub unsafe fn lua_resumex(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
+    let ret = if narg == LUA_RESUMEERROR {
+        lua_resumeerror(L, from)
+    } else {
+        lua_resume_(L, from, narg)
+    };
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
+}
+
 //
 // lauxlib ported functions
 //
@@ -304,12 +316,30 @@ pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char)
         if !msg.is_null() {
             luaL_error(L, cstr!("stack overflow (%s)"), msg);
         } else {
-            lua_pushliteral(L, "stack overflow");
+            lua_pushliteral(L, c"stack overflow");
             lua_error(L);
         }
     }
 }
 
+#[inline(always)]
+pub unsafe fn luaL_checkinteger(L: *mut lua_State, narg: c_int) -> lua_Integer {
+    let mut isnum = 0;
+    let int = lua_tointegerx(L, narg, &mut isnum);
+    if isnum == 0 {
+        luaL_typeerror(L, narg, lua_typename(L, LUA_TNUMBER));
+    }
+    int
+}
+
+pub unsafe fn luaL_optinteger(L: *mut lua_State, narg: c_int, def: lua_Integer) -> lua_Integer {
+    if lua_isnoneornil(L, narg) != 0 {
+        def
+    } else {
+        luaL_checkinteger(L, narg)
+    }
+}
+
 #[inline(always)]
 pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int {
     if luaL_getmetafield_(L, obj, e) != 0 {
@@ -330,50 +360,65 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
     }
 }
 
-pub unsafe fn luaL_loadbufferx(
+pub unsafe fn luaL_loadbufferenv(
     L: *mut lua_State,
     data: *const c_char,
     mut size: usize,
     name: *const c_char,
     mode: *const c_char,
+    mut env: c_int,
 ) -> c_int {
     extern "C" {
         fn free(p: *mut c_void);
     }
 
+    unsafe extern "C" fn data_dtor(_: *mut lua_State, data: *mut c_void) {
+        free(*(data as *mut *mut c_char) as *mut c_void);
+    }
+
     let chunk_is_text = size == 0 || (*data as u8) >= b'\t';
     if !mode.is_null() {
         let modeb = CStr::from_ptr(mode).to_bytes();
         if !chunk_is_text && !modeb.contains(&b'b') {
-            lua_pushfstring(
-                L,
-                cstr!("attempt to load a binary chunk (mode is '%s')"),
-                mode,
-            );
+            lua_pushfstring(L, cstr!("attempt to load a binary chunk (mode is '%s')"), mode);
             return LUA_ERRSYNTAX;
         } else if chunk_is_text && !modeb.contains(&b't') {
-            lua_pushfstring(
-                L,
-                cstr!("attempt to load a text chunk (mode is '%s')"),
-                mode,
-            );
+            lua_pushfstring(L, cstr!("attempt to load a text chunk (mode is '%s')"), mode);
             return LUA_ERRSYNTAX;
         }
     }
 
     if chunk_is_text {
+        if env < 0 {
+            env -= 1;
+        }
+        let data_ud = lua_newuserdatadtor(L, mem::size_of::<*mut c_char>(), data_dtor) as *mut *mut c_char;
         let data = luau_compile_(data, size, ptr::null_mut(), &mut size);
-        let ok = luau_load(L, name, data, size, 0) == 0;
-        free(data as *mut c_void);
+        ptr::write(data_ud, data);
+        // By deferring the `free(data)` to the userdata destructor, we ensure that
+        // even if `luau_load` throws an error, the `data` is still released.
+        let ok = luau_load(L, name, data, size, env) == 0;
+        lua_replace(L, -2); // replace data with the result
         if !ok {
             return LUA_ERRSYNTAX;
         }
-    } else if luau_load(L, name, data, size, 0) != 0 {
+    } else if luau_load(L, name, data, size, env) != 0 {
         return LUA_ERRSYNTAX;
     }
     LUA_OK
 }
 
+#[inline(always)]
+pub unsafe fn luaL_loadbufferx(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+) -> c_int {
+    luaL_loadbufferenv(L, data, size, name, mode, 0)
+}
+
 #[inline(always)]
 pub unsafe fn luaL_loadbuffer(
     L: *mut lua_State,
@@ -381,13 +426,13 @@ pub unsafe fn luaL_loadbuffer(
     size: usize,
     name: *const c_char,
 ) -> c_int {
-    luaL_loadbufferx(L, data, size, name, ptr::null())
+    luaL_loadbufferenv(L, data, size, name, ptr::null(), 0)
 }
 
 #[inline(always)]
 pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
     let mut isnum = 0;
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_len(L, idx);
     let res = lua_tointegerx(L, -1, &mut isnum);
     lua_pop(L, 1);
@@ -397,12 +442,7 @@ pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
     res
 }
 
-pub unsafe fn luaL_traceback(
-    L: *mut lua_State,
-    L1: *mut lua_State,
-    msg: *const c_char,
-    mut level: c_int,
-) {
+pub unsafe fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, mut level: c_int) {
     let mut ar: lua_Debug = mem::zeroed();
     let top = lua_gettop(L);
     let numlevels = lua_stackdepth(L);
@@ -415,11 +455,11 @@ pub unsafe fn luaL_traceback(
     if !msg.is_null() {
         lua_pushfstring(L, cstr!("%s\n"), msg);
     }
-    lua_pushliteral(L, "stack traceback:");
+    lua_pushliteral(L, c"stack traceback:");
     while lua_getinfo(L1, level, cstr!(""), &mut ar) != 0 {
         if level + 1 == mark {
             // too many levels?
-            lua_pushliteral(L, "\n\t..."); // add a '...'
+            lua_pushliteral(L, c"\n\t..."); // add a '...'
             level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
         } else {
             lua_getinfo(L1, level, cstr!("sln"), &mut ar);
@@ -427,7 +467,7 @@ pub unsafe fn luaL_traceback(
             if ar.currentline > 0 {
                 lua_pushfstring(L, cstr!("%d:"), ar.currentline);
             }
-            lua_pushliteral(L, " in ");
+            lua_pushliteral(L, c" in ");
             compat53_pushfuncname(L, level, &mut ar);
             lua_concat(L, lua_gettop(L) - top);
         }
@@ -441,16 +481,16 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
         match lua_type(L, idx) {
             LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
             }
             LUA_TSTRING | LUA_TNUMBER => {
                 lua_pushvalue(L, idx);
             }
             LUA_TBOOLEAN => {
                 if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                 } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                 }
             }
             t => {
@@ -474,14 +514,14 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize)
 
 #[inline(always)]
 pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     luaL_getmetatable(L, tname);
     lua_setmetatable(L, -2);
 }
 
 pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int {
     let abs_i = lua_absindex(L, idx);
-    luaL_checkstack(L, 3, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
     lua_pushstring_(L, fname);
     if lua_gettable(L, abs_i) == LUA_TTABLE {
         return 1;
@@ -494,12 +534,7 @@ pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_ch
     0
 }
 
-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
     luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
     luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
     if lua_getfield(L, -1, modname) == LUA_TNIL {

mlua-sys/src/luau/lauxlib.rs

@@ -3,9 +3,7 @@
 use std::os::raw::{c_char, c_float, c_int, c_void};
 use std::ptr;
 
-use super::lua::{
-    self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Unsigned, LUA_REGISTRYINDEX,
-};
+use super::lua::{self, lua_CFunction, lua_Number, lua_State, lua_Unsigned, LUA_REGISTRYINDEX};
 
 #[repr(C)]
 pub struct luaL_Reg {
@@ -35,8 +33,10 @@ extern "C-unwind" {
     pub fn luaL_checkboolean(L: *mut lua_State, narg: c_int) -> c_int;
     pub fn luaL_optboolean(L: *mut lua_State, narg: c_int, def: c_int) -> c_int;
 
-    pub fn luaL_checkinteger(L: *mut lua_State, narg: c_int) -> lua_Integer;
-    pub fn luaL_optinteger(L: *mut lua_State, narg: c_int, def: lua_Integer) -> lua_Integer;
+    #[link_name = "luaL_checkinteger"]
+    pub fn luaL_checkinteger_(L: *mut lua_State, narg: c_int) -> c_int;
+    #[link_name = "luaL_optinteger"]
+    pub fn luaL_optinteger_(L: *mut lua_State, narg: c_int, def: c_int) -> c_int;
     pub fn luaL_checkunsigned(L: *mut lua_State, narg: c_int) -> lua_Unsigned;
     pub fn luaL_optunsigned(L: *mut lua_State, narg: c_int, def: lua_Unsigned) -> lua_Unsigned;
 
@@ -71,10 +71,17 @@ extern "C-unwind" {
 
     pub fn luaL_newstate() -> *mut lua_State;
 
-    // TODO: luaL_findtable
+    pub fn luaL_findtable(
+        L: *mut lua_State,
+        idx: c_int,
+        fname: *const c_char,
+        szhint: c_int,
+    ) -> *const c_char;
 
     pub fn luaL_typename(L: *mut lua_State, idx: c_int) -> *const c_char;
 
+    pub fn luaL_callyieldable(L: *mut lua_State, nargs: c_int, nresults: c_int) -> c_int;
+
     // sandbox libraries and globals
     #[link_name = "luaL_sandbox"]
     pub fn luaL_sandbox_(L: *mut lua_State);
@@ -143,7 +150,7 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
     }
 
     // set all builtin metatables to read-only
-    lua_pushliteral(L, "");
+    lua_pushliteral(L, c"");
     if lua_getmetatable(L, -1) != 0 {
         lua_setreadonly(L, -1, enabled);
         lua_pop(L, 2);

mlua-sys/src/luau/lua.rs

@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_float, c_int, c_uint, c_void};
 use std::{mem, ptr};
@@ -69,8 +70,11 @@ pub const LUA_MINSTACK: c_int = 20;
 /// A Lua number, usually equivalent to `f64`.
 pub type lua_Number = c_double;
 
-/// A Lua integer, equivalent to `i32`.
-pub type lua_Integer = c_int;
+/// A Lua integer, usually equivalent to `i64`
+#[cfg(target_pointer_width = "32")]
+pub type lua_Integer = i32;
+#[cfg(target_pointer_width = "64")]
+pub type lua_Integer = i64;
 
 /// A Lua unsigned integer, equivalent to `u32`.
 pub type lua_Unsigned = c_uint;
@@ -79,17 +83,12 @@ pub type lua_Unsigned = c_uint;
 pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 pub type lua_Continuation = unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int) -> c_int;
 
-/// Type for userdata destructor functions.
-pub type lua_Udestructor = unsafe extern "C-unwind" fn(*mut c_void);
-pub type lua_Destructor = unsafe extern "C-unwind" fn(L: *mut lua_State, *mut c_void);
+/// Type for userdata destructor functions (no unwinding).
+pub type lua_Destructor = unsafe extern "C" fn(L: *mut lua_State, *mut c_void);
 
-/// Type for memory-allocation functions.
-pub type lua_Alloc = unsafe extern "C-unwind" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+/// Type for memory-allocation functions (no unwinding).
+pub type lua_Alloc =
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
 /// Returns Luau release version (eg. `0.xxx`).
 pub const fn luau_version() -> Option<&'static str> {
@@ -140,7 +139,7 @@ extern "C-unwind" {
 
     pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
     #[link_name = "lua_tointegerx"]
-    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> c_int;
     pub fn lua_tounsignedx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Unsigned;
     pub fn lua_tovector(L: *mut lua_State, idx: c_int) -> *const c_float;
     pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
@@ -164,7 +163,8 @@ extern "C-unwind" {
     //
     pub fn lua_pushnil(L: *mut lua_State);
     pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
-    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    #[link_name = "lua_pushinteger"]
+    pub fn lua_pushinteger_(L: *mut lua_State, n: c_int);
     pub fn lua_pushunsigned(L: *mut lua_State, n: lua_Unsigned);
     #[cfg(not(feature = "luau-vector4"))]
     pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float);
@@ -189,7 +189,8 @@ extern "C-unwind" {
 
     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_newuserdatataggedwithmetatable(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
+    pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Destructor) -> *mut c_void;
 
     pub fn lua_newbuffer(L: *mut lua_State, sz: usize) -> *mut c_void;
 
@@ -288,7 +289,7 @@ 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_setuserdatametatable(L: *mut lua_State, tag: 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;
@@ -313,13 +314,13 @@ extern "C-unwind" {
 //
 
 #[inline(always)]
-pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
-    lua_tonumberx(L, i, ptr::null_mut())
+pub unsafe fn lua_tonumber(L: *mut lua_State, idx: c_int) -> lua_Number {
+    lua_tonumberx(L, idx, ptr::null_mut())
 }
 
 #[inline(always)]
-pub unsafe fn lua_tointeger_(L: *mut lua_State, i: c_int) -> lua_Integer {
-    lua_tointegerx_(L, i, ptr::null_mut())
+pub unsafe fn lua_tointeger_(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_tointegerx_(L, idx, ptr::null_mut())
 }
 
 #[inline(always)]
@@ -343,12 +344,14 @@ pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
 }
 
 #[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) {
+pub unsafe fn lua_newuserdata_t<T>(L: *mut lua_State, data: T) -> *mut T {
+    unsafe extern "C" fn destructor<T>(_: *mut lua_State, ud: *mut c_void) {
         ptr::drop_in_place(ud as *mut T);
     }
 
-    lua_newuserdatadtor(L, mem::size_of::<T>(), destructor::<T>) as *mut T
+    let ud_ptr = lua_newuserdatadtor(L, const { mem::size_of::<T>() }, destructor::<T>) as *mut T;
+    ptr::write(ud_ptr, data);
+    ud_ptr
 }
 
 // TODO: lua_strlen
@@ -404,10 +407,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring_(L, s.as_ptr());
 }
 
 #[inline(always)]
@@ -426,12 +427,7 @@ pub unsafe fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, nup: c_int)
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushcclosured(
-    L: *mut lua_State,
-    f: lua_CFunction,
-    debugname: *const c_char,
-    nup: c_int,
-) {
+pub unsafe fn lua_pushcclosured(L: *mut lua_State, f: lua_CFunction, debugname: *const c_char, nup: c_int) {
     lua_pushcclosurek(L, f, debugname, nup, None)
 }
 
@@ -476,12 +472,7 @@ pub type lua_Coverage = unsafe extern "C-unwind" fn(
 
 extern "C-unwind" {
     pub fn lua_stackdepth(L: *mut lua_State) -> c_int;
-    pub fn lua_getinfo(
-        L: *mut lua_State,
-        level: c_int,
-        what: *const c_char,
-        ar: *mut lua_Debug,
-    ) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, level: c_int, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getargument(L: *mut lua_State, level: c_int, n: c_int) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, level: c_int, n: c_int) -> *const c_char;
     pub fn lua_setlocal(L: *mut lua_State, level: c_int, n: c_int) -> *const c_char;
@@ -489,19 +480,9 @@ extern "C-unwind" {
     pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
 
     pub fn lua_singlestep(L: *mut lua_State, enabled: c_int);
-    pub fn lua_breakpoint(
-        L: *mut lua_State,
-        funcindex: c_int,
-        line: c_int,
-        enabled: c_int,
-    ) -> c_int;
+    pub fn lua_breakpoint(L: *mut lua_State, funcindex: c_int, line: c_int, enabled: c_int) -> c_int;
 
-    pub fn lua_getcoverage(
-        L: *mut lua_State,
-        funcindex: c_int,
-        context: *mut c_void,
-        callback: lua_Coverage,
-    );
+    pub fn lua_getcoverage(L: *mut lua_State, funcindex: c_int, context: *mut c_void, callback: lua_Coverage);
 
     pub fn lua_debugtrace(L: *mut lua_State) -> *const c_char;
 }
@@ -550,6 +531,9 @@ pub struct lua_Callbacks {
     pub debuginterrupt: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
     /// gets called when protected call results in an error
     pub debugprotectederror: Option<unsafe extern "C-unwind" fn(L: *mut lua_State)>,
+
+    /// gets called when memory is allocated
+    pub onallocate: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, osize: usize, nsize: usize)>,
 }
 
 extern "C" {
@@ -559,4 +543,5 @@ extern "C" {
 // Functions from customization lib
 extern "C" {
     pub fn luau_setfflag(name: *const c_char, value: c_int) -> c_int;
+    pub fn lua_getmetatablepointer(L: *mut lua_State, idx: c_int) -> *const c_void;
 }

mlua-sys/src/luau/luacode.rs

@@ -1,5 +1,6 @@
 //! Contains definitions from `luacode.h`.
 
+use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_int, c_void};
 use std::{ptr, slice};
 
@@ -15,6 +16,10 @@ pub struct lua_CompileOptions {
     pub vectorType: *const c_char,
     pub mutableGlobals: *const *const c_char,
     pub userdataTypes: *const *const c_char,
+    pub librariesWithKnownMembers: *const *const c_char,
+    pub libraryMemberTypeCallback: Option<lua_LibraryMemberTypeCallback>,
+    pub libraryMemberConstantCallback: Option<lua_LibraryMemberConstantCallback>,
+    pub disabledBuiltins: *const *const c_char,
 }
 
 impl Default for lua_CompileOptions {
@@ -29,10 +34,56 @@ impl Default for lua_CompileOptions {
             vectorType: ptr::null(),
             mutableGlobals: ptr::null(),
             userdataTypes: ptr::null(),
+            librariesWithKnownMembers: ptr::null(),
+            libraryMemberTypeCallback: None,
+            libraryMemberConstantCallback: None,
+            disabledBuiltins: ptr::null(),
         }
     }
 }
 
+#[repr(C)]
+pub struct lua_CompileConstant {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+/// Type table tags
+#[doc(hidden)]
+#[repr(i32)]
+#[non_exhaustive]
+pub enum luau_BytecodeType {
+    Nil = 0,
+    Boolean,
+    Number,
+    String,
+    Table,
+    Function,
+    Thread,
+    UserData,
+    Vector,
+    Buffer,
+
+    Any = 15,
+}
+
+pub type lua_LibraryMemberTypeCallback =
+    unsafe extern "C-unwind" fn(library: *const c_char, member: *const c_char) -> c_int;
+
+pub type lua_LibraryMemberConstantCallback = unsafe extern "C-unwind" fn(
+    library: *const c_char,
+    member: *const c_char,
+    constant: *mut lua_CompileConstant,
+);
+
+extern "C" {
+    pub fn luau_set_compile_constant_nil(cons: *mut lua_CompileConstant);
+    pub fn luau_set_compile_constant_boolean(cons: *mut lua_CompileConstant, b: c_int);
+    pub fn luau_set_compile_constant_number(cons: *mut lua_CompileConstant, n: f64);
+    pub fn luau_set_compile_constant_vector(cons: *mut lua_CompileConstant, x: f32, y: f32, z: f32, w: f32);
+    pub fn luau_set_compile_constant_string(cons: *mut lua_CompileConstant, s: *const c_char, l: usize);
+}
+
 extern "C-unwind" {
     #[link_name = "luau_compile"]
     pub fn luau_compile_(

mlua-sys/src/luau/lualib.rs

@@ -1,18 +1,19 @@
 //! Contains definitions from `lualib.h`.
 
-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};
 
 use super::lua::lua_State;
 
-pub const LUA_COLIBNAME: &str = "coroutine";
-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";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_BUFFERLIBNAME: *const c_char = cstr!("buffer");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_VECLIBNAME: *const c_char = cstr!("vector");
 
 extern "C-unwind" {
     pub fn luaopen_base(L: *mut lua_State) -> c_int;
@@ -25,6 +26,7 @@ extern "C-unwind" {
     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;
+    pub fn luaopen_vector(L: *mut lua_State) -> c_int;
 
     // open all builtin libraries
     pub fn luaL_openlibs(L: *mut lua_State);

mlua-sys/src/luau/luarequire.rs

@@ -0,0 +1,154 @@
+//! Contains definitions from `Require.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+
+use super::lua::lua_State;
+
+pub const LUA_REGISTERED_MODULES_TABLE: *const c_char = cstr!("_REGISTEREDMODULES");
+
+#[repr(C)]
+pub enum luarequire_NavigateResult {
+    Success,
+    Ambiguous,
+    NotFound,
+}
+
+// Functions returning WriteSuccess are expected to set their size_out argument
+// to the number of bytes written to the buffer. If WriteBufferTooSmall is
+// returned, size_out should be set to the required buffer size.
+#[repr(C)]
+pub enum luarequire_WriteResult {
+    Success,
+    BufferTooSmall,
+    Failure,
+}
+
+#[repr(C)]
+pub struct luarequire_Configuration {
+    // Returns whether requires are permitted from the given chunkname.
+    pub is_require_allowed:
+        unsafe extern "C" fn(L: *mut lua_State, ctx: *mut c_void, requirer_chunkname: *const c_char) -> bool,
+
+    // Resets the internal state to point at the requirer module.
+    pub reset: unsafe extern "C" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        requirer_chunkname: *const c_char,
+    ) -> luarequire_NavigateResult,
+
+    // Resets the internal state to point at an aliased module, given its exact path from a configuration
+    // file. This function is only called when an alias's path cannot be resolved relative to its
+    // configuration file.
+    pub jump_to_alias: unsafe extern "C" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        path: *const c_char,
+    ) -> luarequire_NavigateResult,
+
+    // Navigates through the context by making mutations to the internal state.
+    pub to_parent: unsafe extern "C" fn(L: *mut lua_State, ctx: *mut c_void) -> luarequire_NavigateResult,
+    pub to_child: unsafe extern "C" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        name: *const c_char,
+    ) -> luarequire_NavigateResult,
+
+    // Returns whether the context is currently pointing at a module.
+    pub is_module_present: unsafe extern "C" fn(L: *mut lua_State, ctx: *mut c_void) -> bool,
+
+    // Provides the contents of the current module. This function is only called if is_module_present returns
+    // true.
+    pub get_contents: unsafe extern "C" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> luarequire_WriteResult,
+
+    // Provides a chunkname for the current module. This will be accessible through the debug library. This
+    // function is only called if is_module_present returns true.
+    pub get_chunkname: unsafe extern "C" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> luarequire_WriteResult,
+
+    // Provides a cache key representing the current module. This function is only called if
+    // is_module_present returns true.
+    pub get_cache_key: unsafe extern "C" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> luarequire_WriteResult,
+
+    // Returns whether a configuration file is present in the current context.
+    // If not, require-by-string will call to_parent until either a configuration file is present or
+    // NAVIGATE_FAILURE is returned (at root).
+    pub is_config_present: unsafe extern "C" fn(L: *mut lua_State, ctx: *mut c_void) -> bool,
+
+    // Provides the contents of the configuration file in the current context.
+    // This function is only called if is_config_present returns true.
+    pub get_config: unsafe extern "C" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> luarequire_WriteResult,
+
+    // Executes the module and places the result on the stack. Returns the number of results placed on the
+    // stack.
+    // Returning -1 directs the requiring thread to yield. In this case, this thread should be resumed with
+    // the module result pushed onto its stack.
+    pub load: unsafe extern "C-unwind" fn(
+        L: *mut lua_State,
+        ctx: *mut c_void,
+        path: *const c_char,
+        chunkname: *const c_char,
+        contents: *const c_char,
+    ) -> c_int,
+}
+
+// Populates function pointers in the given luarequire_Configuration.
+pub type luarequire_Configuration_init = unsafe extern "C" fn(config: *mut luarequire_Configuration);
+
+extern "C-unwind" {
+    // Initializes and pushes the require closure onto the stack without registration.
+    pub fn luarequire_pushrequire(
+        L: *mut lua_State,
+        config_init: luarequire_Configuration_init,
+        ctx: *mut c_void,
+    ) -> c_int;
+
+    // Initializes the require library and registers it globally.
+    pub fn luaopen_require(L: *mut lua_State, config_init: luarequire_Configuration_init, ctx: *mut c_void);
+
+    // Initializes and pushes a "proxyrequire" closure onto the stack.
+    //
+    // The closure takes two parameters: the string path to resolve and the chunkname of an existing
+    // module.
+    pub fn luarequire_pushproxyrequire(
+        L: *mut lua_State,
+        config_init: luarequire_Configuration_init,
+        ctx: *mut c_void,
+    ) -> c_int;
+
+    // Registers an aliased require path to a result.
+    //
+    // After registration, the given result will always be immediately returned when the given path is
+    // required.
+    // Expects the path and table to be passed as arguments on the stack.
+    pub fn luarequire_registermodule(L: *mut lua_State) -> c_int;
+
+    // Clears the entry associated with the given cache key from the require cache.
+    // Expects the cache key to be passed as an argument on the stack.
+    pub fn luarequire_clearcacheentry(L: *mut lua_State) -> c_int;
+
+    // Clears all entries from the require cache.
+    pub fn luarequire_clearcache(L: *mut lua_State) -> c_int;
+}

mlua-sys/src/luau/mod.rs

@@ -6,6 +6,7 @@ pub use lua::*;
 pub use luacode::*;
 pub use luacodegen::*;
 pub use lualib::*;
+pub use luarequire::*;
 
 pub mod compat;
 pub mod lauxlib;
@@ -13,3 +14,4 @@ pub mod lua;
 pub mod luacode;
 pub mod luacodegen;
 pub mod lualib;
+pub mod luarequire;

mlua-sys/src/macros.rs

@@ -1,7 +1,6 @@
 #[allow(unused_macros)]
 macro_rules! cstr {
     ($s:expr) => {
-        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char]
-            as *const ::std::os::raw::c_char
+        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char] as *const ::std::os::raw::c_char
     };
 }

mlua_derive/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "mlua_derive"
-version = "0.9.3"
+version = "0.10.1"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 edition = "2021"
 description = "Procedural macros for the mlua crate."
-repository = "https://github.com/khvzak/mlua"
+repository = "https://github.com/mlua-rs/mlua"
 keywords = ["lua", "mlua"]
 license = "MIT"
 
@@ -12,13 +12,13 @@ license = "MIT"
 proc-macro = true
 
 [features]
-macros = ["proc-macro-error", "itertools", "regex", "once_cell"]
+macros = ["proc-macro-error2", "itertools", "regex", "once_cell"]
 
 [dependencies]
 quote = "1.0"
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
-proc-macro-error = { version = "1.0", optional = true }
+proc-macro-error2 = { version = "2.0.1", optional = true }
 syn = { version = "2.0", features = ["full"] }
-itertools = { version = "0.12", optional = true }
+itertools = { version = "0.14", optional = true }
 regex = { version = "1.4", optional = true }
 once_cell = { version = "1.0", optional = true }

mlua_derive/src/from_lua.rs

@@ -3,9 +3,7 @@ use quote::quote;
 use syn::{parse_macro_input, DeriveInput};
 
 pub fn from_lua(input: TokenStream) -> TokenStream {
-    let DeriveInput {
-        ident, generics, ..
-    } = parse_macro_input!(input as DeriveInput);
+    let DeriveInput { ident, generics, .. } = parse_macro_input!(input as DeriveInput);
 
     let ident_str = ident.to_string();
     let (impl_generics, ty_generics, _) = generics.split_for_impl();
@@ -15,14 +13,14 @@ pub fn from_lua(input: TokenStream) -> TokenStream {
     };
 
     quote! {
-      impl #impl_generics ::mlua::FromLua<'_> for #ident #ty_generics #where_clause {
+      impl #impl_generics ::mlua::FromLua for #ident #ty_generics #where_clause {
         #[inline]
-        fn from_lua(value: ::mlua::Value<'_>, _: &'_ ::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 {
                 from: value.type_name(),
-                to: #ident_str,
+                to: #ident_str.to_string(),
                 message: None,
             }),
           }

mlua_derive/src/lib.rs

@@ -7,7 +7,7 @@ use syn::{parse_macro_input, ItemFn, LitStr, Result};
 #[cfg(feature = "macros")]
 use {
     crate::chunk::Chunk, proc_macro::TokenTree, proc_macro2::TokenStream as TokenStream2,
-    proc_macro_error::proc_macro_error,
+    proc_macro_error2::proc_macro_error,
 };
 
 #[derive(Default)]
@@ -64,9 +64,10 @@ pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
 
         #[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);
-            #skip_memory_check
-            lua.entrypoint1(state, #func_name)
+            mlua::Lua::entrypoint1(state, move |lua| {
+                #skip_memory_check
+                #func_name(lua)
+            })
         }
     };
 
@@ -99,15 +100,14 @@ pub fn chunk(input: TokenStream) -> TokenStream {
         use ::std::borrow::Cow;
         use ::std::cell::Cell;
         use ::std::io::Result as IoResult;
-        use ::std::marker::PhantomData;
 
-        struct InnerChunk<'lua, F: FnOnce(&'lua Lua) -> Result<Table<'lua>>>(Cell<Option<F>>, PhantomData<&'lua ()>);
+        struct InnerChunk<F: FnOnce(&Lua) -> Result<Table>>(Cell<Option<F>>);
 
-        impl<'lua, F> AsChunk<'lua, 'static> for InnerChunk<'lua, F>
+        impl<F> AsChunk<'static> for InnerChunk<F>
         where
-            F: FnOnce(&'lua Lua) -> Result<Table<'lua>>,
+            F: FnOnce(&Lua) -> Result<Table>,
         {
-            fn environment(&self, lua: &'lua Lua) -> Result<Option<Table<'lua>>> {
+            fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
                 if #caps_len > 0 {
                     if let Some(make_env) = self.0.take() {
                         return make_env(lua).map(Some);
@@ -125,9 +125,7 @@ pub fn chunk(input: TokenStream) -> TokenStream {
             }
         }
 
-        fn annotate<'a, F: FnOnce(&'a Lua) -> Result<Table<'a>>>(f: F) -> F { f }
-
-        let make_env = annotate(move |lua: &Lua| -> Result<Table> {
+        let make_env = move |lua: &Lua| -> Result<Table> {
             let globals = lua.globals();
             let env = lua.create_table()?;
             let meta = lua.create_table()?;
@@ -139,9 +137,9 @@ pub fn chunk(input: TokenStream) -> TokenStream {
 
             env.set_metatable(Some(meta));
             Ok(env)
-        });
+        };
 
-        InnerChunk(Cell::new(Some(make_env)), PhantomData)
+        InnerChunk(Cell::new(Some(make_env)))
     }};
 
     wrapped_code.into()

mlua_derive/src/token.rs

@@ -1,8 +1,6 @@
-use std::{
-    cmp::{Eq, PartialEq},
-    fmt::{self, Display, Formatter},
-    vec::IntoIter,
-};
+use std::cmp::{Eq, PartialEq};
+use std::fmt::{self, Display, Formatter};
+use std::vec::IntoIter;
 
 use itertools::Itertools;
 use once_cell::sync::Lazy;
@@ -47,10 +45,7 @@ fn span_pos(span: &Span) -> (Pos, Pos) {
         return fallback_span_pos(span);
     }
 
-    (
-        Pos::new(start.line, start.column),
-        Pos::new(end.line, end.column),
-    )
+    (Pos::new(start.line, start.column), Pos::new(end.line, end.column))
 }
 
 fn parse_pos(span: &Span) -> Option<(usize, usize)> {
@@ -79,9 +74,7 @@ fn parse_pos(span: &Span) -> Option<(usize, usize)> {
 fn fallback_span_pos(span: &Span) -> (Pos, Pos) {
     let (start, end) = match parse_pos(span) {
         Some(v) => v,
-        None => proc_macro_error::abort_call_site!(
-            "Cannot retrieve span information; please use nightly"
-        ),
+        None => proc_macro_error2::abort_call_site!("Cannot retrieve span information; please use nightly"),
     };
     (Pos::new(1, start), Pos::new(1, end))
 }

rustfmt.toml

@@ -0,0 +1,4 @@
+imports_granularity = "Module"
+max_width = 110
+comment_width = 100
+wrap_comments = true

src/buffer.rs

@@ -0,0 +1,86 @@
+#[cfg(feature = "serialize")]
+use serde::ser::{Serialize, Serializer};
+
+use crate::types::ValueRef;
+
+/// A Luau buffer type.
+///
+/// See the buffer [documentation] for more information.
+///
+/// [documentation]: https://luau.org/library#buffer-library
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Debug, PartialEq)]
+pub struct Buffer(pub(crate) ValueRef);
+
+#[cfg_attr(not(feature = "luau"), allow(unused))]
+impl Buffer {
+    /// Copies the buffer data into a new `Vec<u8>`.
+    pub fn to_vec(&self) -> Vec<u8> {
+        unsafe { self.as_slice().to_vec() }
+    }
+
+    /// Returns the length of the buffer.
+    pub fn len(&self) -> usize {
+        unsafe { self.as_slice().len() }
+    }
+
+    /// Returns `true` if the buffer is empty.
+    #[doc(hidden)]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Reads given number of bytes from the buffer at the given offset.
+    ///
+    /// Offset is 0-based.
+    #[track_caller]
+    pub fn read_bytes<const N: usize>(&self, offset: usize) -> [u8; N] {
+        let data = unsafe { self.as_slice() };
+        let mut bytes = [0u8; N];
+        bytes.copy_from_slice(&data[offset..offset + N]);
+        bytes
+    }
+
+    /// Writes given bytes to the buffer at the given offset.
+    ///
+    /// Offset is 0-based.
+    #[track_caller]
+    pub fn write_bytes(&self, offset: usize, bytes: &[u8]) {
+        let data = unsafe {
+            let (buf, size) = self.as_raw_parts();
+            std::slice::from_raw_parts_mut(buf, size)
+        };
+        data[offset..offset + bytes.len()].copy_from_slice(bytes);
+    }
+
+    pub(crate) unsafe fn as_slice(&self) -> &[u8] {
+        let (buf, size) = self.as_raw_parts();
+        std::slice::from_raw_parts(buf, size)
+    }
+
+    #[cfg(feature = "luau")]
+    unsafe fn as_raw_parts(&self) -> (*mut u8, usize) {
+        let lua = self.0.lua.lock();
+        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");
+        (buf as *mut u8, size)
+    }
+
+    #[cfg(not(feature = "luau"))]
+    unsafe fn as_raw_parts(&self) -> (*mut u8, usize) {
+        unreachable!()
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl Serialize for Buffer {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        serializer.serialize_bytes(unsafe { self.as_slice() })
+    }
+}
+
+#[cfg(feature = "luau")]
+impl crate::types::LuaType for Buffer {
+    const TYPE_ID: std::os::raw::c_int = ffi::LUA_TBUFFER;
+}

src/chunk.rs

@@ -2,21 +2,25 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::ffi::CString;
 use std::io::Result as IoResult;
+use std::marker::PhantomData;
+use std::panic::Location;
 use std::path::{Path, PathBuf};
 use std::string::String as StdString;
 
-use crate::error::{Error, ErrorContext, Result};
+use crate::error::{Error, Result};
 use crate::function::Function;
-use crate::lua::Lua;
+use crate::state::{Lua, WeakLua};
 use crate::table::Table;
-use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti};
+use crate::traits::{FromLuaMulti, IntoLua, IntoLuaMulti};
+use crate::value::Value;
 
 /// Trait for types [loadable by Lua] and convertible to a [`Chunk`]
 ///
 /// [loadable by Lua]: https://www.lua.org/manual/5.4/manual.html#3.3.2
-/// [`Chunk`]: crate::Chunk
-pub trait AsChunk<'lua, 'a> {
+pub trait AsChunk<'a> {
     /// Returns optional chunk name
+    ///
+    /// See [`Chunk::set_name`] for possible name prefixes.
     fn name(&self) -> Option<StdString> {
         None
     }
@@ -24,7 +28,7 @@ pub trait AsChunk<'lua, 'a> {
     /// Returns optional chunk [environment]
     ///
     /// [environment]: https://www.lua.org/manual/5.4/manual.html#2.2
-    fn environment(&self, lua: &'lua Lua) -> Result<Option<Table<'lua>>> {
+    fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
         let _lua = lua; // suppress warning
         Ok(None)
     }
@@ -38,43 +42,43 @@ pub trait AsChunk<'lua, 'a> {
     fn source(self) -> IoResult<Cow<'a, [u8]>>;
 }
 
-impl<'a> AsChunk<'_, 'a> for &'a str {
+impl<'a> AsChunk<'a> for &'a str {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self.as_ref()))
     }
 }
 
-impl AsChunk<'_, 'static> for StdString {
+impl AsChunk<'static> for StdString {
     fn source(self) -> IoResult<Cow<'static, [u8]>> {
         Ok(Cow::Owned(self.into_bytes()))
     }
 }
 
-impl<'a> AsChunk<'_, 'a> for &'a StdString {
+impl<'a> AsChunk<'a> for &'a StdString {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self.as_bytes()))
     }
 }
 
-impl<'a> AsChunk<'_, 'a> for &'a [u8] {
+impl<'a> AsChunk<'a> for &'a [u8] {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self))
     }
 }
 
-impl AsChunk<'_, 'static> for Vec<u8> {
+impl AsChunk<'static> for Vec<u8> {
     fn source(self) -> IoResult<Cow<'static, [u8]>> {
         Ok(Cow::Owned(self))
     }
 }
 
-impl<'a> AsChunk<'_, 'a> for &'a Vec<u8> {
+impl<'a> AsChunk<'a> for &'a Vec<u8> {
     fn source(self) -> IoResult<Cow<'a, [u8]>> {
         Ok(Cow::Borrowed(self.as_ref()))
     }
 }
 
-impl AsChunk<'_, 'static> for &Path {
+impl AsChunk<'static> for &Path {
     fn name(&self) -> Option<StdString> {
         Some(format!("@{}", self.display()))
     }
@@ -84,7 +88,7 @@ impl AsChunk<'_, 'static> for &Path {
     }
 }
 
-impl AsChunk<'_, 'static> for PathBuf {
+impl AsChunk<'static> for PathBuf {
     fn name(&self) -> Option<StdString> {
         Some(format!("@{}", self.display()))
     }
@@ -95,13 +99,11 @@ impl AsChunk<'_, 'static> for PathBuf {
 }
 
 /// Returned from [`Lua::load`] and is used to finalize loading and executing Lua main chunks.
-///
-/// [`Lua::load`]: crate::Lua::load
 #[must_use = "`Chunk`s do nothing unless one of `exec`, `eval`, `call`, or `into_function` are called on them"]
-pub struct Chunk<'lua, 'a> {
-    pub(crate) lua: &'lua Lua,
+pub struct Chunk<'a> {
+    pub(crate) lua: WeakLua,
     pub(crate) name: StdString,
-    pub(crate) env: Result<Option<Table<'lua>>>,
+    pub(crate) env: Result<Option<Table>>,
     pub(crate) mode: Option<ChunkMode>,
     pub(crate) source: IoResult<Cow<'a, [u8]>>,
     #[cfg(feature = "luau")]
@@ -134,7 +136,7 @@ pub struct Compiler {
 #[cfg(any(feature = "luau", doc))]
 impl Default for Compiler {
     fn default() -> Self {
-        Self::new()
+        const { Self::new() }
     }
 }
 
@@ -240,7 +242,9 @@ impl Compiler {
     }
 
     /// Compiles the `source` into bytecode.
-    pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
+    ///
+    /// Returns [`Error::SyntaxError`] if the source code is invalid.
+    pub fn compile(&self, source: impl AsRef<[u8]>) -> Result<Vec<u8>> {
         use std::os::raw::c_int;
         use std::ptr;
 
@@ -274,7 +278,7 @@ impl Compiler {
         vec2cstring_ptr!(mutable_globals, mutable_globals_ptr);
         vec2cstring_ptr!(userdata_types, userdata_types_ptr);
 
-        unsafe {
+        let bytecode = unsafe {
             let mut options = ffi::lua_CompileOptions::default();
             options.optimizationLevel = self.optimization_level as c_int;
             options.debugLevel = self.debug_level as c_int;
@@ -286,21 +290,48 @@ impl Compiler {
             options.mutableGlobals = mutable_globals_ptr;
             options.userdataTypes = userdata_types_ptr;
             ffi::luau_compile(source.as_ref(), options)
+        };
+
+        if bytecode.first() == Some(&0) {
+            // The rest of the bytecode is the error message starting with `:`
+            // See https://github.com/luau-lang/luau/blob/0.640/Compiler/src/Compiler.cpp#L4336
+            let message = String::from_utf8_lossy(&bytecode[2..]).to_string();
+            return Err(Error::SyntaxError {
+                incomplete_input: message.ends_with("<eof>"),
+                message,
+            });
         }
+
+        Ok(bytecode)
     }
 }
 
-impl<'lua, 'a> Chunk<'lua, 'a> {
+impl Chunk<'_> {
+    /// Returns the name of this chunk.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
     /// Sets the name of this chunk, which results in more informative error traces.
+    ///
+    /// Possible name prefixes:
+    /// - `@` - file path (when truncation is needed, the end of the file path is kept, as this is
+    ///   more useful for identifying the file)
+    /// - `=` - custom chunk name (when truncation is needed, the beginning of the name is kept)
     pub fn set_name(mut self, name: impl Into<String>) -> Self {
         self.name = name.into();
         self
     }
 
+    /// Returns the environment of this chunk.
+    pub fn environment(&self) -> Option<&Table> {
+        self.env.as_ref().ok()?.as_ref()
+    }
+
     /// Sets the environment of the loaded chunk to the given value.
     ///
-    /// In Lua >=5.2 main chunks always have exactly one upvalue, and this upvalue is used as the `_ENV`
-    /// variable inside the chunk. By default this value is set to the global environment.
+    /// In Lua >=5.2 main chunks always have exactly one upvalue, and this upvalue is used as the
+    /// `_ENV` variable inside the chunk. By default this value is set to the global environment.
     ///
     /// Calling this method changes the `_ENV` upvalue to the value provided, and variables inside
     /// the chunk will refer to the given environment rather than the global one.
@@ -308,14 +339,16 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// All global variables (including the standard library!) are looked up in `_ENV`, so it may be
     /// necessary to populate the environment in order for scripts using custom environments to be
     /// useful.
-    pub fn set_environment<V: IntoLua<'lua>>(mut self, env: V) -> Self {
-        self.env = env
-            .into_lua(self.lua)
-            .and_then(|val| self.lua.unpack(val))
-            .context("bad environment value");
+    pub fn set_environment(mut self, env: Table) -> Self {
+        self.env = Ok(Some(env));
         self
     }
 
+    /// Returns the mode (auto-detected by default) of this chunk.
+    pub fn mode(&self) -> ChunkMode {
+        self.detect_mode()
+    }
+
     /// Sets whether the chunk is text or binary (autodetected by default).
     ///
     /// Be aware, Lua does not check the consistency of the code inside binary chunks.
@@ -341,8 +374,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::<_, ()>(())?;
-        Ok(())
+        self.call(())
     }
 
     /// Asynchronously execute this chunk of code.
@@ -351,7 +383,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`exec`]: #method.exec
+    /// [`exec`]: Chunk::exec
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub async fn exec_async(self) -> Result<()> {
@@ -363,7 +395,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// If the chunk can be parsed as an expression, this loads and executes the chunk and returns
     /// the value that it evaluates to. Otherwise, the chunk is interpreted as a block as normal,
     /// and this is equivalent to calling `exec`.
-    pub fn eval<R: FromLuaMulti<'lua>>(self) -> Result<R> {
+    pub fn eval<R: FromLuaMulti>(self) -> Result<R> {
         // Bytecode is always interpreted as a statement.
         // For source code, first try interpreting the lua as an expression by adding
         // "return", then as a statement. This is the same thing the
@@ -383,12 +415,12 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`eval`]: #method.eval
+    /// [`eval`]: Chunk::eval
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub async fn eval_async<R>(self) -> Result<R>
     where
-        R: FromLuaMulti<'lua> + 'lua,
+        R: FromLuaMulti,
     {
         if self.detect_mode() == ChunkMode::Binary {
             self.call_async(()).await
@@ -402,7 +434,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// Load the chunk function and call it with the given arguments.
     ///
     /// This is equivalent to `into_function` and calling the resulting function.
-    pub fn call<A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(self, args: A) -> Result<R> {
+    pub fn call<R: FromLuaMulti>(self, args: impl IntoLuaMulti) -> Result<R> {
         self.into_function()?.call(args)
     }
 
@@ -412,22 +444,21 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`call`]: #method.call
+    /// [`call`]: Chunk::call
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub async fn call_async<A, R>(self, args: A) -> Result<R>
+    pub async fn call_async<R>(self, args: impl IntoLuaMulti) -> Result<R>
     where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua,
+        R: FromLuaMulti,
     {
         self.into_function()?.call_async(args).await
     }
 
-    /// Load this chunk into a regular `Function`.
+    /// Load this chunk into a regular [`Function`].
     ///
     /// This simply compiles the chunk without actually executing it.
     #[cfg_attr(not(feature = "luau"), allow(unused_mut))]
-    pub fn into_function(mut self) -> Result<Function<'lua>> {
+    pub fn into_function(mut self) -> Result<Function> {
         #[cfg(feature = "luau")]
         if self.compiler.is_some() {
             // We don't need to compile source if no compiler set
@@ -436,26 +467,23 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
 
         let name = Self::convert_name(self.name)?;
         self.lua
-            .load_chunk(Some(&name), self.env?, self.mode, self.source?.as_ref())
+            .lock()
+            .load_chunk(Some(&name), self.env?.as_ref(), self.mode, self.source?.as_ref())
     }
 
     /// Compiles the chunk and changes mode to binary.
     ///
-    /// It does nothing if the chunk is already binary.
+    /// It does nothing if the chunk is already binary or invalid.
     fn compile(&mut self) {
         if let Ok(ref source) = self.source {
             if self.detect_mode() == ChunkMode::Text {
                 #[cfg(feature = "luau")]
-                {
-                    let data = self
-                        .compiler
-                        .get_or_insert_with(Default::default)
-                        .compile(source);
+                if let Ok(data) = self.compiler.get_or_insert_with(Default::default).compile(source) {
                     self.source = Ok(Cow::Owned(data));
                     self.mode = Some(ChunkMode::Binary);
                 }
                 #[cfg(not(feature = "luau"))]
-                if let Ok(func) = self.lua.load_chunk(None, None, None, source.as_ref()) {
+                if let Ok(func) = self.lua.lock().load_chunk(None, None, None, source.as_ref()) {
                     let data = func.dump(false);
                     self.source = Ok(Cow::Owned(data));
                     self.mode = Some(ChunkMode::Binary);
@@ -474,7 +502,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         let mut text_source = None;
         if let Ok(ref source) = self.source {
             if self.detect_mode() == ChunkMode::Text {
-                if let Some(cache) = self.lua.app_data_ref::<ChunksCache>() {
+                let lua = self.lua.lock();
+                if let Some(cache) = lua.app_data_ref_unguarded::<ChunksCache>() {
                     if let Some(data) = cache.0.get(source.as_ref()) {
                         self.source = Ok(Cow::Owned(data.clone()));
                         self.mode = Some(ChunkMode::Binary);
@@ -490,13 +519,14 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
             self.compile();
             if let Ok(ref binary_source) = self.source {
                 if self.detect_mode() == ChunkMode::Binary {
-                    if let Some(mut cache) = self.lua.app_data_mut::<ChunksCache>() {
+                    let lua = self.lua.lock();
+                    if let Some(mut cache) = lua.app_data_mut_unguarded::<ChunksCache>() {
                         cache.0.insert(text_source, binary_source.as_ref().to_vec());
                     } else {
                         let mut cache = ChunksCache(HashMap::new());
                         cache.0.insert(text_source, binary_source.as_ref().to_vec());
-                        let _ = self.lua.try_set_app_data(cache);
-                    }
+                        let _ = lua.try_set_app_data(cache);
+                    };
                 }
             }
         }
@@ -504,7 +534,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         self
     }
 
-    fn to_expression(&self) -> Result<Function<'lua>> {
+    fn to_expression(&self) -> Result<Function> {
         // We assume that mode is Text
         let source = self.source.as_ref();
         let source = source.map_err(Error::runtime)?;
@@ -515,11 +545,16 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
             .compiler
             .as_ref()
             .map(|c| c.compile(&source))
+            .transpose()?
             .unwrap_or(source);
 
         let name = Self::convert_name(self.name.clone())?;
-        self.lua
-            .load_chunk(Some(&name), self.env.clone()?, None, &source)
+        let env = match &self.env {
+            Ok(Some(env)) => Some(env),
+            Ok(None) => None,
+            Err(err) => return Err(err.clone()),
+        };
+        self.lua.lock().load_chunk(Some(&name), env, None, &source)
     }
 
     fn detect_mode(&self) -> ChunkMode {
@@ -551,3 +586,33 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         buf
     }
 }
+
+struct WrappedChunk<'a, T: AsChunk<'a>> {
+    chunk: T,
+    caller: &'static Location<'static>,
+    _marker: PhantomData<&'a T>,
+}
+
+impl<'a> Chunk<'a> {
+    /// Wraps a chunk of Lua code, returning an opaque type that implements [`IntoLua`] trait.
+    ///
+    /// The resulted `IntoLua` implementation will convert the chunk into a Lua function without
+    /// executing it.
+    #[doc(hidden)]
+    #[track_caller]
+    pub fn wrap(chunk: impl AsChunk<'a> + 'a) -> impl IntoLua + 'a {
+        WrappedChunk {
+            chunk,
+            caller: Location::caller(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, T: AsChunk<'a>> IntoLua for WrappedChunk<'a, T> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.load_with_location(self.chunk, self.caller)
+            .into_function()
+            .map(Value::Function)
+    }
+}

src/error.rs

@@ -9,6 +9,12 @@ use std::sync::Arc;
 
 use crate::private::Sealed;
 
+#[cfg(feature = "error-send")]
+type DynStdError = dyn StdError + Send + Sync;
+
+#[cfg(not(feature = "error-send"))]
+type DynStdError = dyn StdError;
+
 /// Error type returned by `mlua` methods.
 #[derive(Debug, Clone)]
 #[non_exhaustive]
@@ -42,11 +48,11 @@ pub enum Error {
     GarbageCollectorError(StdString),
     /// Potentially unsafe action in safe mode.
     SafetyError(StdString),
-    /// Setting memory limit is not available.
+    /// Memory control is not available.
     ///
     /// This error can only happen when Lua state was not created by us and does not have the
     /// custom allocator attached.
-    MemoryLimitNotAvailable,
+    MemoryControlNotAvailable,
     /// A mutable callback has triggered Lua code that has called the same mutable callback again.
     ///
     /// This is an error because a mutable callback can only be borrowed mutably once.
@@ -61,10 +67,12 @@ pub enum Error {
     ///
     /// Due to the way `mlua` works, it should not be directly possible to run out of stack space
     /// during normal use. The only way that this error can be triggered is if a `Function` is
-    /// called with a huge number of arguments, or a rust callback returns a huge number of return
+    /// called with a huge number of arguments, or a Rust callback returns a huge number of return
     /// values.
     StackError,
-    /// Too many arguments to `Function::bind`.
+    /// Too many arguments to [`Function::bind`].
+    ///
+    /// [`Function::bind`]: crate::Function::bind
     BindError,
     /// Bad argument received from Lua (usually when calling a function).
     ///
@@ -83,7 +91,7 @@ pub enum Error {
     /// A Rust value could not be converted to a Lua value.
     ToLuaConversionError {
         /// Name of the Rust type that could not be converted.
-        from: &'static str,
+        from: String,
         /// Name of the Lua type that could not be created.
         to: &'static str,
         /// A message indicating why the conversion failed in more detail.
@@ -94,21 +102,21 @@ pub enum Error {
         /// Name of the Lua type that could not be converted.
         from: &'static str,
         /// Name of the Rust type that could not be created.
-        to: &'static str,
+        to: String,
         /// A string containing more detailed error information.
         message: Option<StdString>,
     },
-    /// [`Thread::resume`] was called on an inactive coroutine.
+    /// [`Thread::resume`] was called on an unresumable coroutine.
     ///
-    /// A coroutine is inactive if its main function has returned or if an error has occurred inside
-    /// the coroutine. Already running coroutines are also marked as inactive (unresumable).
+    /// A coroutine is unresumable if its main function has returned or if an error has occurred
+    /// inside the coroutine. Already running coroutines are also marked as unresumable.
     ///
     /// [`Thread::status`] can be used to check if the coroutine can be resumed without causing this
     /// error.
     ///
     /// [`Thread::resume`]: crate::Thread::resume
     /// [`Thread::status`]: crate::Thread::status
-    CoroutineInactive,
+    CoroutineUnresumable,
     /// An [`AnyUserData`] is not the expected type in a borrow.
     ///
     /// This error can only happen when manually using [`AnyUserData`], or when implementing
@@ -189,7 +197,7 @@ pub enum Error {
     /// Returning `Err(ExternalError(...))` from a Rust callback will raise the error as a Lua
     /// error. The Rust code that originally invoked the Lua code then receives a `CallbackError`,
     /// from which the original error (and a stack traceback) can be recovered.
-    ExternalError(Arc<dyn StdError + Send + Sync>),
+    ExternalError(Arc<DynStdError>),
     /// An error with additional context.
     WithContext {
         /// A string containing additional context.
@@ -205,21 +213,21 @@ pub type Result<T> = StdResult<T, Error>;
 #[cfg(not(tarpaulin_include))]
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {message}"),
-            Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {msg}"),
-            Error::MemoryError(ref msg) => {
+        match self {
+            Error::SyntaxError { message, .. } => write!(fmt, "syntax error: {message}"),
+            Error::RuntimeError(msg) => write!(fmt, "runtime error: {msg}"),
+            Error::MemoryError(msg) => {
                 write!(fmt, "memory error: {msg}")
             }
             #[cfg(any(feature = "lua53", feature = "lua52"))]
-            Error::GarbageCollectorError(ref msg) => {
+            Error::GarbageCollectorError(msg) => {
                 write!(fmt, "garbage collector error: {msg}")
             }
-            Error::SafetyError(ref msg) => {
+            Error::SafetyError(msg) => {
                 write!(fmt, "safety error: {msg}")
             },
-            Error::MemoryLimitNotAvailable => {
-                write!(fmt, "setting memory limit is not available")
+            Error::MemoryControlNotAvailable => {
+                write!(fmt, "memory control is not available")
             }
             Error::RecursiveMutCallback => write!(fmt, "mutable callback called recursively"),
             Error::CallbackDestructed => write!(
@@ -234,7 +242,7 @@ impl fmt::Display for Error {
                 fmt,
                 "too many arguments to Function::bind"
             ),
-            Error::BadArgument { ref to, pos, ref name, ref cause } => {
+            Error::BadArgument { to, pos, name, cause } => {
                 if let Some(name) = name {
                     write!(fmt, "bad argument `{name}`")?;
                 } else {
@@ -245,40 +253,40 @@ impl fmt::Display for Error {
                 }
                 write!(fmt, ": {cause}")
             },
-            Error::ToLuaConversionError { from, to, ref message } => {
+            Error::ToLuaConversionError { from, to, message } => {
                 write!(fmt, "error converting {from} to Lua {to}")?;
-                match *message {
+                match message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({message})"),
+                    Some(message) => write!(fmt, " ({message})"),
                 }
             }
-            Error::FromLuaConversionError { from, to, ref message } => {
+            Error::FromLuaConversionError { from, to, message } => {
                 write!(fmt, "error converting Lua {from} to {to}")?;
-                match *message {
+                match message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({message})"),
+                    Some(message) => write!(fmt, " ({message})"),
                 }
             }
-            Error::CoroutineInactive => write!(fmt, "cannot resume inactive coroutine"),
+            Error::CoroutineUnresumable => write!(fmt, "coroutine is non-resumable"),
             Error::UserDataTypeMismatch => write!(fmt, "userdata is not expected type"),
             Error::UserDataDestructed => write!(fmt, "userdata has been destructed"),
             Error::UserDataBorrowError => write!(fmt, "error borrowing userdata"),
             Error::UserDataBorrowMutError => write!(fmt, "error mutably borrowing userdata"),
-            Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {method} is restricted"),
-            Error::MetaMethodTypeError { ref method, type_name, ref message } => {
+            Error::MetaMethodRestricted(method) => write!(fmt, "metamethod {method} is restricted"),
+            Error::MetaMethodTypeError { method, type_name, message } => {
                 write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
-                match *message {
+                match message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({message})"),
+                    Some(message) => write!(fmt, " ({message})"),
                 }
             }
             Error::MismatchedRegistryKey => {
                 write!(fmt, "RegistryKey used from different Lua state")
             }
-            Error::CallbackError { ref cause, ref traceback } => {
+            Error::CallbackError { cause, traceback } => {
                 // Trace errors down to the root
                 let (mut cause, mut full_traceback) = (cause, None);
-                while let Error::CallbackError { cause: ref cause2, traceback: ref traceback2 } = **cause {
+                while let Error::CallbackError { cause: cause2, traceback: traceback2 } = &**cause {
                     cause = cause2;
                     full_traceback = Some(traceback2);
                 }
@@ -302,15 +310,15 @@ impl fmt::Display for Error {
                 write!(fmt, "previously resumed panic returned again")
             }
             #[cfg(feature = "serialize")]
-            Error::SerializeError(ref err) => {
+            Error::SerializeError(err) => {
                 write!(fmt, "serialize error: {err}")
             },
             #[cfg(feature = "serialize")]
-            Error::DeserializeError(ref err) => {
+            Error::DeserializeError(err) => {
                 write!(fmt, "deserialize error: {err}")
             },
-            Error::ExternalError(ref err) => write!(fmt, "{err}"),
-            Error::WithContext { ref context, ref cause } => {
+            Error::ExternalError(err) => err.fmt(fmt),
+            Error::WithContext { context, cause } => {
                 writeln!(fmt, "{context}")?;
                 write!(fmt, "{cause}")
             }
@@ -320,17 +328,15 @@ impl fmt::Display for Error {
 
 impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        match *self {
+        match self {
             // An error type with a source error should either return that error via source or
             // include that source's error message in its own Display output, but never both.
             // https://blog.rust-lang.org/inside-rust/2021/07/01/What-the-error-handling-project-group-is-working-towards.html
-            // Given that we include source to fmt::Display implementation for `CallbackError`, this call returns nothing.
+            // Given that we include source to fmt::Display implementation for `CallbackError`, this call
+            // returns nothing.
             Error::CallbackError { .. } => None,
-            Error::ExternalError(ref err) => err.source(),
-            Error::WithContext { ref cause, .. } => match cause.as_ref() {
-                Error::ExternalError(err) => err.source(),
-                _ => None,
-            },
+            Error::ExternalError(err) => err.source(),
+            Error::WithContext { cause, .. } => Self::source(cause),
             _ => None,
         }
     }
@@ -345,7 +351,7 @@ impl Error {
 
     /// Wraps an external error object.
     #[inline]
-    pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Self {
+    pub fn external<T: Into<Box<DynStdError>>>(err: T) -> Self {
         Error::ExternalError(err.into().into())
     }
 
@@ -356,10 +362,25 @@ impl Error {
     {
         match self {
             Error::ExternalError(err) => err.downcast_ref(),
-            Error::WithContext { cause, .. } => match cause.as_ref() {
-                Error::ExternalError(err) => err.downcast_ref(),
-                _ => None,
-            },
+            Error::WithContext { cause, .. } => Self::downcast_ref(cause),
+            _ => None,
+        }
+    }
+
+    /// An iterator over the chain of nested errors wrapped by this Error.
+    pub fn chain(&self) -> impl Iterator<Item = &(dyn StdError + 'static)> {
+        Chain {
+            root: self,
+            current: None,
+        }
+    }
+
+    /// Returns the parent of this error.
+    #[doc(hidden)]
+    pub fn parent(&self) -> Option<&Error> {
+        match self {
+            Error::CallbackError { cause, .. } => Some(cause.as_ref()),
+            Error::WithContext { cause, .. } => Some(cause.as_ref()),
             _ => None,
         }
     }
@@ -373,15 +394,15 @@ impl Error {
         }
     }
 
-    pub(crate) fn from_lua_conversion<'a>(
+    pub(crate) fn from_lua_conversion(
         from: &'static str,
-        to: &'static str,
-        message: impl Into<Option<&'a str>>,
+        to: impl ToString,
+        message: impl Into<Option<String>>,
     ) -> Self {
         Error::FromLuaConversionError {
             from,
-            to,
-            message: message.into().map(|s| s.into()),
+            to: to.to_string(),
+            message: message.into(),
         }
     }
 }
@@ -391,7 +412,7 @@ pub trait ExternalError {
     fn into_lua_err(self) -> Error;
 }
 
-impl<E: Into<Box<dyn StdError + Send + Sync>>> ExternalError for E {
+impl<E: Into<Box<DynStdError>>> ExternalError for E {
     fn into_lua_err(self) -> Error {
         Error::external(self)
     }
@@ -445,7 +466,7 @@ impl ErrorContext for Error {
     }
 }
 
-impl<T> ErrorContext for StdResult<T, Error> {
+impl<T> ErrorContext for Result<T> {
     fn context<C: fmt::Display>(self, context: C) -> Self {
         self.map_err(|err| err.context(context))
     }
@@ -486,3 +507,64 @@ impl serde::de::Error for Error {
         Self::DeserializeError(msg.to_string())
     }
 }
+
+#[cfg(feature = "anyhow")]
+impl From<anyhow::Error> for Error {
+    fn from(err: anyhow::Error) -> Self {
+        match err.downcast::<Self>() {
+            Ok(err) => err,
+            Err(err) => Error::external(err),
+        }
+    }
+}
+
+struct Chain<'a> {
+    root: &'a Error,
+    current: Option<&'a (dyn StdError + 'static)>,
+}
+
+impl<'a> Iterator for Chain<'a> {
+    type Item = &'a (dyn StdError + 'static);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let error: Option<&dyn StdError> = match self.current {
+                None => {
+                    self.current = Some(self.root);
+                    self.current
+                }
+                Some(current) => match current.downcast_ref::<Error>()? {
+                    Error::BadArgument { cause, .. }
+                    | Error::CallbackError { cause, .. }
+                    | Error::WithContext { cause, .. } => {
+                        self.current = Some(&**cause);
+                        self.current
+                    }
+                    Error::ExternalError(err) => {
+                        self.current = Some(&**err);
+                        self.current
+                    }
+                    _ => None,
+                },
+            };
+
+            // Skip `ExternalError` as it only wraps the underlying error
+            // without meaningful context
+            if let Some(Error::ExternalError(_)) = error?.downcast_ref::<Error>() {
+                continue;
+            }
+
+            return self.current;
+        }
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "error-send"))]
+    static_assertions::assert_not_impl_any!(Error: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Error: Send, Sync);
+}

src/function.rs

@@ -1,49 +1,27 @@
 use std::cell::RefCell;
-use std::mem;
 use std::os::raw::{c_int, c_void};
-use std::ptr;
-use std::slice;
+use std::{mem, ptr, slice};
 
 use crate::error::{Error, Result};
-use crate::lua::Lua;
+use crate::state::Lua;
 use crate::table::Table;
-use crate::types::{Callback, LuaRef, MaybeSend};
+use crate::traits::{FromLuaMulti, IntoLua, IntoLuaMulti, LuaNativeFn, LuaNativeFnMut};
+use crate::types::{Callback, LuaType, MaybeSend, ValueRef};
 use crate::util::{
-    assert_stack, check_stack, 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};
+use crate::value::Value;
 
 #[cfg(feature = "async")]
 use {
+    crate::traits::LuaNativeAsyncFn,
     crate::types::AsyncCallback,
-    futures_util::future::{self, Future},
+    std::future::{self, Future},
 };
 
 /// Handle to an internal Lua function.
-#[derive(Clone, Debug)]
-pub struct Function<'lua>(pub(crate) LuaRef<'lua>);
-
-/// Owned handle to an internal Lua function.
-///
-/// The owned handle holds a *strong* reference to the current Lua instance.
-/// Be warned, if you place it into a Lua type (eg. [`UserData`] or a Rust callback), it is *very easy*
-/// to accidentally cause reference cycles that would prevent destroying Lua instance.
-///
-/// [`UserData`]: crate::UserData
-#[cfg(feature = "unstable")]
-#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
-#[derive(Clone, Debug)]
-pub struct OwnedFunction(pub(crate) crate::types::LuaOwnedRef);
-
-#[cfg(feature = "unstable")]
-impl OwnedFunction {
-    /// Get borrowed handle to the underlying Lua function.
-    #[cfg_attr(feature = "send", allow(unused))]
-    pub const fn to_ref(&self) -> Function {
-        Function(self.0.to_ref())
-    }
-}
+#[derive(Clone, Debug, PartialEq)]
+pub struct Function(pub(crate) ValueRef);
 
 /// Contains information about a function.
 ///
@@ -58,7 +36,8 @@ pub struct FunctionInfo {
     ///
     /// Always `None` for Luau.
     pub name_what: Option<&'static str>,
-    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is the main part of a chunk.
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is
+    /// the main part of a chunk.
     pub what: &'static str,
     /// Source of the chunk that created the function.
     pub source: Option<String>,
@@ -81,7 +60,7 @@ pub struct CoverageInfo {
     pub hits: Vec<i32>,
 }
 
-impl<'lua> Function<'lua> {
+impl Function {
     /// Calls the function, passing `args` as function arguments.
     ///
     /// The function's return values are converted to the generic type `R`.
@@ -98,7 +77,7 @@ impl<'lua> Function<'lua> {
     ///
     /// let tostring: Function = globals.get("tostring")?;
     ///
-    /// assert_eq!(tostring.call::<_, String>(123)?, "123");
+    /// assert_eq!(tostring.call::<String>(123)?, "123");
     ///
     /// # Ok(())
     /// # }
@@ -117,13 +96,13 @@ impl<'lua> Function<'lua> {
     ///         end
     /// "#).eval()?;
     ///
-    /// assert_eq!(sum.call::<_, u32>((3, 4))?, 3 + 4);
+    /// assert_eq!(sum.call::<u32>((3, 4))?, 3 + 4);
     ///
     /// # Ok(())
     /// # }
     /// ```
-    pub fn call<A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
-        let lua = self.0.lua;
+    pub fn call<R: FromLuaMulti>(&self, args: impl IntoLuaMulti) -> Result<R> {
+        let lua = self.0.lua.lock();
         let state = lua.state();
         unsafe {
             let _sg = StackGuard::new(state);
@@ -134,7 +113,7 @@ impl<'lua> Function<'lua> {
             let stack_start = ffi::lua_gettop(state);
             // Push function and the arguments
             lua.push_ref(&self.0);
-            let nargs = args.push_into_stack_multi(lua)?;
+            let nargs = args.push_into_stack_multi(&lua)?;
             // Call the function
             let ret = ffi::lua_pcall(state, nargs, ffi::LUA_MULTRET, stack_start);
             if ret != ffi::LUA_OK {
@@ -142,7 +121,7 @@ impl<'lua> Function<'lua> {
             }
             // Get the results
             let nresults = ffi::lua_gettop(state) - stack_start;
-            R::from_stack_multi(nresults, lua)
+            R::from_stack_multi(nresults, &lua)
         }
     }
 
@@ -167,7 +146,7 @@ impl<'lua> Function<'lua> {
     ///     Ok(())
     /// })?;
     ///
-    /// sleep.call_async(10).await?;
+    /// sleep.call_async::<()>(10).await?;
     ///
     /// # Ok(())
     /// # }
@@ -176,17 +155,18 @@ impl<'lua> Function<'lua> {
     /// [`AsyncThread`]: crate::AsyncThread
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn call_async<A, R>(&self, args: A) -> impl Future<Output = Result<R>> + 'lua
+    pub fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
     where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua,
+        R: FromLuaMulti,
     {
-        let lua = self.0.lua;
-        let thread_res = lua.create_recycled_thread(self).map(|th| {
-            let mut th = th.into_async(args);
-            th.set_recyclable(true);
-            th
-        });
+        let lua = self.0.lua.lock();
+        let thread_res = unsafe {
+            lua.create_recycled_thread(self).map(|th| {
+                let mut th = th.into_async(args);
+                th.set_recyclable(true);
+                th
+            })
+        };
         async move { thread_res?.await }
     }
 
@@ -209,15 +189,15 @@ impl<'lua> Function<'lua> {
     /// "#).eval()?;
     ///
     /// let bound_a = sum.bind(1)?;
-    /// assert_eq!(bound_a.call::<_, u32>(2)?, 1 + 2);
+    /// assert_eq!(bound_a.call::<u32>(2)?, 1 + 2);
     ///
     /// let bound_a_and_b = sum.bind(13)?.bind(57)?;
-    /// assert_eq!(bound_a_and_b.call::<_, u32>(())?, 13 + 57);
+    /// assert_eq!(bound_a_and_b.call::<u32>(())?, 13 + 57);
     ///
     /// # Ok(())
     /// # }
     /// ```
-    pub fn bind<A: IntoLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
+    pub fn bind(&self, args: impl IntoLuaMulti) -> Result<Function> {
         unsafe extern "C-unwind" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
             let nargs = ffi::lua_gettop(state);
             let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(1)) as c_int;
@@ -233,10 +213,10 @@ impl<'lua> Function<'lua> {
             nargs + nbinds
         }
 
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         let state = lua.state();
 
-        let args = args.into_lua_multi(lua)?;
+        let args = args.into_lua_multi(lua.lua())?;
         let nargs = args.len() as c_int;
 
         if nargs == 0 {
@@ -252,7 +232,7 @@ impl<'lua> Function<'lua> {
             check_stack(state, nargs + 3)?;
 
             ffi::lua_pushinteger(state, nargs as ffi::lua_Integer);
-            for arg in args {
+            for arg in &args {
                 lua.push_value(arg)?;
             }
             protect_lua!(state, nargs + 1, 1, fn(state) {
@@ -262,6 +242,7 @@ impl<'lua> Function<'lua> {
             Function(lua.pop_ref())
         };
 
+        let lua = lua.lua();
         lua.load(
             r#"
             local func, args_wrapper = ...
@@ -272,7 +253,7 @@ impl<'lua> Function<'lua> {
         )
         .try_cache()
         .set_name("__mlua_bind")
-        .call((self.clone(), args_wrapper))
+        .call((self, args_wrapper))
     }
 
     /// Returns the environment of the Lua function.
@@ -281,7 +262,7 @@ impl<'lua> Function<'lua> {
     ///
     /// This function always returns `None` for Rust/C functions.
     pub fn environment(&self) -> Option<Table> {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         let state = lua.state();
         unsafe {
             let _sg = StackGuard::new(state);
@@ -299,7 +280,7 @@ impl<'lua> Function<'lua> {
                 // Traverse upvalues until we find the _ENV one
                 match ffi::lua_getupvalue(state, -1, i) {
                     s if s.is_null() => break,
-                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => break,
+                    s if std::ffi::CStr::from_ptr(s as _) == c"_ENV" => break,
                     _ => ffi::lua_pop(state, 1),
                 }
             }
@@ -318,7 +299,7 @@ impl<'lua> Function<'lua> {
     ///
     /// This function does nothing for Rust/C functions.
     pub fn set_environment(&self, env: Table) -> Result<bool> {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         let state = lua.state();
         unsafe {
             let _sg = StackGuard::new(state);
@@ -338,10 +319,11 @@ impl<'lua> Function<'lua> {
             for i in 1..=255 {
                 match ffi::lua_getupvalue(state, -1, i) {
                     s if s.is_null() => return Ok(false),
-                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => {
+                    s if std::ffi::CStr::from_ptr(s as _) == c"_ENV" => {
                         ffi::lua_pop(state, 1);
                         // Create an anonymous function with the new environment
                         let f_with_env = lua
+                            .lua()
                             .load("return _ENV")
                             .set_environment(env)
                             .try_cache()
@@ -364,7 +346,7 @@ impl<'lua> Function<'lua> {
     ///
     /// [`lua_getinfo`]: https://www.lua.org/manual/5.4/manual.html#lua_getinfo
     pub fn info(&self) -> FunctionInfo {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         let state = lua.state();
         unsafe {
             let _sg = StackGuard::new(state);
@@ -407,9 +389,9 @@ impl<'lua> Function<'lua> {
     /// If `strip` is true, the binary representation may not include all debug information
     /// about the function, to save space.
     ///
-    /// For Luau a [Compiler] can be used to compile Lua chunks to bytecode.
+    /// For Luau a [`Compiler`] can be used to compile Lua chunks to bytecode.
     ///
-    /// [Compiler]: crate::chunk::Compiler
+    /// [`Compiler`]: crate::chunk::Compiler
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn dump(&self, strip: bool) -> Vec<u8> {
@@ -425,7 +407,7 @@ impl<'lua> Function<'lua> {
             0
         }
 
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         let state = lua.state();
         let mut data: Vec<u8> = Vec::new();
         unsafe {
@@ -443,8 +425,8 @@ impl<'lua> Function<'lua> {
 
     /// Retrieves recorded coverage information about this Lua function including inner calls.
     ///
-    /// This function takes a callback as an argument and calls it providing [`CoverageInfo`] snapshot
-    /// per each executed inner function.
+    /// This function takes a callback as an argument and calls it providing [`CoverageInfo`]
+    /// snapshot per each executed inner function.
     ///
     /// Recording of coverage information is controlled by [`Compiler::set_coverage_level`] option.
     ///
@@ -482,7 +464,7 @@ impl<'lua> Function<'lua> {
             });
         }
 
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         let state = lua.state();
         unsafe {
             let _sg = StackGuard::new(state);
@@ -508,149 +490,166 @@ impl<'lua> Function<'lua> {
     ///
     /// 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(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn deep_clone(&self) -> Self {
-        let ref_thread = self.0.lua.ref_thread();
+        let lua = self.0.lua.lock();
+        let ref_thread = 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())
+            Function(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")))))]
-    #[inline]
-    pub fn into_owned(self) -> OwnedFunction {
-        OwnedFunction(self.0.into_owned())
-    }
 }
 
-impl<'lua> PartialEq for Function<'lua> {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
-    }
-}
-
-// Additional shortcuts
-#[cfg(feature = "unstable")]
-impl OwnedFunction {
-    /// Calls the function, passing `args` as function arguments.
-    ///
-    /// This is a shortcut for [`Function::call()`].
-    #[inline]
-    pub fn call<'lua, A, R>(&'lua self, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
-    {
-        self.to_ref().call(args)
-    }
-
-    /// Returns a future that, when polled, calls `self`, passing `args` as function arguments,
-    /// and drives the execution.
-    ///
-    /// This is a shortcut for [`Function::call_async()`].
-    #[cfg(feature = "async")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    #[inline]
-    pub async fn call_async<'lua, A, R>(&'lua self, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua,
-    {
-        self.to_ref().call_async(args).await
-    }
-}
-
-pub(crate) struct WrappedFunction<'lua>(pub(crate) Callback<'lua, 'static>);
+struct WrappedFunction(pub(crate) Callback);
 
 #[cfg(feature = "async")]
-pub(crate) struct WrappedAsyncFunction<'lua>(pub(crate) AsyncCallback<'lua, 'static>);
+struct WrappedAsyncFunction(pub(crate) AsyncCallback);
 
-impl<'lua> Function<'lua> {
-    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`] trait.
+impl Function {
+    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
     #[inline]
-    pub fn wrap<A, R, F>(func: F) -> impl IntoLua<'lua>
+    pub fn wrap<F, A, R>(func: F) -> impl IntoLua
     where
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
+        F: LuaNativeFn<A, Output = Result<R>> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
     {
         WrappedFunction(Box::new(move |lua, nargs| unsafe {
             let args = A::from_stack_args(nargs, 1, None, lua)?;
-            func(lua, args)?.push_into_stack_multi(lua)
+            func.call(args)?.push_into_stack_multi(lua)
         }))
     }
 
     /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
-    #[inline]
-    pub fn wrap_mut<A, R, F>(func: F) -> impl IntoLua<'lua>
+    pub fn wrap_mut<F, A, R>(func: F) -> impl IntoLua
     where
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
+        F: LuaNativeFnMut<A, Output = Result<R>> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
     {
         let func = RefCell::new(func);
         WrappedFunction(Box::new(move |lua, nargs| unsafe {
-            let mut func = func
-                .try_borrow_mut()
-                .map_err(|_| Error::RecursiveMutCallback)?;
+            let mut func = func.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
             let args = A::from_stack_args(nargs, 1, None, lua)?;
-            func(lua, args)?.push_into_stack_multi(lua)
+            func.call(args)?.push_into_stack_multi(lua)
         }))
     }
 
-    /// Wraps a Rust async function or closure, returning an opaque type that implements [`IntoLua`] trait.
+    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
+    ///
+    /// This function is similar to [`Function::wrap`] but any returned `Result` will be converted
+    /// to a `ok, err` tuple without throwing an exception.
+    #[inline]
+    pub fn wrap_raw<F, A>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeFn<A> + MaybeSend + 'static,
+        A: FromLuaMulti,
+    {
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func.call(args).push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
+    ///
+    /// This function is similar to [`Function::wrap_mut`] but any returned `Result` will be
+    /// converted to a `ok, err` tuple without throwing an exception.
+    #[inline]
+    pub fn wrap_raw_mut<F, A>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeFnMut<A> + MaybeSend + 'static,
+        A: FromLuaMulti,
+    {
+        let func = RefCell::new(func);
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let mut func = func.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func.call(args).push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust async function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn wrap_async<A, R, F, FR>(func: F) -> impl IntoLua<'lua>
+    pub fn wrap_async<F, A, R>(func: F) -> impl IntoLua
     where
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
-        FR: Future<Output = Result<R>> + 'lua,
+        F: LuaNativeAsyncFn<A, Output = Result<R>> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
     {
-        WrappedAsyncFunction(Box::new(move |lua, args| unsafe {
-            let args = match A::from_lua_args(args, 1, None, lua) {
+        WrappedAsyncFunction(Box::new(move |rawlua, nargs| unsafe {
+            let args = match A::from_stack_args(nargs, 1, None, rawlua) {
                 Ok(args) => args,
-                Err(e) => return Box::pin(future::err(e)),
+                Err(e) => return Box::pin(future::ready(Err(e))),
             };
-            let fut = func(lua, args);
-            Box::pin(async move { fut.await?.push_into_stack_multi(lua) })
+            let lua = rawlua.lua();
+            let fut = func.call(args);
+            Box::pin(async move { fut.await?.push_into_stack_multi(lua.raw_lua()) })
+        }))
+    }
+
+    /// Wraps a Rust async function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
+    ///
+    /// This function is similar to [`Function::wrap_async`] but any returned `Result` will be
+    /// converted to a `ok, err` tuple without throwing an exception.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn wrap_raw_async<F, A>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeAsyncFn<A> + MaybeSend + 'static,
+        A: FromLuaMulti,
+    {
+        WrappedAsyncFunction(Box::new(move |rawlua, nargs| unsafe {
+            let args = match A::from_stack_args(nargs, 1, None, rawlua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let lua = rawlua.lua();
+            let fut = func.call(args);
+            Box::pin(async move { fut.await.push_into_stack_multi(lua.raw_lua()) })
         }))
     }
 }
 
-impl<'lua> IntoLua<'lua> for WrappedFunction<'lua> {
+impl IntoLua for WrappedFunction {
     #[inline]
-    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        lua.create_callback(self.0).map(Value::Function)
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.lock().create_callback(self.0).map(Value::Function)
     }
 }
 
 #[cfg(feature = "async")]
-impl<'lua> IntoLua<'lua> for WrappedAsyncFunction<'lua> {
+impl IntoLua for WrappedAsyncFunction {
     #[inline]
-    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        lua.create_async_callback(self.0).map(Value::Function)
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.lock().create_async_callback(self.0).map(Value::Function)
     }
 }
 
+impl LuaType for Function {
+    const TYPE_ID: c_int = ffi::LUA_TFUNCTION;
+}
+
 #[cfg(test)]
 mod assertions {
     use super::*;
 
+    #[cfg(not(feature = "send"))]
     static_assertions::assert_not_impl_any!(Function: Send);
-
-    #[cfg(all(feature = "unstable", not(feature = "send")))]
-    static_assertions::assert_not_impl_any!(OwnedFunction: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Function: Send, Sync);
 }

src/hook.rs

@@ -1,12 +1,14 @@
 use std::borrow::Cow;
 use std::cell::UnsafeCell;
+use std::ops::Deref;
 #[cfg(not(feature = "luau"))]
 use std::ops::{BitOr, BitOrAssign};
 use std::os::raw::c_int;
 
 use ffi::lua_Debug;
 
-use crate::lua::Lua;
+use crate::state::RawLua;
+use crate::types::ReentrantMutexGuard;
 use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
 
 /// Contains information about currently executing Lua code.
@@ -14,29 +16,48 @@ use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
 /// The `Debug` structure is provided as a parameter to the hook function set with
 /// [`Lua::set_hook`]. You may call the methods on this structure to retrieve information about the
 /// Lua code executing at the time that the hook function was called. Further information can be
-/// found in the Lua [documentation][lua_doc].
+/// found in the Lua [documentation].
 ///
-/// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
+/// [documentation]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
 /// [`Lua::set_hook`]: crate::Lua::set_hook
-pub struct Debug<'lua> {
-    lua: &'lua Lua,
+pub struct Debug<'a> {
+    lua: EitherLua<'a>,
     ar: ActivationRecord,
     #[cfg(feature = "luau")]
     level: c_int,
 }
 
-impl<'lua> Debug<'lua> {
+enum EitherLua<'a> {
+    Owned(ReentrantMutexGuard<'a, RawLua>),
     #[cfg(not(feature = "luau"))]
-    pub(crate) fn new(lua: &'lua Lua, ar: *mut lua_Debug) -> Self {
+    Borrowed(&'a RawLua),
+}
+
+impl Deref for EitherLua<'_> {
+    type Target = RawLua;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            EitherLua::Owned(guard) => guard,
+            #[cfg(not(feature = "luau"))]
+            EitherLua::Borrowed(lua) => lua,
+        }
+    }
+}
+
+impl<'a> Debug<'a> {
+    // We assume the lock is held when this function is called.
+    #[cfg(not(feature = "luau"))]
+    pub(crate) fn new(lua: &'a RawLua, ar: *mut lua_Debug) -> Self {
         Debug {
-            lua,
+            lua: EitherLua::Borrowed(lua),
             ar: ActivationRecord::Borrowed(ar),
         }
     }
 
-    pub(crate) fn new_owned(lua: &'lua Lua, _level: c_int, ar: lua_Debug) -> Self {
+    pub(crate) fn new_owned(guard: ReentrantMutexGuard<'a, RawLua>, _level: c_int, ar: lua_Debug) -> Self {
         Debug {
-            lua,
+            lua: EitherLua::Owned(guard),
             ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
             #[cfg(feature = "luau")]
             level: _level,
@@ -45,7 +66,7 @@ impl<'lua> Debug<'lua> {
 
     /// Returns the specific event that triggered the hook.
     ///
-    /// For [Lua 5.1] `DebugEvent::TailCall` is used for return events to indicate a return
+    /// For [Lua 5.1] [`DebugEvent::TailCall`] is used for return events to indicate a return
     /// from a function that did a tail call.
     ///
     /// [Lua 5.1]: https://www.lua.org/manual/5.1/manual.html#pdf-LUA_HOOKTAILRET
@@ -163,8 +184,8 @@ impl<'lua> Debug<'lua> {
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("a"), self.ar.get()) != 0,
-                "lua_getinfo failed with `a`"
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("au"), self.ar.get()) != 0,
+                "lua_getinfo failed with `au`"
             );
 
             #[cfg(not(feature = "luau"))]
@@ -177,8 +198,8 @@ impl<'lua> Debug<'lua> {
             };
             #[cfg(feature = "luau")]
             let stack = DebugStack {
-                num_ups: (*self.ar.get()).nupvals as i32,
-                num_params: (*self.ar.get()).nparams as i32,
+                num_ups: (*self.ar.get()).nupvals,
+                num_params: (*self.ar.get()).nparams,
                 is_vararg: (*self.ar.get()).isvararg != 0,
             };
             stack
@@ -234,28 +255,24 @@ pub struct DebugSource<'a> {
     pub line_defined: Option<usize>,
     /// The line number where the definition of the function ends (not set by Luau).
     pub last_line_defined: Option<usize>,
-    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is the main part of a chunk.
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is
+    /// the main part of a chunk.
     pub what: &'static str,
 }
 
 #[derive(Copy, Clone, Debug)]
 pub struct DebugStack {
-    pub num_ups: i32,
+    /// Number of upvalues.
+    pub num_ups: u8,
+    /// Number of parameters.
+    ///
     /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
-    pub num_params: i32,
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
+    pub num_params: u8,
+    /// Whether the function is a vararg function.
+    ///
     /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
     pub is_vararg: bool,
 }
 

src/lib.rs

@@ -27,123 +27,115 @@
 //!
 //! # Serde support
 //!
-//! The [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua values
-//! and vice versa using serde. Any user defined data type that implements [`serde::Serialize`] or
-//! [`serde::Deserialize`] can be converted.
+//! The [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua
+//! values and vice versa using serde. Any user defined data type that implements
+//! [`serde::Serialize`] or [`serde::Deserialize`] can be converted.
 //! For convenience, additional functionality to handle `NULL` values and arrays is provided.
 //!
-//! The [`Value`] enum implements [`serde::Serialize`] trait to support serializing Lua values
-//! (including [`UserData`]) into Rust values.
+//! The [`Value`] enum and other types implement [`serde::Serialize`] trait to support serializing
+//! Lua values into Rust values.
 //!
 //! Requires `feature = "serialize"`.
 //!
 //! # Async/await support
 //!
-//! The [`create_async_function`] allows creating non-blocking functions that returns [`Future`].
-//! Lua code with async capabilities can be executed by [`call_async`] family of functions or polling
-//! [`AsyncThread`] using any runtime (eg. Tokio).
+//! The [`Lua::create_async_function`] allows creating non-blocking functions that returns
+//! [`Future`]. Lua code with async capabilities can be executed by [`Function::call_async`] family
+//! of functions or polling [`AsyncThread`] using any runtime (eg. Tokio).
 //!
 //! Requires `feature = "async"`.
 //!
-//! # `Send` requirement
-//! By default `mlua` is `!Send`. This can be changed by enabling `feature = "send"` that adds `Send` requirement
-//! to [`Function`]s and [`UserData`].
+//! # `Send` and `Sync` support
+//!
+//! By default `mlua` is `!Send`. This can be changed by enabling `feature = "send"` that adds
+//! `Send` requirement to Rust functions and [`UserData`] types.
+//!
+//! In this case [`Lua`] object and their types can be send or used from other threads. Internally
+//! access to Lua VM is synchronized using a reentrant mutex that can be locked many times within
+//! the same thread.
 //!
 //! [Lua programming language]: https://www.lua.org/
-//! [`Lua`]: crate::Lua
 //! [executing]: crate::Chunk::exec
 //! [evaluating]: crate::Chunk::eval
 //! [globals]: crate::Lua::globals
-//! [`IntoLua`]: crate::IntoLua
-//! [`FromLua`]: crate::FromLua
-//! [`IntoLuaMulti`]: crate::IntoLuaMulti
-//! [`FromLuaMulti`]: crate::FromLuaMulti
-//! [`Function`]: crate::Function
-//! [`UserData`]: crate::UserData
-//! [`UserDataFields`]: crate::UserDataFields
-//! [`UserDataMethods`]: crate::UserDataMethods
-//! [`LuaSerdeExt`]: crate::LuaSerdeExt
-//! [`Value`]: crate::Value
-//! [`create_async_function`]: crate::Lua::create_async_function
-//! [`call_async`]: crate::Function::call_async
-//! [`AsyncThread`]: crate::AsyncThread
 //! [`Future`]: std::future::Future
 //! [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
-#![doc(test(attr(warn(warnings))))] // FIXME: Remove this when rust-lang/rust#123748 is fixed
 #![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(not(send), allow(clippy::arc_with_non_send_sync))]
+#![allow(clippy::ptr_eq)]
 
 #[macro_use]
 mod macros;
 
+mod buffer;
 mod chunk;
 mod conversion;
 mod error;
 mod function;
 mod hook;
-mod lua;
 #[cfg(feature = "luau")]
 mod luau;
 mod memory;
 mod multi;
 mod scope;
+mod state;
 mod stdlib;
 mod string;
 mod table;
 mod thread;
+mod traits;
 mod types;
 mod userdata;
-mod userdata_ext;
-mod userdata_impl;
 mod util;
 mod value;
+mod vector;
 
 pub mod prelude;
 
+pub use bstr::BString;
 pub use ffi::{self, lua_CFunction, lua_State};
 
 pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
 pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
 pub use crate::function::{Function, FunctionInfo};
 pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
-pub use crate::lua::{GCMode, Lua, LuaOptions};
-pub use crate::multi::Variadic;
+pub use crate::multi::{MultiValue, Variadic};
 pub use crate::scope::Scope;
+pub use crate::state::{GCMode, Lua, LuaOptions, WeakLua};
 pub use crate::stdlib::StdLib;
-pub use crate::string::String;
-pub use crate::table::{Table, TableExt, TablePairs, TableSequence};
+pub use crate::string::{BorrowedBytes, BorrowedStr, String};
+pub use crate::table::{Table, TablePairs, TableSequence};
 pub use crate::thread::{Thread, ThreadStatus};
-pub use crate::types::{AppDataRef, AppDataRefMut, Integer, LightUserData, Number, RegistryKey};
-pub use crate::userdata::{
-    AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
-    UserDataRef, UserDataRefMut,
+pub use crate::traits::{
+    FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, LuaNativeFn, LuaNativeFnMut, ObjectLike,
 };
-pub use crate::userdata_ext::AnyUserDataExt;
-pub use crate::userdata_impl::UserDataRegistry;
-pub use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, Value};
+pub use crate::types::{
+    AppDataRef, AppDataRefMut, Either, Integer, LightUserData, MaybeSend, Number, RegistryKey, VmState,
+};
+pub use crate::userdata::{
+    AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods, UserDataRef,
+    UserDataRefMut, UserDataRegistry,
+};
+pub use crate::value::{Nil, Value};
 
 #[cfg(not(feature = "luau"))]
 pub use crate::hook::HookTriggers;
 
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-pub use crate::{
-    chunk::Compiler,
-    function::CoverageInfo,
-    types::{Vector, VmState},
-};
+pub use crate::{buffer::Buffer, chunk::Compiler, function::CoverageInfo, vector::Vector};
 
 #[cfg(feature = "async")]
-pub use crate::thread::AsyncThread;
+#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+pub use crate::{thread::AsyncThread, traits::LuaNativeAsyncFn};
 
 #[cfg(feature = "serialize")]
 #[doc(inline)]
-pub use crate::serde::{
-    de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt,
-};
+pub use crate::serde::{de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt};
 
 #[cfg(feature = "serialize")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
@@ -154,13 +146,6 @@ pub mod serde;
 #[macro_use]
 extern crate mlua_derive;
 
-// Unstable features
-#[cfg(feature = "unstable")]
-pub use crate::{
-    function::OwnedFunction, string::OwnedString, table::OwnedTable, thread::OwnedThread,
-    userdata::OwnedAnyUserData,
-};
-
 /// Create a type that implements [`AsChunk`] and can capture Rust variables.
 ///
 /// This macro allows to write Lua code directly in Rust code.
@@ -201,18 +186,14 @@ pub use crate::{
 ///
 /// Other minor limitations:
 ///
-/// - Certain escape codes in string literals don't work.
-///   (Specifically: `\a`, `\b`, `\f`, `\v`, `\123` (octal escape codes), `\u`, and `\U`).
+/// - Certain escape codes in string literals don't work. (Specifically: `\a`, `\b`, `\f`, `\v`,
+///   `\123` (octal escape codes), `\u`, and `\U`).
 ///
 ///   These are accepted: : `\\`, `\n`, `\t`, `\r`, `\xAB` (hex escape codes), and `\0`.
 ///
 /// - The `//` (floor division) operator is unusable, as its start a comment.
 ///
 /// Everything else should work.
-///
-/// [`AsChunk`]: crate::AsChunk
-/// [`UserData`]: crate::UserData
-/// [`IntoLua`]: crate::IntoLua
 #[cfg(feature = "macros")]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
@@ -266,11 +247,13 @@ pub use mlua_derive::FromLua;
 ///     ...
 /// }
 /// ```
-///
 #[cfg(any(feature = "module", docsrs))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;
 
+#[cfg(all(feature = "module", feature = "send"))]
+compile_error!("`send` feature is not supported in module mode");
+
 pub(crate) mod private {
     use super::*;
 
@@ -279,6 +262,6 @@ pub(crate) mod private {
     impl Sealed for Error {}
     impl<T> Sealed for std::result::Result<T, Error> {}
     impl Sealed for Lua {}
-    impl Sealed for Table<'_> {}
-    impl Sealed for AnyUserData<'_> {}
+    impl Sealed for Table {}
+    impl Sealed for AnyUserData {}
 }

src/luau/mod.rs

@@ -1,8 +1,8 @@
 use std::ffi::CStr;
-use std::os::raw::{c_float, c_int};
+use std::os::raw::c_int;
 
 use crate::error::Result;
-use crate::lua::Lua;
+use crate::state::Lua;
 
 // Since Luau has some missing standard functions, we re-implement them here
 
@@ -10,11 +10,7 @@ impl Lua {
     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("vector", self.create_c_function(lua_vector)?)?;
+        globals.raw_set("collectgarbage", self.create_c_function(lua_collectgarbage)?)?;
 
         // Set `_VERSION` global to include version number
         // The environment variable `LUAU_VERSION` set by the build script
@@ -55,7 +51,7 @@ unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_
             1
         }
         Ok("step") => {
-            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg);
+            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg as _);
             ffi::lua_pushboolean(state, res);
             1
         }
@@ -68,21 +64,6 @@ unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_
     }
 }
 
-// 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;
-    let y = ffi::luaL_checknumber(state, 2) as c_float;
-    let z = ffi::luaL_checknumber(state, 3) as c_float;
-    #[cfg(feature = "luau-vector4")]
-    let w = ffi::luaL_checknumber(state, 4) as c_float;
-
-    #[cfg(not(feature = "luau-vector4"))]
-    ffi::lua_pushvector(state, x, y, z);
-    #[cfg(feature = "luau-vector4")]
-    ffi::lua_pushvector(state, x, y, z, w);
-    1
-}
-
 pub(crate) use package::register_package_module;
 
 mod package;

src/luau/package.rs

@@ -7,10 +7,10 @@ use std::{env, fs};
 
 use crate::chunk::ChunkMode;
 use crate::error::Result;
-use crate::lua::Lua;
+use crate::state::Lua;
 use crate::table::Table;
-use crate::types::RegistryKey;
-use crate::value::{IntoLua, Value};
+use crate::traits::IntoLua;
+use crate::value::Value;
 
 #[cfg(unix)]
 use {libloading::Library, rustc_hash::FxHashMap};
@@ -20,16 +20,13 @@ use {libloading::Library, rustc_hash::FxHashMap};
 //
 
 #[cfg(unix)]
-const TARGET_MLUA_LUAU_ABI_VERSION: u32 = 1;
+const TARGET_MLUA_LUAU_ABI_VERSION: u32 = 3;
 
 #[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>);
@@ -51,9 +48,8 @@ impl std::ops::DerefMut for LoadedDylibs {
 }
 
 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)
+    // Create the package table
     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")
@@ -81,13 +77,19 @@ pub(crate) fn register_package_module(lua: &Lua) -> Result<()> {
     }
 
     // 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)?;
+    let loaded = if let Ok(Some(loaded)) = lua.named_registry_value::<Option<Table>>("_LOADED") {
+        package.raw_set("loaded", &loaded)?;
+        loaded
+    } else {
+        let loaded = lua.create_table()?;
+        package.raw_set("loaded", &loaded)?;
+        lua.set_named_registry_value("_LOADED", &loaded)?;
+        loaded
+    };
 
     // Set `package.loaders`
     let loaders = lua.create_sequence_from([lua.create_function(lua_loader)?])?;
-    package.raw_set("loaders", loaders.clone())?;
+    package.raw_set("loaders", &loaders)?;
     #[cfg(unix)]
     {
         loaders.push(lua.create_function(dylib_loader)?)?;
@@ -97,7 +99,8 @@ pub(crate) fn register_package_module(lua: &Lua) -> Result<()> {
 
     // Register the module and `require` function in globals
     let globals = lua.globals();
-    globals.raw_set("package", package)?;
+    globals.raw_set("package", &package)?;
+    loaded.raw_set("package", package)?;
     globals.raw_set("require", unsafe { lua.create_c_function(lua_require)? })?;
 
     Ok(())
@@ -121,8 +124,7 @@ unsafe extern "C-unwind" fn lua_require(state: *mut ffi::lua_State) -> c_int {
     ffi::lua_pop(state, 1); // remove nil
 
     // load the module
-    let err_buf = ffi::lua_newuserdata_t::<StdString>(state);
-    err_buf.write(StdString::new());
+    let err_buf = ffi::lua_newuserdata_t(state, 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 {
@@ -191,17 +193,17 @@ fn package_searchpath(name: &str, search_path: &str, try_prefix: bool) -> Option
 /// 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 loaded = lua.named_registry_value::<Table>("_LOADED")?;
+        loaded.raw_get::<Table>("package")
     }?;
-    let search_path = package.get::<_, StdString>("path").unwrap_or_default();
+    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()))
+                    .load(buf)
+                    .set_name(format!("={}", file_path.display()))
                     .set_mode(ChunkMode::Text)
                     .into_function()
                     .map(Value::Function);
@@ -219,20 +221,19 @@ fn lua_loader(lua: &Lua, modname: StdString) -> Result<Value> {
 #[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 loaded = lua.named_registry_value::<Table>("_LOADED")?;
+        loaded.raw_get::<Table>("package")
     }?;
-    let search_cpath = package.get::<_, StdString>("cpath").unwrap_or_default();
+    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())
-        {
+        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(),
-        ) {
+        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)

src/macros.rs

@@ -10,8 +10,7 @@ macro_rules! bug_msg {
 
 macro_rules! cstr {
     ($s:expr) => {
-        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char]
-            as *const ::std::os::raw::c_char
+        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char] as *const ::std::os::raw::c_char
     };
 }
 

src/memory.rs

@@ -18,15 +18,32 @@ pub(crate) struct MemoryState {
 }
 
 impl MemoryState {
+    #[cfg(feature = "luau")]
     #[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");
+        ffi::lua_getallocf(state, &mut mem_state);
+        mlua_assert!(!mem_state.is_null(), "Luau state has no allocator userdata");
+        mem_state as *mut MemoryState
+    }
+
+    #[cfg(not(feature = "luau"))]
+    #[rustversion::since(1.85)]
+    #[inline]
+    #[allow(clippy::incompatible_msrv)]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        if !ptr::fn_addr_eq(ffi::lua_getallocf(state, &mut mem_state), ALLOCATOR) {
+            mem_state = ptr::null_mut();
         }
-        #[cfg(not(feature = "luau"))]
+        mem_state as *mut MemoryState
+    }
+
+    #[cfg(not(feature = "luau"))]
+    #[rustversion::before(1.85)]
+    #[inline]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
         if ffi::lua_getallocf(state, &mut mem_state) != ALLOCATOR {
             mem_state = ptr::null_mut();
         }
@@ -80,7 +97,7 @@ impl MemoryState {
     }
 }
 
-unsafe extern "C-unwind" fn allocator(
+unsafe extern "C" fn allocator(
     extra: *mut c_void,
     ptr: *mut c_void,
     osize: usize,

src/multi.rs

@@ -1,135 +1,212 @@
+use std::collections::{vec_deque, VecDeque};
+use std::iter::FromIterator;
+use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::os::raw::c_int;
 use std::result::Result as StdResult;
 
 use crate::error::Result;
-use crate::lua::Lua;
+use crate::state::{Lua, RawLua};
+use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti};
 use crate::util::check_stack;
-use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil};
+use crate::value::{Nil, Value};
 
-/// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
+/// Result is convertible to [`MultiValue`] following the common Lua idiom of returning the result
 /// on success, or in the case of an error, returning `nil` and an error message.
-impl<'lua, T: IntoLua<'lua>, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<T, E> {
+impl<T: IntoLua, E: IntoLua> IntoLuaMulti for StdResult<T, E> {
     #[inline]
-    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut result = MultiValue::with_lua_and_capacity(lua, 2);
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
         match self {
-            Ok(v) => result.push_front(v.into_lua(lua)?),
-            Err(e) => {
-                result.push_front(e.into_lua(lua)?);
-                result.push_front(Nil);
-            }
+            Ok(val) => (val,).into_lua_multi(lua),
+            Err(err) => (Nil, err).into_lua_multi(lua),
         }
-        Ok(result)
     }
 
     #[inline]
-    unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> 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)
-            }
+            Ok(val) => (val,).push_into_stack_multi(lua),
+            Err(err) => (Nil, err).push_into_stack_multi(lua),
         }
     }
 }
 
-impl<'lua, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<(), E> {
+impl<E: IntoLua> IntoLuaMulti for StdResult<(), E> {
     #[inline]
-    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
         match self {
-            Ok(_) => return Ok(MultiValue::new()),
-            Err(e) => {
-                let mut result = MultiValue::with_lua_and_capacity(lua, 2);
-                result.push_front(e.into_lua(lua)?);
-                result.push_front(Nil);
-                Ok(result)
-            }
+            Ok(_) => const { Ok(MultiValue::new()) },
+            Err(err) => (Nil, err).into_lua_multi(lua),
         }
     }
 
     #[inline]
-    unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> 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)
-            }
+            Err(err) => (Nil, err).push_into_stack_multi(lua),
         }
     }
 }
 
-impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for T {
+impl<T: IntoLua> IntoLuaMulti for T {
     #[inline]
-    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut v = MultiValue::with_lua_and_capacity(lua, 1);
-        v.push_front(self.into_lua(lua)?);
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        let mut v = MultiValue::with_capacity(1);
+        v.push_back(self.into_lua(lua)?);
         Ok(v)
     }
 
     #[inline]
-    unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
         self.push_into_stack(lua)?;
         Ok(1)
     }
 }
 
-impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
+impl<T: FromLua> FromLuaMulti for T {
     #[inline]
-    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+    fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
         T::from_lua(values.pop_front().unwrap_or(Nil), lua)
     }
 
     #[inline]
-    fn from_lua_args(
-        mut args: MultiValue<'lua>,
-        i: usize,
-        to: Option<&str>,
-        lua: &'lua Lua,
-    ) -> Result<Self> {
+    fn from_lua_args(mut args: MultiValue, i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
         T::from_lua_arg(args.pop_front().unwrap_or(Nil), i, to, lua)
     }
 
     #[inline]
-    unsafe fn from_stack_multi(nvals: c_int, lua: &'lua Lua) -> Result<Self> {
+    unsafe fn from_stack_multi(nvals: c_int, lua: &RawLua) -> Result<Self> {
         if nvals == 0 {
-            return T::from_lua(Nil, lua);
+            return T::from_lua(Nil, lua.lua());
         }
         T::from_stack(-nvals, lua)
     }
 
     #[inline]
-    unsafe fn from_stack_args(
-        nargs: c_int,
-        i: usize,
-        to: Option<&str>,
-        lua: &'lua Lua,
-    ) -> Result<Self> {
+    unsafe fn from_stack_args(nargs: c_int, i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
         if nargs == 0 {
-            return T::from_lua_arg(Nil, i, to, lua);
+            return T::from_lua_arg(Nil, i, to, lua.lua());
         }
         T::from_stack_arg(-nargs, i, to, lua)
     }
 }
 
-impl<'lua> IntoLuaMulti<'lua> for MultiValue<'lua> {
+/// Multiple Lua values used for both argument passing and also for multiple return values.
+#[derive(Default, Debug, Clone)]
+pub struct MultiValue(VecDeque<Value>);
+
+impl Deref for MultiValue {
+    type Target = VecDeque<Value>;
+
     #[inline]
-    fn into_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for MultiValue {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl MultiValue {
+    /// Creates an empty `MultiValue` containing no values.
+    #[inline]
+    pub const fn new() -> MultiValue {
+        MultiValue(VecDeque::new())
+    }
+
+    /// Creates an empty `MultiValue` container with space for at least `capacity` elements.
+    pub fn with_capacity(capacity: usize) -> MultiValue {
+        MultiValue(VecDeque::with_capacity(capacity))
+    }
+
+    /// Creates a `MultiValue` container from vector of values.
+    ///
+    /// This method works in *O*(1) time and does not allocate any additional memory.
+    #[inline]
+    pub fn from_vec(vec: Vec<Value>) -> MultiValue {
+        vec.into()
+    }
+
+    /// Consumes the `MultiValue` and returns a vector of values.
+    ///
+    /// This method needs *O*(*n*) data movement if the circular buffer doesn't happen to be at the
+    /// beginning of the allocation.
+    #[inline]
+    pub fn into_vec(self) -> Vec<Value> {
+        self.into()
+    }
+
+    #[inline]
+    pub(crate) fn from_lua_iter<T: IntoLua>(lua: &Lua, iter: impl IntoIterator<Item = T>) -> Result<Self> {
+        let iter = iter.into_iter();
+        let mut multi_value = MultiValue::with_capacity(iter.size_hint().0);
+        for value in iter {
+            multi_value.push_back(value.into_lua(lua)?);
+        }
+        Ok(multi_value)
+    }
+}
+
+impl From<Vec<Value>> for MultiValue {
+    #[inline]
+    fn from(value: Vec<Value>) -> Self {
+        MultiValue(value.into())
+    }
+}
+
+impl From<MultiValue> for Vec<Value> {
+    #[inline]
+    fn from(value: MultiValue) -> Self {
+        value.0.into()
+    }
+}
+
+impl FromIterator<Value> for MultiValue {
+    #[inline]
+    fn from_iter<I: IntoIterator<Item = Value>>(iter: I) -> Self {
+        let mut multi_value = MultiValue::new();
+        multi_value.extend(iter);
+        multi_value
+    }
+}
+
+impl IntoIterator for MultiValue {
+    type Item = Value;
+    type IntoIter = vec_deque::IntoIter<Value>;
+
+    #[inline]
+    fn into_iter(mut self) -> Self::IntoIter {
+        let deque = mem::take(&mut self.0);
+        mem::forget(self);
+        deque.into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a MultiValue {
+    type Item = &'a Value;
+    type IntoIter = vec_deque::Iter<'a, Value>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
+impl IntoLuaMulti for MultiValue {
+    #[inline]
+    fn into_lua_multi(self, _: &Lua) -> Result<MultiValue> {
         Ok(self)
     }
 }
 
-impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
+impl FromLuaMulti for MultiValue {
     #[inline]
-    fn from_lua_multi(values: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua_multi(values: MultiValue, _: &Lua) -> Result<Self> {
         Ok(values)
     }
 }
@@ -157,10 +234,7 @@ impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
 /// # Ok(())
 /// # }
 /// ```
-///
-/// [`FromLua`]: crate::FromLua
-/// [`MultiValue`]: crate::MultiValue
-#[derive(Debug, Clone)]
+#[derive(Default, Debug, Clone)]
 pub struct Variadic<T>(Vec<T>);
 
 impl<T> Variadic<T> {
@@ -168,11 +242,38 @@ impl<T> Variadic<T> {
     pub const fn new() -> Variadic<T> {
         Variadic(Vec::new())
     }
+
+    /// Creates an empty `Variadic` container with space for at least `capacity` elements.
+    pub fn with_capacity(capacity: usize) -> Variadic<T> {
+        Variadic(Vec::with_capacity(capacity))
+    }
 }
 
-impl<T> Default for Variadic<T> {
-    fn default() -> Variadic<T> {
-        Variadic::new()
+impl<T> Deref for Variadic<T> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for Variadic<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T> From<Vec<T>> for Variadic<T> {
+    #[inline]
+    fn from(vec: Vec<T>) -> Self {
+        Variadic(vec)
+    }
+}
+
+impl<T> From<Variadic<T>> for Vec<T> {
+    #[inline]
+    fn from(value: Variadic<T>) -> Self {
+        value.0
     }
 }
 
@@ -191,35 +292,19 @@ impl<T> IntoIterator for Variadic<T> {
     }
 }
 
-impl<T> Deref for Variadic<T> {
-    type Target = Vec<T>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<T> DerefMut for Variadic<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for Variadic<T> {
+impl<T: IntoLua> IntoLuaMulti for Variadic<T> {
     #[inline]
-    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut values = MultiValue::with_lua_and_capacity(lua, self.0.len());
-        values.refill(self.0.into_iter().map(|e| e.into_lua(lua)))?;
-        Ok(values)
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        MultiValue::from_lua_iter(lua, self)
     }
 }
 
-impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
+impl<T: FromLua> FromLuaMulti for Variadic<T> {
     #[inline]
-    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+    fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
         values
-            .drain_all()
-            .map(|e| T::from_lua(e, lua))
+            .drain(..)
+            .map(|val| T::from_lua(val, lua))
             .collect::<Result<Vec<T>>>()
             .map(Variadic)
     }
@@ -227,42 +312,39 @@ impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
 
 macro_rules! impl_tuple {
     () => (
-        impl<'lua> IntoLuaMulti<'lua> for () {
+        impl IntoLuaMulti for () {
             #[inline]
-            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-                Ok(MultiValue::with_lua_and_capacity(lua, 0))
+            fn into_lua_multi(self, _: &Lua) -> Result<MultiValue> {
+                const { Ok(MultiValue::new()) }
             }
 
             #[inline]
-            unsafe fn push_into_stack_multi(self, _lua: &'lua Lua) -> Result<c_int> {
+            unsafe fn push_into_stack_multi(self, _lua: &RawLua) -> Result<c_int> {
                 Ok(0)
             }
         }
 
-        impl<'lua> FromLuaMulti<'lua> for () {
+        impl FromLuaMulti for () {
             #[inline]
-            fn from_lua_multi(_values: MultiValue<'lua>, _lua: &'lua Lua) -> Result<Self> {
+            fn from_lua_multi(_values: MultiValue, _lua: &Lua) -> Result<Self> {
                 Ok(())
             }
 
             #[inline]
-            unsafe fn from_stack_multi(nvals: c_int, lua: &'lua Lua) -> Result<Self> {
-                if nvals > 0 {
-                    ffi::lua_pop(lua.state(), nvals);
-                }
+            unsafe fn from_stack_multi(_nvals: c_int, _lua: &RawLua) -> Result<Self> {
                 Ok(())
             }
         }
     );
 
     ($last:ident $($name:ident)*) => (
-        impl<'lua, $($name,)* $last> IntoLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: IntoLua<'lua>,)*
-                  $last: IntoLuaMulti<'lua>
+        impl<$($name,)* $last> IntoLuaMulti for ($($name,)* $last,)
+            where $($name: IntoLua,)*
+                  $last: IntoLuaMulti
         {
             #[allow(unused_mut, non_snake_case)]
             #[inline]
-            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+            fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
                 let ($($name,)* $last,) = self;
 
                 let mut results = $last.into_lua_multi(lua)?;
@@ -272,7 +354,7 @@ macro_rules! impl_tuple {
 
             #[allow(non_snake_case)]
             #[inline]
-            unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
+            unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
                 let ($($name,)* $last,) = self;
                 let mut nresults = 0;
                 $(
@@ -288,13 +370,13 @@ macro_rules! impl_tuple {
             }
         }
 
-        impl<'lua, $($name,)* $last> FromLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: FromLua<'lua>,)*
-                  $last: FromLuaMulti<'lua>
+        impl<$($name,)* $last> FromLuaMulti for ($($name,)* $last,)
+            where $($name: FromLua,)*
+                  $last: FromLuaMulti
         {
             #[allow(unused_mut, non_snake_case)]
             #[inline]
-            fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+            fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
                 $(let $name = FromLua::from_lua(values.pop_front().unwrap_or(Nil), lua)?;)*
                 let $last = FromLuaMulti::from_lua_multi(values, lua)?;
                 Ok(($($name,)* $last,))
@@ -302,7 +384,7 @@ macro_rules! impl_tuple {
 
             #[allow(unused_mut, non_snake_case)]
             #[inline]
-            fn from_lua_args(mut args: MultiValue<'lua>, mut i: usize, to: Option<&str>, lua: &'lua Lua) -> Result<Self> {
+            fn from_lua_args(mut args: MultiValue, mut i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
                 $(
                     let $name = FromLua::from_lua_arg(args.pop_front().unwrap_or(Nil), i, to, lua)?;
                     i += 1;
@@ -313,13 +395,13 @@ macro_rules! impl_tuple {
 
             #[allow(unused_mut, non_snake_case)]
             #[inline]
-            unsafe fn from_stack_multi(mut nvals: c_int, lua: &'lua Lua) -> Result<Self> {
+            unsafe fn from_stack_multi(mut nvals: c_int, lua: &RawLua) -> Result<Self> {
                 $(
                     let $name = if nvals > 0 {
                         nvals -= 1;
                         FromLua::from_stack(-(nvals + 1), lua)
                     } else {
-                        FromLua::from_lua(Nil, lua)
+                        FromLua::from_lua(Nil, lua.lua())
                     }?;
                 )*
                 let $last = FromLuaMulti::from_stack_multi(nvals, lua)?;
@@ -328,13 +410,13 @@ macro_rules! impl_tuple {
 
             #[allow(unused_mut, non_snake_case)]
             #[inline]
-            unsafe fn from_stack_args(mut nargs: c_int, mut i: usize, to: Option<&str>, lua: &'lua Lua) -> Result<Self> {
+            unsafe fn from_stack_args(mut nargs: c_int, mut i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
                 $(
                     let $name = if nargs > 0 {
                         nargs -= 1;
                         FromLua::from_stack_arg(-(nargs + 1), i, to, lua)
                     } else {
-                        FromLua::from_lua_arg(Nil, i, to, lua)
+                        FromLua::from_lua_arg(Nil, i, to, lua.lua())
                     }?;
                     i += 1;
                 )*
@@ -375,3 +457,13 @@ impl_tuple!(A B C D E F G H I J K L M);
 impl_tuple!(A B C D E F G H I J K L M N);
 impl_tuple!(A B C D E F G H I J K L M N O);
 impl_tuple!(A B C D E F G H I J K L M N O P);
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(MultiValue: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(MultiValue: Send, Sync);
+}

src/prelude.rs

@@ -2,19 +2,18 @@
 
 #[doc(no_inline)]
 pub use crate::{
-    AnyUserData as LuaAnyUserData, AnyUserDataExt as LuaAnyUserDataExt, Chunk as LuaChunk,
-    Error as LuaError, ErrorContext as LuaErrorContext, ExternalError as LuaExternalError,
-    ExternalResult as LuaExternalResult, FromLua, FromLuaMulti, Function as LuaFunction,
-    FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode, Integer as LuaInteger, IntoLua,
-    IntoLuaMulti, LightUserData as LuaLightUserData, Lua, LuaOptions, MetaMethod as LuaMetaMethod,
-    MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber, RegistryKey as LuaRegistryKey,
-    Result as LuaResult, StdLib as LuaStdLib, String as LuaString, Table as LuaTable,
-    TableExt as LuaTableExt, TablePairs as LuaTablePairs, TableSequence as LuaTableSequence,
-    Thread as LuaThread, ThreadStatus as LuaThreadStatus, UserData as LuaUserData,
-    UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
+    AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Either as LuaEither, Error as LuaError,
+    ErrorContext as LuaErrorContext, ExternalError as LuaExternalError, ExternalResult as LuaExternalResult,
+    FromLua, FromLuaMulti, Function as LuaFunction, FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode,
+    Integer as LuaInteger, IntoLua, IntoLuaMulti, LightUserData as LuaLightUserData, Lua, LuaNativeFn,
+    LuaNativeFnMut, LuaOptions, MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil,
+    Number as LuaNumber, ObjectLike as LuaObjectLike, RegistryKey as LuaRegistryKey, Result as LuaResult,
+    StdLib as LuaStdLib, String as LuaString, Table as LuaTable, TablePairs as LuaTablePairs,
+    TableSequence as LuaTableSequence, Thread as LuaThread, ThreadStatus as LuaThreadStatus,
+    UserData as LuaUserData, UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
     UserDataMethods as LuaUserDataMethods, UserDataRef as LuaUserDataRef,
-    UserDataRefMut as LuaUserDataRefMut, UserDataRegistry as LuaUserDataRegistry,
-    Value as LuaValue,
+    UserDataRefMut as LuaUserDataRefMut, UserDataRegistry as LuaUserDataRegistry, Value as LuaValue,
+    Variadic as LuaVariadic, VmState as LuaVmState, WeakLua,
 };
 
 #[cfg(not(feature = "luau"))]
@@ -23,22 +22,14 @@ pub use crate::HookTriggers as LuaHookTriggers;
 
 #[cfg(feature = "luau")]
 #[doc(no_inline)]
-pub use crate::{CoverageInfo as LuaCoverageInfo, Vector as LuaVector, VmState as LuaVmState};
+pub use crate::{CoverageInfo as LuaCoverageInfo, Vector as LuaVector};
 
 #[cfg(feature = "async")]
 #[doc(no_inline)]
-pub use crate::AsyncThread as LuaAsyncThread;
+pub use crate::{AsyncThread as LuaAsyncThread, LuaNativeAsyncFn};
 
 #[cfg(feature = "serialize")]
 #[doc(no_inline)]
 pub use crate::{
-    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt,
-    SerializeOptions as LuaSerializeOptions,
-};
-
-#[cfg(feature = "unstable")]
-#[doc(no_inline)]
-pub use crate::{
-    OwnedAnyUserData as LuaOwnedAnyUserData, OwnedFunction as LuaOwnedFunction,
-    OwnedString as LuaOwnedString, OwnedTable as LuaOwnedTable, OwnedThread as LuaOwnedThread,
+    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt, SerializeOptions as LuaSerializeOptions,
 };

src/serde/de.rs

@@ -1,3 +1,5 @@
+//! Deserialize Lua values to a Rust data structure.
+
 use std::cell::RefCell;
 use std::os::raw::c_void;
 use std::rc::Rc;
@@ -14,8 +16,8 @@ use crate::value::Value;
 
 /// A struct for deserializing Lua values into Rust values.
 #[derive(Debug)]
-pub struct Deserializer<'lua> {
-    value: Value<'lua>,
+pub struct Deserializer {
+    value: Value,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
@@ -47,11 +49,16 @@ pub struct Options {
     ///
     /// Default: **false**
     pub sort_keys: bool,
+
+    /// If true, empty Lua tables will be encoded as array, instead of map.
+    ///
+    /// Default: **false**
+    pub encode_empty_tables_as_array: bool,
 }
 
 impl Default for Options {
     fn default() -> Self {
-        Self::new()
+        const { Self::new() }
     }
 }
 
@@ -62,6 +69,7 @@ impl Options {
             deny_unsupported_types: true,
             deny_recursive_tables: true,
             sort_keys: false,
+            encode_empty_tables_as_array: false,
         }
     }
 
@@ -91,16 +99,25 @@ impl Options {
         self.sort_keys = enabled;
         self
     }
+
+    /// Sets [`encode_empty_tables_as_array`] option.
+    ///
+    /// [`encode_empty_tables_as_array`]: #structfield.encode_empty_tables_as_array
+    #[must_use]
+    pub const fn encode_empty_tables_as_array(mut self, enabled: bool) -> Self {
+        self.encode_empty_tables_as_array = enabled;
+        self
+    }
 }
 
-impl<'lua> Deserializer<'lua> {
-    /// Creates a new Lua Deserializer for the `Value`.
-    pub fn new(value: Value<'lua>) -> Self {
+impl Deserializer {
+    /// Creates a new Lua Deserializer for the [`Value`].
+    pub fn new(value: Value) -> Self {
         Self::new_with_options(value, Options::default())
     }
 
-    /// Creates a new Lua Deserializer for the `Value` with custom options.
-    pub fn new_with_options(value: Value<'lua>, options: Options) -> Self {
+    /// Creates a new Lua Deserializer for the [`Value`] with custom options.
+    pub fn new_with_options(value: Value, options: Options) -> Self {
         Deserializer {
             value,
             options,
@@ -108,11 +125,7 @@ impl<'lua> Deserializer<'lua> {
         }
     }
 
-    fn from_parts(
-        value: Value<'lua>,
-        options: Options,
-        visited: Rc<RefCell<FxHashSet<*const c_void>>>,
-    ) -> Self {
+    fn from_parts(value: Value, options: Options, visited: Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
         Deserializer {
             value,
             options,
@@ -121,7 +134,7 @@ impl<'lua> Deserializer<'lua> {
     }
 }
 
-impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
+impl<'de> serde::Deserializer<'de> for Deserializer {
     type Error = Error;
 
     #[inline]
@@ -139,28 +152,26 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             #[cfg(feature = "luau")]
             Value::Vector(_) => self.deserialize_seq(visitor),
             Value::String(s) => match s.to_str() {
-                Ok(s) => visitor.visit_str(s),
-                Err(_) => visitor.visit_bytes(s.as_bytes()),
+                Ok(s) => visitor.visit_str(&s),
+                Err(_) => visitor.visit_bytes(&s.as_bytes()),
             },
             Value::Table(ref t) if t.raw_len() > 0 || t.is_array() => self.deserialize_seq(visitor),
+            Value::Table(ref t) if self.options.encode_empty_tables_as_array && t.is_empty() => {
+                self.deserialize_seq(visitor)
+            }
             Value::Table(_) => self.deserialize_map(visitor),
             Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_none(),
             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::Buffer(buf) => visitor.visit_bytes(unsafe { buf.as_slice() }),
             Value::Function(_)
             | Value::Thread(_)
             | Value::UserData(_)
             | Value::LightUserData(_)
-            | Value::Error(_) => {
+            | Value::Error(_)
+            | Value::Other(_) => {
                 if self.options.deny_unsupported_types {
                     let msg = format!("unsupported value type `{}`", self.value.type_name());
                     Err(de::Error::custom(msg))
@@ -266,10 +277,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                 if deserializer.seq.count() == 0 {
                     Ok(seq)
                 } else {
-                    Err(de::Error::invalid_length(
-                        len,
-                        &"fewer elements in the table",
-                    ))
+                    Err(de::Error::invalid_length(len, &"fewer elements in the table"))
                 }
             }
             Value::UserData(ud) if ud.is_serializable() => {
@@ -291,12 +299,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     }
 
     #[inline]
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value>
+    fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
@@ -313,7 +316,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                 let _guard = RecursionGuard::new(&t, &self.visited);
 
                 let mut deserializer = MapDeserializer {
-                    pairs: MapPairs::new(t, self.options.sort_keys)?,
+                    pairs: MapPairs::new(&t, self.options.sort_keys)?,
                     value: None,
                     options: self.options,
                     visited: self.visited,
@@ -394,13 +397,13 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     }
 }
 
-struct SeqDeserializer<'lua> {
-    seq: TableSequence<'lua, Value<'lua>>,
+struct SeqDeserializer<'a> {
+    seq: TableSequence<'a, Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
-impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
+impl<'de> de::SeqAccess<'de> for SeqDeserializer<'_> {
     type Error = Error;
 
     fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
@@ -435,7 +438,7 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
 
 #[cfg(feature = "luau")]
 struct VecDeserializer {
-    vec: crate::types::Vector,
+    vec: crate::Vector,
     next: usize,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
@@ -453,8 +456,7 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
             Some(&n) => {
                 self.next += 1;
                 let visited = Rc::clone(&self.visited);
-                let deserializer =
-                    Deserializer::from_parts(Value::Number(n as _), self.options, visited);
+                let deserializer = Deserializer::from_parts(Value::Number(n as _), self.options, visited);
                 seed.deserialize(deserializer).map(Some)
             }
             None => Ok(None),
@@ -462,20 +464,20 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
     }
 
     fn size_hint(&self) -> Option<usize> {
-        Some(crate::types::Vector::SIZE)
+        Some(crate::Vector::SIZE)
     }
 }
 
-pub(crate) enum MapPairs<'lua> {
-    Iter(TablePairs<'lua, Value<'lua>, Value<'lua>>),
-    Vec(Vec<(Value<'lua>, Value<'lua>)>),
+pub(crate) enum MapPairs<'a> {
+    Iter(TablePairs<'a, Value, Value>),
+    Vec(Vec<(Value, Value)>),
 }
 
-impl<'lua> MapPairs<'lua> {
-    pub(crate) fn new(t: Table<'lua>, sort_keys: bool) -> Result<Self> {
+impl<'a> MapPairs<'a> {
+    pub(crate) fn new(t: &'a Table, sort_keys: bool) -> Result<Self> {
         if sort_keys {
             let mut pairs = t.pairs::<Value, Value>().collect::<Result<Vec<_>>>()?;
-            pairs.sort_by(|(a, _), (b, _)| b.cmp(a)); // reverse order as we pop values from the end
+            pairs.sort_by(|(a, _), (b, _)| b.sort_cmp(a)); // reverse order as we pop values from the end
             Ok(MapPairs::Vec(pairs))
         } else {
             Ok(MapPairs::Iter(t.pairs::<Value, Value>()))
@@ -497,8 +499,8 @@ impl<'lua> MapPairs<'lua> {
     }
 }
 
-impl<'lua> Iterator for MapPairs<'lua> {
-    type Item = Result<(Value<'lua>, Value<'lua>)>;
+impl Iterator for MapPairs<'_> {
+    type Item = Result<(Value, Value)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self {
@@ -508,21 +510,16 @@ impl<'lua> Iterator for MapPairs<'lua> {
     }
 }
 
-struct MapDeserializer<'lua> {
-    pairs: MapPairs<'lua>,
-    value: Option<Value<'lua>>,
+struct MapDeserializer<'a> {
+    pairs: MapPairs<'a>,
+    value: Option<Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
     processed: usize,
 }
 
-impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
-    type Error = Error;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
+impl MapDeserializer<'_> {
+    fn next_key_deserializer(&mut self) -> Result<Option<Deserializer>> {
         loop {
             match self.pairs.next() {
                 Some(item) => {
@@ -538,23 +535,45 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
                     self.value = Some(value);
                     let visited = Rc::clone(&self.visited);
                     let key_de = Deserializer::from_parts(key, self.options, visited);
-                    return seed.deserialize(key_de).map(Some);
+                    return Ok(Some(key_de));
                 }
                 None => return Ok(None),
             }
         }
     }
 
+    fn next_value_deserializer(&mut self) -> Result<Deserializer> {
+        match self.value.take() {
+            Some(value) => {
+                let visited = Rc::clone(&self.visited);
+                Ok(Deserializer::from_parts(value, self.options, visited))
+            }
+            None => Err(de::Error::custom("value is missing")),
+        }
+    }
+}
+
+impl<'de> de::MapAccess<'de> for MapDeserializer<'_> {
+    type Error = Error;
+
+    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        match self.next_key_deserializer() {
+            Ok(Some(key_de)) => seed.deserialize(key_de).map(Some),
+            Ok(None) => Ok(None),
+            Err(error) => Err(error),
+        }
+    }
+
     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value>
     where
         T: de::DeserializeSeed<'de>,
     {
-        match self.value.take() {
-            Some(value) => {
-                let visited = Rc::clone(&self.visited);
-                seed.deserialize(Deserializer::from_parts(value, self.options, visited))
-            }
-            None => Err(de::Error::custom("value is missing")),
+        match self.next_value_deserializer() {
+            Ok(value_de) => seed.deserialize(value_de),
+            Err(error) => Err(error),
         }
     }
 
@@ -566,16 +585,16 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
     }
 }
 
-struct EnumDeserializer<'lua> {
+struct EnumDeserializer {
     variant: StdString,
-    value: Option<Value<'lua>>,
+    value: Option<Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
-impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
+impl<'de> de::EnumAccess<'de> for EnumDeserializer {
     type Error = Error;
-    type Variant = VariantDeserializer<'lua>;
+    type Variant = VariantDeserializer;
 
     fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant)>
     where
@@ -591,13 +610,13 @@ impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
     }
 }
 
-struct VariantDeserializer<'lua> {
-    value: Option<Value<'lua>>,
+struct VariantDeserializer {
+    value: Option<Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
-impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
+impl<'de> de::VariantAccess<'de> for VariantDeserializer {
     type Error = Error;
 
     fn unit_variant(self) -> Result<()> {
@@ -615,9 +634,7 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
         T: de::DeserializeSeed<'de>,
     {
         match self.value {
-            Some(value) => {
-                seed.deserialize(Deserializer::from_parts(value, self.options, self.visited))
-            }
+            Some(value) => seed.deserialize(Deserializer::from_parts(value, self.options, self.visited)),
             None => Err(de::Error::invalid_type(
                 de::Unexpected::UnitVariant,
                 &"newtype variant",
@@ -716,6 +733,11 @@ fn serde_userdata<V>(
     ud: AnyUserData,
     f: impl FnOnce(serde_value::Value) -> std::result::Result<V, serde_value::DeserializerError>,
 ) -> Result<V> {
-    let value = serde_value::to_value(ud).map_err(|err| Error::SerializeError(err.to_string()))?;
-    f(value).map_err(|err| Error::DeserializeError(err.to_string()))
+    match serde_value::to_value(ud) {
+        Ok(value) => match f(value) {
+            Ok(r) => Ok(r),
+            Err(error) => Err(Error::DeserializeError(error.to_string())),
+        },
+        Err(error) => Err(Error::SerializeError(error.to_string())),
+    }
 }

src/serde/mod.rs

@@ -2,11 +2,12 @@
 
 use std::os::raw::c_void;
 
-use serde::{de::DeserializeOwned, ser::Serialize};
+use serde::de::DeserializeOwned;
+use serde::ser::Serialize;
 
 use crate::error::Result;
-use crate::lua::Lua;
 use crate::private::Sealed;
+use crate::state::Lua;
 use crate::table::Table;
 use crate::util::check_stack;
 use crate::value::Value;
@@ -99,14 +100,12 @@ pub trait LuaSerdeExt: Sealed {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value<'lua, T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
+    fn to_value<T: Serialize + ?Sized>(&self, t: &T) -> Result<Value>;
 
     /// Converts `T` into a [`Value`] instance with options.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: crate::Value
-    ///
     /// # Example
     ///
     /// ```
@@ -124,7 +123,7 @@ pub trait LuaSerdeExt: Sealed {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value_with<'lua, T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<T>(&self, t: &T, options: ser::Options) -> Result<Value>
     where
         T: Serialize + ?Sized;
 
@@ -132,8 +131,6 @@ pub trait LuaSerdeExt: Sealed {
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: crate::Value
-    ///
     /// # Example
     ///
     /// ```
@@ -163,8 +160,6 @@ pub trait LuaSerdeExt: Sealed {
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: crate::Value
-    ///
     /// # Example
     ///
     /// ```
@@ -189,8 +184,7 @@ pub trait LuaSerdeExt: Sealed {
     /// }
     /// ```
     #[allow(clippy::wrong_self_convention)]
-    fn from_value_with<T: DeserializeOwned>(&self, value: Value, options: de::Options)
-        -> Result<T>;
+    fn from_value_with<T: DeserializeOwned>(&self, value: Value, options: de::Options) -> Result<T>;
 }
 
 impl LuaSerdeExt for Lua {
@@ -199,20 +193,21 @@ impl LuaSerdeExt for Lua {
     }
 
     fn array_metatable(&self) -> Table {
+        let lua = self.lock();
         unsafe {
-            push_array_metatable(self.ref_thread());
-            Table(self.pop_ref_thread())
+            push_array_metatable(lua.ref_thread());
+            Table(lua.pop_ref_thread())
         }
     }
 
-    fn to_value<'lua, T>(&'lua self, t: &T) -> Result<Value<'lua>>
+    fn to_value<T>(&self, t: &T) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
         t.serialize(ser::Serializer::new(self))
     }
 
-    fn to_value_with<'lua, T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<T>(&self, t: &T, options: ser::Options) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {

src/serde/ser.rs

@@ -1,15 +1,18 @@
+//! Serialize a Rust data structure into Lua value.
+
 use serde::{ser, Serialize};
 
 use super::LuaSerdeExt;
 use crate::error::{Error, Result};
-use crate::lua::Lua;
+use crate::state::Lua;
 use crate::table::Table;
-use crate::value::{IntoLua, Value};
+use crate::traits::IntoLua;
+use crate::value::Value;
 
 /// A struct for serializing Rust values into Lua values.
 #[derive(Debug)]
-pub struct Serializer<'lua> {
-    lua: &'lua Lua,
+pub struct Serializer<'a> {
+    lua: &'a Lua,
     options: Options,
 }
 
@@ -52,7 +55,7 @@ pub struct Options {
 
 impl Default for Options {
     fn default() -> Self {
-        Self::new()
+        const { Self::new() }
     }
 }
 
@@ -96,8 +99,8 @@ impl Options {
 
     /// 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 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.
     ///
@@ -109,14 +112,14 @@ impl Options {
     }
 }
 
-impl<'lua> Serializer<'lua> {
+impl<'a> Serializer<'a> {
     /// Creates a new Lua Serializer with default options.
-    pub fn new(lua: &'lua Lua) -> Self {
+    pub fn new(lua: &'a Lua) -> Self {
         Self::new_with_options(lua, Options::default())
     }
 
     /// Creates a new Lua Serializer with custom options.
-    pub fn new_with_options(lua: &'lua Lua, options: Options) -> Self {
+    pub fn new_with_options(lua: &'a Lua, options: Options) -> Self {
         Serializer { lua, options }
     }
 }
@@ -124,28 +127,28 @@ impl<'lua> Serializer<'lua> {
 macro_rules! lua_serialize_number {
     ($name:ident, $t:ty) => {
         #[inline]
-        fn $name(self, value: $t) -> Result<Value<'lua>> {
+        fn $name(self, value: $t) -> Result<Value> {
             value.into_lua(self.lua)
         }
     };
 }
 
-impl<'lua> ser::Serializer for Serializer<'lua> {
-    type Ok = Value<'lua>;
+impl<'a> ser::Serializer for Serializer<'a> {
+    type Ok = Value;
     type Error = Error;
 
     // Associated types for keeping track of additional state while serializing
     // compound data structures like sequences and maps.
-    type SerializeSeq = SerializeSeq<'lua>;
-    type SerializeTuple = SerializeSeq<'lua>;
-    type SerializeTupleStruct = SerializeSeq<'lua>;
-    type SerializeTupleVariant = SerializeTupleVariant<'lua>;
-    type SerializeMap = SerializeMap<'lua>;
-    type SerializeStruct = SerializeStruct<'lua>;
-    type SerializeStructVariant = SerializeStructVariant<'lua>;
+    type SerializeSeq = SerializeSeq<'a>;
+    type SerializeTuple = SerializeSeq<'a>;
+    type SerializeTupleStruct = SerializeSeq<'a>;
+    type SerializeTupleVariant = SerializeTupleVariant<'a>;
+    type SerializeMap = SerializeMap<'a>;
+    type SerializeStruct = SerializeStruct<'a>;
+    type SerializeStructVariant = SerializeStructVariant<'a>;
 
     #[inline]
-    fn serialize_bool(self, value: bool) -> Result<Value<'lua>> {
+    fn serialize_bool(self, value: bool) -> Result<Value> {
         Ok(Value::Boolean(value))
     }
 
@@ -164,22 +167,22 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     lua_serialize_number!(serialize_f64, f64);
 
     #[inline]
-    fn serialize_char(self, value: char) -> Result<Value<'lua>> {
+    fn serialize_char(self, value: char) -> Result<Value> {
         self.serialize_str(&value.to_string())
     }
 
     #[inline]
-    fn serialize_str(self, value: &str) -> Result<Value<'lua>> {
+    fn serialize_str(self, value: &str) -> Result<Value> {
         self.lua.create_string(value).map(Value::String)
     }
 
     #[inline]
-    fn serialize_bytes(self, value: &[u8]) -> Result<Value<'lua>> {
+    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
         self.lua.create_string(value).map(Value::String)
     }
 
     #[inline]
-    fn serialize_none(self) -> Result<Value<'lua>> {
+    fn serialize_none(self) -> Result<Value> {
         if self.options.serialize_none_to_null {
             Ok(self.lua.null())
         } else {
@@ -188,7 +191,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_some<T>(self, value: &T) -> Result<Value<'lua>>
+    fn serialize_some<T>(self, value: &T) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
@@ -196,7 +199,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_unit(self) -> Result<Value<'lua>> {
+    fn serialize_unit(self) -> Result<Value> {
         if self.options.serialize_unit_to_null {
             Ok(self.lua.null())
         } else {
@@ -205,7 +208,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value<'lua>> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
         if self.options.serialize_unit_to_null {
             Ok(self.lua.null())
         } else {
@@ -219,12 +222,12 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         _name: &'static str,
         _variant_index: u32,
         variant: &'static str,
-    ) -> Result<Value<'lua>> {
+    ) -> Result<Value> {
         self.serialize_str(variant)
     }
 
     #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value<'lua>>
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
@@ -238,7 +241,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         _variant_index: u32,
         variant: &'static str,
         value: &T,
-    ) -> Result<Value<'lua>>
+    ) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
@@ -255,7 +258,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         if self.options.set_array_metatable {
             table.set_metatable(Some(self.lua.array_metatable()));
         }
-        Ok(SerializeSeq::new(table, self.options))
+        Ok(SerializeSeq::new(self.lua, table, self.options))
     }
 
     #[inline]
@@ -264,13 +267,9 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_tuple_struct(
-        self,
-        name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
+    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
         #[cfg(feature = "luau")]
-        if name == "Vector" && len == crate::types::Vector::SIZE {
+        if name == "Vector" && len == crate::Vector::SIZE {
             return Ok(SerializeSeq::new_vector(self.lua, self.options));
         }
         _ = name;
@@ -286,6 +285,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         _len: usize,
     ) -> Result<Self::SerializeTupleVariant> {
         Ok(SerializeTupleVariant {
+            lua: self.lua,
             variant,
             table: self.lua.create_table()?,
             options: self.options,
@@ -295,6 +295,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     #[inline]
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
         Ok(SerializeMap {
+            lua: self.lua,
             key: None,
             table: self.lua.create_table_with_capacity(0, len.unwrap_or(0))?,
             options: self.options,
@@ -330,6 +331,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         len: usize,
     ) -> Result<Self::SerializeStructVariant> {
         Ok(SerializeStructVariant {
+            lua: self.lua,
             variant,
             table: self.lua.create_table_with_capacity(0, len)?,
             options: self.options,
@@ -338,19 +340,19 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 }
 
 #[doc(hidden)]
-pub struct SerializeSeq<'lua> {
-    lua: &'lua Lua,
+pub struct SerializeSeq<'a> {
+    lua: &'a Lua,
     #[cfg(feature = "luau")]
-    vector: Option<crate::types::Vector>,
-    table: Option<Table<'lua>>,
+    vector: Option<crate::Vector>,
+    table: Option<Table>,
     next: usize,
     options: Options,
 }
 
-impl<'lua> SerializeSeq<'lua> {
-    const fn new(table: Table<'lua>, options: Options) -> Self {
+impl<'a> SerializeSeq<'a> {
+    fn new(lua: &'a Lua, table: Table, options: Options) -> Self {
         Self {
-            lua: table.0.lua,
+            lua,
             #[cfg(feature = "luau")]
             vector: None,
             table: Some(table),
@@ -360,10 +362,10 @@ impl<'lua> SerializeSeq<'lua> {
     }
 
     #[cfg(feature = "luau")]
-    const fn new_vector(lua: &'lua Lua, options: Options) -> Self {
+    const fn new_vector(lua: &'a Lua, options: Options) -> Self {
         Self {
             lua,
-            vector: Some(crate::types::Vector::zero()),
+            vector: Some(crate::Vector::zero()),
             table: None,
             next: 0,
             options,
@@ -371,8 +373,8 @@ impl<'lua> SerializeSeq<'lua> {
     }
 }
 
-impl<'lua> ser::SerializeSeq for SerializeSeq<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeSeq for SerializeSeq<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
@@ -386,13 +388,13 @@ impl<'lua> ser::SerializeSeq for SerializeSeq<'lua> {
         Ok(())
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
         Ok(Value::Table(self.table.unwrap()))
     }
 }
 
-impl<'lua> ser::SerializeTuple for SerializeSeq<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTuple for SerializeSeq<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
@@ -402,13 +404,13 @@ impl<'lua> ser::SerializeTuple for SerializeSeq<'lua> {
         ser::SerializeSeq::serialize_element(self, value)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
         ser::SerializeSeq::end(self)
     }
 }
 
-impl<'lua> ser::SerializeTupleStruct for SerializeSeq<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTupleStruct for SerializeSeq<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
@@ -426,7 +428,7 @@ impl<'lua> ser::SerializeTupleStruct for SerializeSeq<'lua> {
         ser::SerializeSeq::serialize_element(self, value)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
         #[cfg(feature = "luau")]
         if let Some(vector) = self.vector {
             return Ok(Value::Vector(vector));
@@ -436,49 +438,48 @@ impl<'lua> ser::SerializeTupleStruct for SerializeSeq<'lua> {
 }
 
 #[doc(hidden)]
-pub struct SerializeTupleVariant<'lua> {
+pub struct SerializeTupleVariant<'a> {
+    lua: &'a Lua,
     variant: &'static str,
-    table: Table<'lua>,
+    table: Table,
     options: Options,
 }
 
-impl<'lua> ser::SerializeTupleVariant for SerializeTupleVariant<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTupleVariant for SerializeTupleVariant<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        self.table.raw_push(lua.to_value_with(value, self.options)?)
+        self.table.raw_push(self.lua.to_value_with(value, self.options)?)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
-        let lua = self.table.0.lua;
-        let table = lua.create_table()?;
+    fn end(self) -> Result<Value> {
+        let table = self.lua.create_table()?;
         table.raw_set(self.variant, self.table)?;
         Ok(Value::Table(table))
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeMap<'lua> {
-    table: Table<'lua>,
-    key: Option<Value<'lua>>,
+pub struct SerializeMap<'a> {
+    lua: &'a Lua,
+    table: Table,
+    key: Option<Value>,
     options: Options,
 }
 
-impl<'lua> ser::SerializeMap for SerializeMap<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeMap for SerializeMap<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_key<T>(&mut self, key: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        self.key = Some(lua.to_value_with(key, self.options)?);
+        self.key = Some(self.lua.to_value_with(key, self.options)?);
         Ok(())
     }
 
@@ -486,29 +487,25 @@ impl<'lua> ser::SerializeMap for SerializeMap<'lua> {
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        let key = mlua_expect!(
-            self.key.take(),
-            "serialize_value called before serialize_key"
-        );
-        let value = lua.to_value_with(value, self.options)?;
+        let key = mlua_expect!(self.key.take(), "serialize_value called before serialize_key");
+        let value = self.lua.to_value_with(value, self.options)?;
         self.table.raw_set(key, value)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
         Ok(Value::Table(self.table))
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeStruct<'lua> {
-    lua: &'lua Lua,
-    inner: Option<Value<'lua>>,
+pub struct SerializeStruct<'a> {
+    lua: &'a Lua,
+    inner: Option<Value>,
     options: Options,
 }
 
-impl<'lua> ser::SerializeStruct for SerializeStruct<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeStruct for SerializeStruct<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
@@ -529,7 +526,7 @@ impl<'lua> ser::SerializeStruct for SerializeStruct<'lua> {
         Ok(())
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
         match self.inner {
             Some(table @ Value::Table(_)) => Ok(table),
             Some(value) if self.options.detect_serde_json_arbitrary_precision => {
@@ -551,29 +548,28 @@ impl<'lua> ser::SerializeStruct for SerializeStruct<'lua> {
 }
 
 #[doc(hidden)]
-pub struct SerializeStructVariant<'lua> {
+pub struct SerializeStructVariant<'a> {
+    lua: &'a Lua,
     variant: &'static str,
-    table: Table<'lua>,
+    table: Table,
     options: Options,
 }
 
-impl<'lua> ser::SerializeStructVariant for SerializeStructVariant<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeStructVariant for SerializeStructVariant<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
         self.table
-            .raw_set(key, lua.to_value_with(value, self.options)?)?;
+            .raw_set(key, self.lua.to_value_with(value, self.options)?)?;
         Ok(())
     }
 
-    fn end(self) -> Result<Value<'lua>> {
-        let lua = self.table.0.lua;
-        let table = lua.create_table_with_capacity(0, 1)?;
+    fn end(self) -> Result<Value> {
+        let table = self.lua.create_table_with_capacity(0, 1)?;
         table.raw_set(self.variant, self.table)?;
         Ok(Value::Table(table))
     }

src/state/extra.rs

@@ -0,0 +1,255 @@
+use std::any::TypeId;
+use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
+use std::os::raw::{c_int, c_void};
+use std::ptr;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+use rustc_hash::FxHashMap;
+
+use crate::error::Result;
+use crate::state::RawLua;
+use crate::stdlib::StdLib;
+use crate::types::{AppData, ReentrantMutex, XRc};
+use crate::userdata::RawUserDataRegistry;
+use crate::util::{get_internal_metatable, push_internal_userdata, TypeKey, WrappedFailure};
+
+#[cfg(any(feature = "luau", doc))]
+use crate::chunk::Compiler;
+
+#[cfg(feature = "async")]
+use {futures_util::task::noop_waker_ref, std::ptr::NonNull, std::task::Waker};
+
+use super::{Lua, WeakLua};
+
+// Unique key to store `ExtraData` in the registry
+static EXTRA_REGISTRY_KEY: u8 = 0;
+
+const WRAPPED_FAILURE_POOL_DEFAULT_CAPACITY: usize = 64;
+const REF_STACK_RESERVE: c_int = 2;
+
+/// Data associated with the Lua state.
+pub(crate) struct ExtraData {
+    pub(super) lua: MaybeUninit<Lua>,
+    pub(super) weak: MaybeUninit<WeakLua>,
+    pub(super) owned: bool,
+
+    pub(super) pending_userdata_reg: FxHashMap<TypeId, RawUserDataRegistry>,
+    pub(super) registered_userdata_t: FxHashMap<TypeId, c_int>,
+    pub(super) registered_userdata_mt: FxHashMap<*const c_void, Option<TypeId>>,
+    pub(super) last_checked_userdata_mt: (*const c_void, Option<TypeId>),
+
+    // When Lua instance dropped, setting `None` would prevent collecting `RegistryKey`s
+    pub(super) registry_unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
+
+    // Container to store arbitrary data (extensions)
+    pub(super) app_data: AppData,
+
+    pub(super) safe: bool,
+    pub(super) libs: StdLib,
+    // Used in module mode
+    pub(super) skip_memory_check: bool,
+
+    // Auxiliary thread to store references
+    pub(super) ref_thread: *mut ffi::lua_State,
+    pub(super) ref_stack_size: c_int,
+    pub(super) ref_stack_top: c_int,
+    pub(super) ref_free: Vec<c_int>,
+
+    // Pool of `WrappedFailure` enums in the ref thread (as userdata)
+    pub(super) wrapped_failure_pool: Vec<c_int>,
+    pub(super) wrapped_failure_top: usize,
+    // Pool of `Thread`s (coroutines) for async execution
+    #[cfg(feature = "async")]
+    pub(super) thread_pool: Vec<c_int>,
+
+    // Address of `WrappedFailure` metatable
+    pub(super) wrapped_failure_mt_ptr: *const c_void,
+
+    // Waker for polling futures
+    #[cfg(feature = "async")]
+    pub(super) waker: NonNull<Waker>,
+
+    #[cfg(not(feature = "luau"))]
+    pub(super) hook_callback: Option<crate::types::HookCallback>,
+    #[cfg(not(feature = "luau"))]
+    pub(super) hook_thread: *mut ffi::lua_State,
+    #[cfg(feature = "lua54")]
+    pub(super) warn_callback: Option<crate::types::WarnCallback>,
+    #[cfg(feature = "luau")]
+    pub(super) interrupt_callback: Option<crate::types::InterruptCallback>,
+
+    #[cfg(feature = "luau")]
+    pub(crate) running_userdata_gc: bool,
+    #[cfg(feature = "luau")]
+    pub(super) sandboxed: bool,
+    #[cfg(feature = "luau")]
+    pub(super) compiler: Option<Compiler>,
+    #[cfg(feature = "luau-jit")]
+    pub(super) enable_jit: bool,
+}
+
+impl Drop for ExtraData {
+    fn drop(&mut self) {
+        unsafe {
+            if !self.owned {
+                self.lua.assume_init_drop();
+            }
+
+            self.weak.assume_init_drop();
+        }
+        *self.registry_unref_list.lock() = None;
+    }
+}
+
+static EXTRA_TYPE_KEY: u8 = 0;
+
+impl TypeKey for XRc<UnsafeCell<ExtraData>> {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &EXTRA_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+impl ExtraData {
+    // Index of `error_traceback` function in auxiliary thread stack
+    #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+    pub(super) const ERROR_TRACEBACK_IDX: c_int = 1;
+
+    pub(super) unsafe fn init(state: *mut ffi::lua_State, owned: bool) -> XRc<UnsafeCell<Self>> {
+        // Create ref stack thread and place it in the registry to prevent it
+        // from being garbage collected.
+        let ref_thread = mlua_expect!(
+            protect_lua!(state, 0, 0, |state| {
+                let thread = ffi::lua_newthread(state);
+                ffi::luaL_ref(state, ffi::LUA_REGISTRYINDEX);
+                thread
+            }),
+            "Error while creating ref thread",
+        );
+
+        let wrapped_failure_mt_ptr = {
+            get_internal_metatable::<WrappedFailure>(state);
+            let ptr = ffi::lua_topointer(state, -1);
+            ffi::lua_pop(state, 1);
+            ptr
+        };
+
+        // Store `error_traceback` function on the ref stack
+        #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+        {
+            ffi::lua_pushcfunction(ref_thread, crate::util::error_traceback);
+            assert_eq!(ffi::lua_gettop(ref_thread), Self::ERROR_TRACEBACK_IDX);
+        }
+
+        #[allow(clippy::arc_with_non_send_sync)]
+        let extra = XRc::new(UnsafeCell::new(ExtraData {
+            lua: MaybeUninit::uninit(),
+            weak: MaybeUninit::uninit(),
+            owned,
+            pending_userdata_reg: FxHashMap::default(),
+            registered_userdata_t: FxHashMap::default(),
+            registered_userdata_mt: FxHashMap::default(),
+            last_checked_userdata_mt: (ptr::null(), None),
+            registry_unref_list: Arc::new(Mutex::new(Some(Vec::new()))),
+            app_data: AppData::default(),
+            safe: false,
+            libs: StdLib::NONE,
+            skip_memory_check: false,
+            ref_thread,
+            // 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_DEFAULT_CAPACITY),
+            wrapped_failure_top: 0,
+            #[cfg(feature = "async")]
+            thread_pool: Vec::new(),
+            wrapped_failure_mt_ptr,
+            #[cfg(feature = "async")]
+            waker: NonNull::from(noop_waker_ref()),
+            #[cfg(not(feature = "luau"))]
+            hook_callback: None,
+            #[cfg(not(feature = "luau"))]
+            hook_thread: ptr::null_mut(),
+            #[cfg(feature = "lua54")]
+            warn_callback: None,
+            #[cfg(feature = "luau")]
+            interrupt_callback: None,
+            #[cfg(feature = "luau")]
+            sandboxed: false,
+            #[cfg(feature = "luau")]
+            compiler: None,
+            #[cfg(feature = "luau-jit")]
+            enable_jit: true,
+            #[cfg(feature = "luau")]
+            running_userdata_gc: false,
+        }));
+
+        // Store it in the registry
+        mlua_expect!(Self::store(&extra, state), "Error while storing extra data");
+
+        extra
+    }
+
+    pub(super) unsafe fn set_lua(&mut self, raw: &XRc<ReentrantMutex<RawLua>>) {
+        self.lua.write(Lua {
+            raw: XRc::clone(raw),
+            collect_garbage: false,
+        });
+        if self.owned {
+            XRc::decrement_strong_count(XRc::as_ptr(raw));
+        }
+        self.weak.write(WeakLua(XRc::downgrade(raw)));
+    }
+
+    pub(super) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        #[cfg(feature = "luau")]
+        if cfg!(not(feature = "module")) {
+            // In the main app we can use `lua_callbacks` to access ExtraData
+            return (*ffi::lua_callbacks(state)).userdata as *mut _;
+        }
+
+        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.
+            // This case in used in `Lua::try_from_ptr()`.
+            ffi::lua_pop(state, 1);
+            return ptr::null_mut();
+        }
+        let extra_ptr = ffi::lua_touserdata(state, -1) as *mut Rc<UnsafeCell<ExtraData>>;
+        ffi::lua_pop(state, 1);
+        (*extra_ptr).get()
+    }
+
+    unsafe fn store(extra: &XRc<UnsafeCell<Self>>, state: *mut ffi::lua_State) -> Result<()> {
+        #[cfg(feature = "luau")]
+        if cfg!(not(feature = "module")) {
+            (*ffi::lua_callbacks(state)).userdata = extra.get() as *mut _;
+            return Ok(());
+        }
+
+        push_internal_userdata(state, XRc::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);
+        })
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn lua(&self) -> &Lua {
+        self.lua.assume_init_ref()
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn raw_lua(&self) -> &RawLua {
+        &*self.lua.assume_init_ref().raw.data_ptr()
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn weak(&self) -> &WeakLua {
+        self.weak.assume_init_ref()
+    }
+}

src/state/util.rs

@@ -0,0 +1,172 @@
+use std::os::raw::c_int;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::ptr;
+use std::sync::Arc;
+
+use crate::error::{Error, Result};
+use crate::state::{ExtraData, RawLua};
+use crate::util::{self, get_internal_metatable, WrappedFailure};
+
+struct StateGuard<'a>(&'a RawLua, *mut ffi::lua_State);
+
+impl<'a> StateGuard<'a> {
+    fn new(inner: &'a RawLua, mut state: *mut ffi::lua_State) -> Self {
+        state = inner.state.replace(state);
+        Self(inner, state)
+    }
+}
+
+impl Drop for StateGuard<'_> {
+    fn drop(&mut self) {
+        self.0.state.set(self.1);
+    }
+}
+
+// An optimized version of `callback_error` that does not allocate `WrappedFailure` userdata
+// and instead reuses unused values from previous calls (or allocates new).
+pub(super) unsafe fn callback_error_ext<F, R>(
+    state: *mut ffi::lua_State,
+    mut extra: *mut ExtraData,
+    f: F,
+) -> R
+where
+    F: FnOnce(*mut ExtraData, c_int) -> Result<R>,
+{
+    if extra.is_null() {
+        extra = ExtraData::get(state);
+    }
+
+    let nargs = ffi::lua_gettop(state);
+
+    enum PreallocatedFailure {
+        New(*mut WrappedFailure),
+        Reserved,
+    }
+
+    impl PreallocatedFailure {
+        unsafe fn reserve(state: *mut ffi::lua_State, extra: *mut ExtraData) -> Self {
+            if (*extra).wrapped_failure_top > 0 {
+                (*extra).wrapped_failure_top -= 1;
+                return PreallocatedFailure::Reserved;
+            }
+
+            // We need to check stack for Luau in case when callback is called from interrupt
+            // See https://github.com/luau-lang/luau/issues/446 and mlua #142 and #153
+            #[cfg(feature = "luau")]
+            ffi::lua_rawcheckstack(state, 2);
+            // Place it to the beginning of the stack
+            let ud = WrappedFailure::new_userdata(state);
+            ffi::lua_insert(state, 1);
+            PreallocatedFailure::New(ud)
+        }
+
+        #[cold]
+        unsafe fn r#use(&self, state: *mut ffi::lua_State, extra: *mut ExtraData) -> *mut WrappedFailure {
+            let ref_thread = (*extra).ref_thread;
+            match *self {
+                PreallocatedFailure::New(ud) => {
+                    ffi::lua_settop(state, 1);
+                    ud
+                }
+                PreallocatedFailure::Reserved => {
+                    let index = (*extra).wrapped_failure_pool.pop().unwrap();
+                    ffi::lua_settop(state, 0);
+                    #[cfg(feature = "luau")]
+                    ffi::lua_rawcheckstack(state, 2);
+                    ffi::lua_xpush(ref_thread, state, index);
+                    ffi::lua_pushnil(ref_thread);
+                    ffi::lua_replace(ref_thread, index);
+                    (*extra).ref_free.push(index);
+                    ffi::lua_touserdata(state, -1) as *mut WrappedFailure
+                }
+            }
+        }
+
+        unsafe fn release(self, state: *mut ffi::lua_State, extra: *mut ExtraData) {
+            let ref_thread = (*extra).ref_thread;
+            match self {
+                PreallocatedFailure::New(_) => {
+                    ffi::lua_rotate(state, 1, -1);
+                    ffi::lua_xmove(state, ref_thread, 1);
+                    let index = ref_stack_pop(extra);
+                    (*extra).wrapped_failure_pool.push(index);
+                    (*extra).wrapped_failure_top += 1;
+                }
+                PreallocatedFailure::Reserved => (*extra).wrapped_failure_top += 1,
+            }
+        }
+    }
+
+    // We cannot shadow Rust errors with Lua ones, so we need to reserve pre-allocated memory
+    // to store a wrapped failure (error or panic) *before* we proceed.
+    let prealloc_failure = PreallocatedFailure::reserve(state, extra);
+
+    match catch_unwind(AssertUnwindSafe(|| {
+        let rawlua = (*extra).raw_lua();
+        let _guard = StateGuard::new(rawlua, state);
+        f(extra, nargs)
+    })) {
+        Ok(Ok(r)) => {
+            // Return unused `WrappedFailure` to the pool
+            prealloc_failure.release(state, extra);
+            r
+        }
+        Ok(Err(err)) => {
+            let wrapped_error = prealloc_failure.r#use(state, extra);
+
+            // Build `CallbackError` with traceback
+            let traceback = if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+                ffi::luaL_traceback(state, state, ptr::null(), 0);
+                let traceback = util::to_string(state, -1);
+                ffi::lua_pop(state, 1);
+                traceback
+            } else {
+                "<not enough stack space for traceback>".to_string()
+            };
+            let cause = Arc::new(err);
+            ptr::write(
+                wrapped_error,
+                WrappedFailure::Error(Error::CallbackError { traceback, cause }),
+            );
+            get_internal_metatable::<WrappedFailure>(state);
+            ffi::lua_setmetatable(state, -2);
+
+            ffi::lua_error(state)
+        }
+        Err(p) => {
+            let wrapped_panic = prealloc_failure.r#use(state, extra);
+            ptr::write(wrapped_panic, WrappedFailure::Panic(Some(p)));
+            get_internal_metatable::<WrappedFailure>(state);
+            ffi::lua_setmetatable(state, -2);
+            ffi::lua_error(state)
+        }
+    }
+}
+
+pub(super) unsafe fn ref_stack_pop(extra: *mut ExtraData) -> c_int {
+    let extra = &mut *extra;
+    if let Some(free) = extra.ref_free.pop() {
+        ffi::lua_replace(extra.ref_thread, free);
+        return free;
+    }
+
+    // Try to grow max stack size
+    if extra.ref_stack_top >= extra.ref_stack_size {
+        let mut inc = extra.ref_stack_size; // Try to double stack size
+        while inc > 0 && ffi::lua_checkstack(extra.ref_thread, inc) == 0 {
+            inc /= 2;
+        }
+        if inc == 0 {
+            // Pop item on top of the stack to avoid stack leaking and successfully run destructors
+            // during unwinding.
+            ffi::lua_pop(extra.ref_thread, 1);
+            let top = extra.ref_stack_top;
+            // It is a user error to create enough references to exhaust the Lua max stack size for
+            // the ref thread.
+            panic!("cannot create a Lua reference, out of auxiliary stack space (used {top} slots)");
+        }
+        extra.ref_stack_size += inc;
+    }
+    extra.ref_stack_top += 1;
+    extra.ref_stack_top
+}

src/stdlib.rs

@@ -8,12 +8,7 @@ impl StdLib {
     /// [`coroutine`](https://www.lua.org/manual/5.4/manual.html#6.2) library
     ///
     /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
     pub const COROUTINE: StdLib = StdLib(1);
 
     /// [`table`](https://www.lua.org/manual/5.4/manual.html#6.6) library
@@ -48,17 +43,22 @@ impl StdLib {
     /// [`package`](https://www.lua.org/manual/5.4/manual.html#6.3) library
     pub const PACKAGE: StdLib = StdLib(1 << 8);
 
-    /// [`buffer`](https://luau-lang.org/library#buffer-library) library
+    /// [`buffer`](https://luau.org/library#buffer-library) library
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub const BUFFER: StdLib = StdLib(1 << 9);
 
+    /// [`vector`](https://luau.org/library#vector-library) library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub const VECTOR: StdLib = StdLib(1 << 10);
+
     /// [`jit`](http://luajit.org/ext_jit.html) library
     ///
     /// Requires `feature = "luajit"`
     #[cfg(any(feature = "luajit", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
-    pub const JIT: StdLib = StdLib(1 << 9);
+    pub const JIT: StdLib = StdLib(1 << 11);
 
     /// (**unsafe**) [`ffi`](http://luajit.org/ext_ffi.html) library
     ///

src/string.rs

@@ -1,8 +1,15 @@
 use std::borrow::{Borrow, Cow};
 use std::hash::{Hash, Hasher};
-use std::os::raw::c_void;
+use std::ops::Deref;
+use std::os::raw::{c_int, c_void};
 use std::string::String as StdString;
-use std::{fmt, slice, str};
+use std::{cmp, fmt, slice, str};
+
+use crate::error::{Error, Result};
+use crate::state::Lua;
+use crate::traits::IntoLua;
+use crate::types::{LuaType, ValueRef};
+use crate::value::Value;
 
 #[cfg(feature = "serialize")]
 use {
@@ -10,38 +17,14 @@ use {
     std::result::Result as StdResult,
 };
 
-use crate::error::{Error, Result};
-use crate::types::LuaRef;
-
 /// Handle to an internal Lua string.
 ///
 /// Unlike Rust strings, Lua strings may not be valid UTF-8.
 #[derive(Clone)]
-pub struct String<'lua>(pub(crate) LuaRef<'lua>);
+pub struct String(pub(crate) ValueRef);
 
-/// Owned handle to an internal Lua string.
-///
-/// The owned handle holds a *strong* reference to the current Lua instance.
-/// Be warned, if you place it into a Lua type (eg. [`UserData`] or a Rust callback), it is *very easy*
-/// to accidentally cause reference cycles that would prevent destroying Lua instance.
-///
-/// [`UserData`]: crate::UserData
-#[cfg(feature = "unstable")]
-#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
-#[derive(Clone)]
-pub struct OwnedString(pub(crate) crate::types::LuaOwnedRef);
-
-#[cfg(feature = "unstable")]
-impl OwnedString {
-    /// Get borrowed handle to the underlying Lua string.
-    #[cfg_attr(feature = "send", allow(unused))]
-    pub const fn to_ref(&self) -> String {
-        String(self.0.to_ref())
-    }
-}
-
-impl<'lua> String<'lua> {
-    /// Get a `&str` slice if the Lua string is valid UTF-8.
+impl String {
+    /// Get a [`BorrowedStr`] if the Lua string is valid UTF-8.
     ///
     /// # Examples
     ///
@@ -60,19 +43,19 @@ impl<'lua> String<'lua> {
     /// # }
     /// ```
     #[inline]
-    pub fn to_str(&self) -> Result<&str> {
-        str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
-            from: "string",
-            to: "&str",
-            message: Some(e.to_string()),
-        })
+    pub fn to_str(&self) -> Result<BorrowedStr> {
+        BorrowedStr::try_from(self)
     }
 
-    /// Converts this string to a [`Cow<str>`].
+    /// Converts this string to a [`StdString`].
     ///
     /// Any non-Unicode sequences are replaced with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].
     ///
+    /// This method returns [`StdString`] instead of [`Cow<'_, str>`] because lifetime cannot be
+    /// bound to a weak Lua object.
+    ///
     /// [U+FFFD]: std::char::REPLACEMENT_CHARACTER
+    /// [`Cow<'_, str>`]: std::borrow::Cow
     ///
     /// # Examples
     ///
@@ -87,8 +70,18 @@ impl<'lua> String<'lua> {
     /// # }
     /// ```
     #[inline]
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        StdString::from_utf8_lossy(self.as_bytes())
+    pub fn to_string_lossy(&self) -> StdString {
+        StdString::from_utf8_lossy(&self.as_bytes()).into_owned()
+    }
+
+    /// Returns an object that implements [`Display`] for safely printing a Lua [`String`] that may
+    /// contain non-Unicode data.
+    ///
+    /// This may perform lossy conversion.
+    ///
+    /// [`Display`]: fmt::Display
+    pub fn display(&self) -> impl fmt::Display + '_ {
+        Display(self)
     }
 
     /// Get the bytes that make up this string.
@@ -109,27 +102,37 @@ impl<'lua> String<'lua> {
     /// # }
     /// ```
     #[inline]
-    pub fn as_bytes(&self) -> &[u8] {
-        let nulled = self.as_bytes_with_nul();
-        &nulled[..nulled.len() - 1]
+    pub fn as_bytes(&self) -> BorrowedBytes {
+        BorrowedBytes::from(self)
     }
 
     /// Get the bytes that make up this string, including the trailing nul byte.
-    pub fn as_bytes_with_nul(&self) -> &[u8] {
-        let ref_thread = self.0.lua.ref_thread();
-        unsafe {
+    pub fn as_bytes_with_nul(&self) -> BorrowedBytes {
+        let BorrowedBytes { buf, borrow, _lua } = BorrowedBytes::from(self);
+        // Include the trailing nul byte (it's always present but excluded by default)
+        let buf = unsafe { slice::from_raw_parts((*buf).as_ptr(), (*buf).len() + 1) };
+        BorrowedBytes { buf, borrow, _lua }
+    }
+
+    // Does not return the terminating nul byte
+    unsafe fn to_slice(&self) -> (&[u8], Lua) {
+        let lua = self.0.lua.upgrade();
+        let slice = {
+            let rawlua = lua.lock();
+            let ref_thread = rawlua.ref_thread();
+
             mlua_debug_assert!(
                 ffi::lua_type(ref_thread, self.0.index) == ffi::LUA_TSTRING,
                 "string ref is not string type"
             );
 
-            let mut size = 0;
             // This will not trigger a 'm' error, because the reference is guaranteed to be of
             // string type
+            let mut size = 0;
             let data = ffi::lua_tolstring(ref_thread, self.0.index, &mut size);
-
-            slice::from_raw_parts(data as *const u8, size + 1)
-        }
+            slice::from_raw_parts(data as *const u8, size)
+        };
+        (slice, lua)
     }
 
     /// Converts this string to a generic C pointer.
@@ -141,66 +144,30 @@ impl<'lua> String<'lua> {
     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) -> OwnedString {
-        OwnedString(self.0.into_owned())
-    }
 }
 
-impl<'lua> fmt::Debug for String<'lua> {
+impl fmt::Debug for String {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let bytes = self.as_bytes();
         // Check if the string is valid utf8
-        if let Ok(s) = str::from_utf8(bytes) {
+        if let Ok(s) = str::from_utf8(&bytes) {
             return s.fmt(f);
         }
 
         // Format as bytes
-        write!(f, "b\"")?;
-        for &b in bytes {
-            // https://doc.rust-lang.org/reference/tokens.html#byte-escapes
-            match b {
-                b'\n' => write!(f, "\\n")?,
-                b'\r' => write!(f, "\\r")?,
-                b'\t' => write!(f, "\\t")?,
-                b'\\' | b'"' => write!(f, "\\{}", b as char)?,
-                b'\0' => write!(f, "\\0")?,
-                // ASCII printable
-                0x20..=0x7e => write!(f, "{}", b as char)?,
-                _ => write!(f, "\\x{b:02x}")?,
-            }
-        }
-        write!(f, "\"")?;
-
-        Ok(())
+        write!(f, "b")?;
+        <bstr::BStr as fmt::Debug>::fmt(bstr::BStr::new(&bytes), f)
     }
 }
 
-impl<'lua> AsRef<[u8]> for String<'lua> {
-    fn as_ref(&self) -> &[u8] {
-        self.as_bytes()
-    }
-}
-
-impl<'lua> Borrow<[u8]> for String<'lua> {
-    fn borrow(&self) -> &[u8] {
-        self.as_bytes()
-    }
-}
-
-// Lua strings are basically &[u8] slices, so implement PartialEq for anything resembling that.
+// Lua strings are basically `&[u8]` slices, so implement `PartialEq` for anything resembling that.
 //
-// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str`, `String` and `mlua::String`
-// itself.
+// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str` and `String`.
 //
 // The only downside is that this disallows a comparison with `Cow<str>`, as that only implements
 // `AsRef<str>`, which collides with this impl. Requiring `AsRef<str>` would fix that, but limit us
 // in other ways.
-impl<'lua, T> PartialEq<T> for String<'lua>
+impl<T> PartialEq<T> for String
 where
     T: AsRef<[u8]> + ?Sized,
 {
@@ -209,61 +176,259 @@ where
     }
 }
 
-impl<'lua> Eq for String<'lua> {}
+impl PartialEq for String {
+    fn eq(&self, other: &String) -> bool {
+        self.as_bytes() == other.as_bytes()
+    }
+}
 
-impl<'lua> Hash for String<'lua> {
+impl Eq for String {}
+
+impl<T> PartialOrd<T> for String
+where
+    T: AsRef<[u8]> + ?Sized,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.as_bytes().partial_cmp(&other.as_ref())
+    }
+}
+
+impl PartialOrd for String {
+    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for String {
+    fn cmp(&self, other: &String) -> cmp::Ordering {
+        self.as_bytes().cmp(&other.as_bytes())
+    }
+}
+
+impl Hash for String {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.as_bytes().hash(state);
     }
 }
 
 #[cfg(feature = "serialize")]
-impl<'lua> Serialize for String<'lua> {
+impl Serialize for String {
     fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
     where
         S: Serializer,
     {
         match self.to_str() {
-            Ok(s) => serializer.serialize_str(s),
-            Err(_) => serializer.serialize_bytes(self.as_bytes()),
+            Ok(s) => serializer.serialize_str(&s),
+            Err(_) => serializer.serialize_bytes(&self.as_bytes()),
         }
     }
 }
 
-// Additional shortcuts
-#[cfg(feature = "unstable")]
-impl OwnedString {
-    /// Get a `&str` slice if the Lua string is valid UTF-8.
-    ///
-    /// This is a shortcut for [`String::to_str()`].
-    #[inline]
-    pub fn to_str(&self) -> Result<&str> {
-        let s = self.to_ref();
-        // Reattach lifetime to &self
-        unsafe { std::mem::transmute(s.to_str()) }
-    }
+struct Display<'a>(&'a String);
 
-    /// Get the bytes that make up this string.
-    ///
-    /// This is a shortcut for [`String::as_bytes()`].
-    #[inline]
-    pub fn as_bytes(&self) -> &[u8] {
-        let s = self.to_ref();
-        // Reattach lifetime to &self
-        unsafe { std::mem::transmute(s.as_bytes()) }
+impl fmt::Display for Display<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let bytes = self.0.as_bytes();
+        <bstr::BStr as fmt::Display>::fmt(bstr::BStr::new(&bytes), f)
     }
 }
 
-#[cfg(feature = "unstable")]
-impl fmt::Debug for OwnedString {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.to_ref().fmt(f)
+/// A borrowed string (`&str`) that holds a strong reference to the Lua state.
+pub struct BorrowedStr<'a> {
+    // `buf` points to a readonly memory managed by Lua
+    pub(crate) buf: &'a str,
+    pub(crate) borrow: Cow<'a, String>,
+    pub(crate) _lua: Lua,
+}
+
+impl Deref for BorrowedStr<'_> {
+    type Target = str;
+
+    #[inline(always)]
+    fn deref(&self) -> &str {
+        self.buf
     }
 }
 
+impl Borrow<str> for BorrowedStr<'_> {
+    #[inline(always)]
+    fn borrow(&self) -> &str {
+        self.buf
+    }
+}
+
+impl AsRef<str> for BorrowedStr<'_> {
+    #[inline(always)]
+    fn as_ref(&self) -> &str {
+        self.buf
+    }
+}
+
+impl fmt::Display for BorrowedStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.buf.fmt(f)
+    }
+}
+
+impl fmt::Debug for BorrowedStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.buf.fmt(f)
+    }
+}
+
+impl<T> PartialEq<T> for BorrowedStr<'_>
+where
+    T: AsRef<str>,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.buf == other.as_ref()
+    }
+}
+
+impl Eq for BorrowedStr<'_> {}
+
+impl<T> PartialOrd<T> for BorrowedStr<'_>
+where
+    T: AsRef<str>,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.buf.partial_cmp(other.as_ref())
+    }
+}
+
+impl Ord for BorrowedStr<'_> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.buf.cmp(other.buf)
+    }
+}
+
+impl<'a> TryFrom<&'a String> for BorrowedStr<'a> {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(value: &'a String) -> Result<Self> {
+        let BorrowedBytes { buf, borrow, _lua } = BorrowedBytes::from(value);
+        let buf = str::from_utf8(buf).map_err(|e| Error::FromLuaConversionError {
+            from: "string",
+            to: "&str".to_string(),
+            message: Some(e.to_string()),
+        })?;
+        Ok(Self { buf, borrow, _lua })
+    }
+}
+
+/// A borrowed byte slice (`&[u8]`) that holds a strong reference to the Lua state.
+pub struct BorrowedBytes<'a> {
+    // `buf` points to a readonly memory managed by Lua
+    pub(crate) buf: &'a [u8],
+    pub(crate) borrow: Cow<'a, String>,
+    pub(crate) _lua: Lua,
+}
+
+impl Deref for BorrowedBytes<'_> {
+    type Target = [u8];
+
+    #[inline(always)]
+    fn deref(&self) -> &[u8] {
+        self.buf
+    }
+}
+
+impl Borrow<[u8]> for BorrowedBytes<'_> {
+    #[inline(always)]
+    fn borrow(&self) -> &[u8] {
+        self.buf
+    }
+}
+
+impl AsRef<[u8]> for BorrowedBytes<'_> {
+    #[inline(always)]
+    fn as_ref(&self) -> &[u8] {
+        self.buf
+    }
+}
+
+impl fmt::Debug for BorrowedBytes<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.buf.fmt(f)
+    }
+}
+
+impl<T> PartialEq<T> for BorrowedBytes<'_>
+where
+    T: AsRef<[u8]>,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.buf == other.as_ref()
+    }
+}
+
+impl Eq for BorrowedBytes<'_> {}
+
+impl<T> PartialOrd<T> for BorrowedBytes<'_>
+where
+    T: AsRef<[u8]>,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.buf.partial_cmp(other.as_ref())
+    }
+}
+
+impl Ord for BorrowedBytes<'_> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.buf.cmp(other.buf)
+    }
+}
+
+impl<'a> IntoIterator for &'a BorrowedBytes<'_> {
+    type Item = &'a u8;
+    type IntoIter = slice::Iter<'a, u8>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a> From<&'a String> for BorrowedBytes<'a> {
+    #[inline]
+    fn from(value: &'a String) -> Self {
+        let (buf, _lua) = unsafe { value.to_slice() };
+        let borrow = Cow::Borrowed(value);
+        Self { buf, borrow, _lua }
+    }
+}
+
+struct WrappedString<T: AsRef<[u8]>>(T);
+
+impl String {
+    /// Wraps bytes, returning an opaque type that implements [`IntoLua`] trait.
+    ///
+    /// This function uses [`Lua::create_string`] under the hood.
+    pub fn wrap(data: impl AsRef<[u8]>) -> impl IntoLua {
+        WrappedString(data)
+    }
+}
+
+impl<T: AsRef<[u8]>> IntoLua for WrappedString<T> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.create_string(self.0).map(Value::String)
+    }
+}
+
+impl LuaType for String {
+    const TYPE_ID: c_int = ffi::LUA_TSTRING;
+}
+
 #[cfg(test)]
 mod assertions {
     use super::*;
 
+    #[cfg(not(feature = "send"))]
     static_assertions::assert_not_impl_any!(String: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(String: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(BorrowedBytes: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(BorrowedStr: Send, Sync);
 }

src/thread.rs

@@ -1,11 +1,12 @@
+use std::fmt;
 use std::os::raw::{c_int, c_void};
 
 use crate::error::{Error, Result};
-#[allow(unused)]
-use crate::lua::Lua;
-use crate::types::LuaRef;
+use crate::function::Function;
+use crate::state::RawLua;
+use crate::traits::{FromLuaMulti, IntoLuaMulti};
+use crate::types::{LuaType, ValueRef};
 use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
-use crate::value::{FromLuaMulti, IntoLuaMulti};
 
 #[cfg(not(feature = "luau"))]
 use crate::{
@@ -15,7 +16,6 @@ use crate::{
 
 #[cfg(feature = "async")]
 use {
-    crate::value::MultiValue,
     futures_util::stream::Stream,
     std::{
         future::Future,
@@ -29,46 +29,47 @@ use {
 /// Status of a Lua thread (coroutine).
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum ThreadStatus {
-    /// The thread was just created, or is suspended because it has called `coroutine.yield`.
+    /// The thread was just created or is suspended (yielded).
     ///
     /// If a thread is in this state, it can be resumed by calling [`Thread::resume`].
-    ///
-    /// [`Thread::resume`]: crate::Thread::resume
     Resumable,
-    /// Either the thread has finished executing, or the thread is currently running.
-    Unresumable,
+    /// The thread is currently running.
+    Running,
+    /// The thread has finished executing.
+    Finished,
     /// The thread has raised a Lua error during execution.
     Error,
 }
 
-/// Handle to an internal Lua thread (coroutine).
-#[derive(Clone, Debug)]
-pub struct Thread<'lua>(pub(crate) LuaRef<'lua>, pub(crate) *mut ffi::lua_State);
-
-/// Owned handle to an internal Lua thread (coroutine).
+/// Internal representation of a Lua thread status.
 ///
-/// The owned handle holds a *strong* reference to the current Lua instance.
-/// Be warned, if you place it into a Lua type (eg. [`UserData`] or a Rust callback), it is *very easy*
-/// to accidentally cause reference cycles that would prevent destroying Lua instance.
-///
-/// [`UserData`]: crate::UserData
-#[cfg(feature = "unstable")]
-#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
-#[derive(Clone, Debug)]
-pub struct OwnedThread(
-    pub(crate) crate::types::LuaOwnedRef,
-    pub(crate) *mut ffi::lua_State,
-);
+/// The number in `New` and `Yielded` variants is the number of arguments pushed
+/// to the thread stack.
+#[derive(Clone, Copy)]
+enum ThreadStatusInner {
+    New,
+    Running,
+    Yielded,
+    Finished,
+    Error,
+}
 
-#[cfg(feature = "unstable")]
-impl OwnedThread {
-    /// Get borrowed handle to the underlying Lua table.
-    #[cfg_attr(feature = "send", allow(unused))]
-    pub const fn to_ref(&self) -> Thread {
-        Thread(self.0.to_ref(), self.1)
+impl ThreadStatusInner {
+    #[inline(always)]
+    fn is_resumable(self) -> bool {
+        matches!(self, ThreadStatusInner::New | ThreadStatusInner::Yielded)
     }
 }
 
+/// Handle to an internal Lua thread (coroutine).
+#[derive(Clone)]
+pub struct Thread(pub(crate) ValueRef, pub(crate) *mut ffi::lua_State);
+
+#[cfg(feature = "send")]
+unsafe impl Send for Thread {}
+#[cfg(feature = "send")]
+unsafe impl Sync for Thread {}
+
 /// Thread (coroutine) representation as an async [`Future`] or [`Stream`].
 ///
 /// Requires `feature = "async"`
@@ -78,37 +79,32 @@ impl OwnedThread {
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct AsyncThread<'lua, R> {
-    thread: Thread<'lua>,
-    init_args: Option<Result<MultiValue<'lua>>>,
+pub struct AsyncThread<A, R> {
+    thread: Thread,
+    init_args: Option<A>,
     ret: PhantomData<R>,
     recycle: bool,
 }
 
-impl<'lua> Thread<'lua> {
+impl Thread {
     #[inline(always)]
-    pub(crate) fn new(r#ref: LuaRef<'lua>) -> Self {
-        let state = unsafe { ffi::lua_tothread(r#ref.lua.ref_thread(), r#ref.index) };
-        Thread(r#ref, state)
-    }
-
-    const fn state(&self) -> *mut ffi::lua_State {
+    fn state(&self) -> *mut ffi::lua_State {
         self.1
     }
 
     /// Resumes execution of this thread.
     ///
-    /// Equivalent to `coroutine.resume`.
+    /// Equivalent to [`coroutine.resume`].
     ///
-    /// Passes `args` as arguments to the thread. If the coroutine has called `coroutine.yield`, it
-    /// will return these arguments. Otherwise, the coroutine wasn't yet started, so the arguments
-    /// are passed to its main function.
+    /// Passes `args` as arguments to the thread. If the coroutine has called [`coroutine.yield`],
+    /// it will return these arguments. Otherwise, the coroutine wasn't yet started, so the
+    /// arguments are passed to its main function.
     ///
-    /// If the thread is no longer in `Active` state (meaning it has finished execution or
-    /// encountered an error), this will return `Err(CoroutineInactive)`, otherwise will return `Ok`
-    /// as follows:
+    /// If the thread is no longer resumable (meaning it has finished execution or encountered an
+    /// error), this will return [`Error::CoroutineUnresumable`], otherwise will return `Ok` as
+    /// follows:
     ///
-    /// If the thread calls `coroutine.yield`, returns the values passed to `yield`. If the thread
+    /// If the thread calls [`coroutine.yield`], returns the values passed to `yield`. If the thread
     /// `return`s values from its main function, returns those.
     ///
     /// # Examples
@@ -126,46 +122,47 @@ impl<'lua> Thread<'lua> {
     ///     end)
     /// "#).eval()?;
     ///
-    /// assert_eq!(thread.resume::<_, u32>(42)?, 123);
-    /// assert_eq!(thread.resume::<_, u32>(43)?, 987);
+    /// assert_eq!(thread.resume::<u32>(42)?, 123);
+    /// assert_eq!(thread.resume::<u32>(43)?, 987);
     ///
     /// // The coroutine has now returned, so `resume` will fail
-    /// match thread.resume::<_, u32>(()) {
-    ///     Err(Error::CoroutineInactive) => {},
+    /// match thread.resume::<u32>(()) {
+    ///     Err(Error::CoroutineUnresumable) => {},
     ///     unexpected => panic!("unexpected result {:?}", unexpected),
     /// }
     /// # Ok(())
     /// # }
     /// ```
-    pub fn resume<A, R>(&self, args: A) -> Result<R>
+    ///
+    /// [`coroutine.resume`]: https://www.lua.org/manual/5.4/manual.html#pdf-coroutine.resume
+    /// [`coroutine.yield`]: https://www.lua.org/manual/5.4/manual.html#pdf-coroutine.yield
+    pub fn resume<R>(&self, args: impl IntoLuaMulti) -> Result<R>
     where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
+        R: FromLuaMulti,
     {
-        if self.status() != ThreadStatus::Resumable {
-            return Err(Error::CoroutineInactive);
+        let lua = self.0.lua.lock();
+        if !self.status_inner(&lua).is_resumable() {
+            return Err(Error::CoroutineUnresumable);
         }
 
-        let lua = self.0.lua;
         let state = lua.state();
         let thread_state = self.state();
         unsafe {
             let _sg = StackGuard::new(state);
             let _thread_sg = StackGuard::with_top(thread_state, 0);
 
-            let nresults = self.resume_inner(args)?;
+            let nresults = self.resume_inner(&lua, args)?;
             check_stack(state, nresults + 1)?;
             ffi::lua_xmove(thread_state, state, nresults);
 
-            R::from_stack_multi(nresults, lua)
+            R::from_stack_multi(nresults, &lua)
         }
     }
 
     /// Resumes execution of this thread.
     ///
     /// It's similar to `resume()` but leaves `nresults` values on the thread stack.
-    unsafe fn resume_inner<A: IntoLuaMulti<'lua>>(&self, args: A) -> Result<c_int> {
-        let lua = self.0.lua;
+    unsafe fn resume_inner(&self, lua: &RawLua, args: impl IntoLuaMulti) -> Result<c_int> {
         let state = lua.state();
         let thread_state = self.state();
 
@@ -183,10 +180,7 @@ impl<'lua> Thread<'lua> {
                 return Err(pop_error(thread_state, ret));
             }
             check_stack(state, 3)?;
-            protect_lua!(state, 0, 1, |state| error_traceback_thread(
-                state,
-                thread_state
-            ))?;
+            protect_lua!(state, 0, 1, |state| error_traceback_thread(state, thread_state))?;
             return Err(pop_error(state, ret));
         }
 
@@ -195,34 +189,41 @@ 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 {
-                ThreadStatus::Error
-            } else if status == ffi::LUA_YIELD || ffi::lua_gettop(thread_state) > 0 {
-                ThreadStatus::Resumable
-            } else {
-                ThreadStatus::Unresumable
-            }
+        match self.status_inner(&self.0.lua.lock()) {
+            ThreadStatusInner::New | ThreadStatusInner::Yielded => ThreadStatus::Resumable,
+            ThreadStatusInner::Running => ThreadStatus::Running,
+            ThreadStatusInner::Finished => ThreadStatus::Finished,
+            ThreadStatusInner::Error => ThreadStatus::Error,
         }
     }
 
-    /// Sets a 'hook' function that will periodically be called as Lua code executes.
+    /// Gets the status of the thread (internal implementation).
+    fn status_inner(&self, lua: &RawLua) -> ThreadStatusInner {
+        let thread_state = self.state();
+        if thread_state == lua.state() {
+            // The thread is currently running
+            return ThreadStatusInner::Running;
+        }
+        let status = unsafe { ffi::lua_status(thread_state) };
+        match status {
+            ffi::LUA_YIELD => ThreadStatusInner::Yielded,
+            ffi::LUA_OK if unsafe { ffi::lua_gettop(thread_state) } > 0 => ThreadStatusInner::New,
+            ffi::LUA_OK => ThreadStatusInner::Finished,
+            _ => ThreadStatusInner::Error,
+        }
+    }
+
+    /// Sets a hook function that will periodically be called as Lua code executes.
     ///
-    /// This function is similar or [`Lua::set_hook()`] except that it sets for the thread.
-    /// To remove a hook call [`Lua::remove_hook()`].
+    /// This function is similar or [`Lua::set_hook`] except that it sets for the thread.
+    /// To remove a hook call [`Lua::remove_hook`].
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F)
     where
-        F: Fn(&Lua, Debug) -> Result<()> + MaybeSend + 'static,
+        F: Fn(&crate::Lua, Debug) -> Result<crate::VmState> + MaybeSend + 'static,
     {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         unsafe {
             lua.set_thread_hook(self.state(), triggers, callback);
         }
@@ -237,31 +238,37 @@ impl<'lua> Thread<'lua> {
     /// In Luau: resets to the initial state of a newly created Lua thread.
     /// Lua threads in arbitrary states (like yielded or errored) can be reset properly.
     ///
+    /// Other Lua versions can reset only new or finished threads.
+    ///
     /// Sets a Lua function for the thread afterwards.
     ///
-    /// Requires `feature = "lua54"` OR `feature = "luau"`.
-    ///
     /// [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(any(feature = "lua54", feature = "luau"))))]
-    pub fn reset(&self, func: crate::function::Function<'lua>) -> Result<()> {
-        let lua = self.0.lua;
+    pub fn reset(&self, func: Function) -> Result<()> {
+        let lua = self.0.lua.lock();
         let thread_state = self.state();
-        if thread_state == lua.state() {
-            return Err(Error::runtime("cannot reset a running thread"));
+        match self.status_inner(&lua) {
+            ThreadStatusInner::Running => return Err(Error::runtime("cannot reset a running thread")),
+            // Any Lua can reuse new or finished thread
+            ThreadStatusInner::New => unsafe { ffi::lua_settop(thread_state, 0) },
+            ThreadStatusInner::Finished => {}
+            #[cfg(not(any(feature = "lua54", feature = "luau")))]
+            _ => return Err(Error::runtime("cannot reset non-finished thread")),
+            #[cfg(any(feature = "lua54", feature = "luau"))]
+            _ => unsafe {
+                #[cfg(all(feature = "lua54", not(feature = "vendored")))]
+                let status = ffi::lua_resetthread(thread_state);
+                #[cfg(all(feature = "lua54", feature = "vendored"))]
+                let status = ffi::lua_closethread(thread_state, lua.state());
+                #[cfg(feature = "lua54")]
+                if status != ffi::LUA_OK {
+                    return Err(pop_error(thread_state, status));
+                }
+                #[cfg(feature = "luau")]
+                ffi::lua_resetthread(thread_state);
+            },
         }
-        unsafe {
-            #[cfg(all(feature = "lua54", not(feature = "vendored")))]
-            let status = ffi::lua_resetthread(thread_state);
-            #[cfg(all(feature = "lua54", feature = "vendored"))]
-            let status = ffi::lua_closethread(thread_state, lua.state());
-            #[cfg(feature = "lua54")]
-            if status != ffi::LUA_OK {
-                return Err(pop_error(thread_state, status));
-            }
-            #[cfg(feature = "luau")]
-            ffi::lua_resetthread(thread_state);
 
+        unsafe {
             // Push function to the top of the thread stack
             ffi::lua_xpush(lua.ref_thread(), thread_state, func.0.index);
 
@@ -276,27 +283,28 @@ impl<'lua> Thread<'lua> {
         }
     }
 
-    /// Converts Thread to an AsyncThread which implements [`Future`] and [`Stream`] traits.
+    /// Converts [`Thread`] to an [`AsyncThread`] which implements [`Future`] and [`Stream`] traits.
     ///
     /// `args` are passed as arguments to the thread function for first call.
-    /// The object calls [`resume()`] while polling and also allows to run rust futures
+    /// The object calls [`resume`] while polling and also allow to run Rust futures
     /// to completion using an executor.
     ///
-    /// Using AsyncThread as a Stream allows to iterate through `coroutine.yield()`
-    /// values whereas Future version discards that values and poll until the final
+    /// Using [`AsyncThread`] as a [`Stream`] allow to iterate through [`coroutine.yield`]
+    /// values whereas [`Future`] version discards that values and poll until the final
     /// one (returned from the thread function).
     ///
     /// Requires `feature = "async"`
     ///
     /// [`Future`]: std::future::Future
     /// [`Stream`]: futures_util::stream::Stream
-    /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    /// [`resume`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    /// [`coroutine.yield`]: https://www.lua.org/manual/5.4/manual.html#pdf-coroutine.yield
     ///
     /// # Examples
     ///
     /// ```
     /// # use mlua::{Lua, Result, Thread};
-    /// use futures::stream::TryStreamExt;
+    /// use futures_util::stream::TryStreamExt;
     /// # #[tokio::main]
     /// # async fn main() -> Result<()> {
     /// # let lua = Lua::new();
@@ -310,7 +318,7 @@ impl<'lua> Thread<'lua> {
     ///     end)
     /// "#).eval()?;
     ///
-    /// let mut stream = thread.into_async::<_, i64>(1);
+    /// let mut stream = thread.into_async::<i64>(1);
     /// let mut sum = 0;
     /// while let Some(n) = stream.try_next().await? {
     ///     sum += n;
@@ -323,12 +331,10 @@ impl<'lua> Thread<'lua> {
     /// ```
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R>
+    pub fn into_async<R>(self, args: impl IntoLuaMulti) -> AsyncThread<impl IntoLuaMulti, R>
     where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
+        R: FromLuaMulti,
     {
-        let args = args.into_lua_multi(self.0.lua);
         AsyncThread {
             thread: self,
             init_args: Some(args),
@@ -342,7 +348,7 @@ impl<'lua> Thread<'lua> {
     /// Under the hood replaces the global environment table with a new table,
     /// that performs writes locally and proxies reads to caller's global environment.
     ///
-    /// This mode ideally should be used together with the global sandbox mode [`Lua::sandbox()`].
+    /// This mode ideally should be used together with the global sandbox mode [`Lua::sandbox`].
     ///
     /// Please note that Luau links environment table with chunk when loading it into Lua state.
     /// Therefore you need to load chunks into a thread to link with the thread environment.
@@ -351,28 +357,32 @@ impl<'lua> Thread<'lua> {
     ///
     /// ```
     /// # use mlua::{Lua, Result};
+    /// # #[cfg(feature = "luau")]
     /// # fn main() -> Result<()> {
     /// let lua = Lua::new();
     /// let thread = lua.create_thread(lua.create_function(|lua2, ()| {
     ///     lua2.load("var = 123").exec()?;
-    ///     assert_eq!(lua2.globals().get::<_, u32>("var")?, 123);
+    ///     assert_eq!(lua2.globals().get::<u32>("var")?, 123);
     ///     Ok(())
     /// })?)?;
     /// thread.sandbox()?;
-    /// thread.resume(())?;
+    /// thread.resume::<()>(())?;
     ///
     /// // The global environment should be unchanged
-    /// assert_eq!(lua.globals().get::<_, Option<u32>>("var")?, None);
+    /// assert_eq!(lua.globals().get::<Option<u32>>("var")?, None);
     /// # Ok(())
     /// # }
+    ///
+    /// # #[cfg(not(feature = "luau"))]
+    /// # fn main() { }
     /// ```
     ///
     /// Requires `feature = "luau"`
-    #[cfg(any(feature = "luau", docsrs))]
+    #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     #[doc(hidden)]
     pub fn sandbox(&self) -> Result<()> {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
         let state = lua.state();
         let thread_state = self.state();
         unsafe {
@@ -391,98 +401,67 @@ impl<'lua> Thread<'lua> {
     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) -> OwnedThread {
-        OwnedThread(self.0.into_owned(), self.1)
+impl fmt::Debug for Thread {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_tuple("Thread").field(&self.0).finish()
     }
 }
 
-impl<'lua> PartialEq for Thread<'lua> {
+impl PartialEq for Thread {
     fn eq(&self, other: &Self) -> bool {
         self.0 == other.0
     }
 }
 
-// Additional shortcuts
-#[cfg(feature = "unstable")]
-impl OwnedThread {
-    /// Resumes execution of this thread.
-    ///
-    /// See [`Thread::resume()`] for more details.
-    pub fn resume<'lua, A, R>(&'lua self, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
-    {
-        self.to_ref().resume(args)
-    }
-
-    /// Gets the status of the thread.
-    pub fn status(&self) -> ThreadStatus {
-        self.to_ref().status()
-    }
+impl LuaType for Thread {
+    const TYPE_ID: c_int = ffi::LUA_TTHREAD;
 }
 
 #[cfg(feature = "async")]
-impl<'lua, R> AsyncThread<'lua, R> {
-    #[inline]
+impl<A, R> AsyncThread<A, R> {
+    #[inline(always)]
     pub(crate) fn set_recyclable(&mut self, recyclable: bool) {
         self.recycle = recyclable;
     }
 }
 
 #[cfg(feature = "async")]
-#[cfg(any(feature = "lua54", feature = "luau"))]
-impl<'lua, R> Drop for AsyncThread<'lua, R> {
+impl<A, R> Drop for AsyncThread<A, R> {
     fn drop(&mut self) {
         if self.recycle {
-            unsafe {
-                let lua = self.thread.0.lua;
+            if let Some(lua) = self.thread.0.lua.try_lock() {
                 // For Lua 5.4 this also closes all pending to-be-closed variables
-                if !lua.recycle_thread(&mut self.thread) {
-                    #[cfg(feature = "lua54")]
-                    if self.thread.status() == ThreadStatus::Error {
-                        #[cfg(not(feature = "vendored"))]
-                        ffi::lua_resetthread(self.thread.state());
-                        #[cfg(feature = "vendored")]
-                        ffi::lua_closethread(self.thread.state(), lua.state());
-                    }
-                }
+                unsafe { lua.recycle_thread(&mut self.thread) };
             }
         }
     }
 }
 
 #[cfg(feature = "async")]
-impl<'lua, R> Stream for AsyncThread<'lua, R>
-where
-    R: FromLuaMulti<'lua>,
-{
+impl<A: IntoLuaMulti, R: FromLuaMulti> Stream for AsyncThread<A, R> {
     type Item = Result<R>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        if self.thread.status() != ThreadStatus::Resumable {
+        let lua = self.thread.0.lua.lock();
+        if !self.thread.status_inner(&lua).is_resumable() {
             return Poll::Ready(None);
         }
 
-        let lua = self.thread.0.lua;
         let state = lua.state();
         let thread_state = self.thread.state();
         unsafe {
             let _sg = StackGuard::new(state);
             let _thread_sg = StackGuard::with_top(thread_state, 0);
-            let _wg = WakerGuard::new(lua, cx.waker());
+            let _wg = WakerGuard::new(&lua, cx.waker());
 
             // This is safe as we are not moving the whole struct
             let this = self.get_unchecked_mut();
             let nresults = if let Some(args) = this.init_args.take() {
-                this.thread.resume_inner(args?)?
+                this.thread.resume_inner(&lua, args)?
             } else {
-                this.thread.resume_inner(())?
+                this.thread.resume_inner(&lua, ())?
             };
 
             if nresults == 1 && is_poll_pending(thread_state) {
@@ -493,37 +472,34 @@ where
             ffi::lua_xmove(thread_state, state, nresults);
 
             cx.waker().wake_by_ref();
-            Poll::Ready(Some(R::from_stack_multi(nresults, lua)))
+            Poll::Ready(Some(R::from_stack_multi(nresults, &lua)))
         }
     }
 }
 
 #[cfg(feature = "async")]
-impl<'lua, R> Future for AsyncThread<'lua, R>
-where
-    R: FromLuaMulti<'lua>,
-{
+impl<A: IntoLuaMulti, R: FromLuaMulti> Future for AsyncThread<A, R> {
     type Output = Result<R>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        if self.thread.status() != ThreadStatus::Resumable {
-            return Poll::Ready(Err(Error::CoroutineInactive));
+        let lua = self.thread.0.lua.lock();
+        if !self.thread.status_inner(&lua).is_resumable() {
+            return Poll::Ready(Err(Error::CoroutineUnresumable));
         }
 
-        let lua = self.thread.0.lua;
         let state = lua.state();
         let thread_state = self.thread.state();
         unsafe {
             let _sg = StackGuard::new(state);
             let _thread_sg = StackGuard::with_top(thread_state, 0);
-            let _wg = WakerGuard::new(lua, cx.waker());
+            let _wg = WakerGuard::new(&lua, cx.waker());
 
             // This is safe as we are not moving the whole struct
             let this = self.get_unchecked_mut();
             let nresults = if let Some(args) = this.init_args.take() {
-                this.thread.resume_inner(args?)?
+                this.thread.resume_inner(&lua, args)?
             } else {
-                this.thread.resume_inner(())?
+                this.thread.resume_inner(&lua, ())?
             };
 
             if nresults == 1 && is_poll_pending(thread_state) {
@@ -539,7 +515,7 @@ where
             check_stack(state, nresults + 1)?;
             ffi::lua_xmove(thread_state, state, nresults);
 
-            Poll::Ready(R::from_stack_multi(nresults, lua))
+            Poll::Ready(R::from_stack_multi(nresults, &lua))
         }
     }
 }
@@ -547,12 +523,12 @@ where
 #[cfg(feature = "async")]
 #[inline(always)]
 unsafe fn is_poll_pending(state: *mut ffi::lua_State) -> bool {
-    ffi::lua_tolightuserdata(state, -1) == Lua::poll_pending().0
+    ffi::lua_tolightuserdata(state, -1) == crate::Lua::poll_pending().0
 }
 
 #[cfg(feature = "async")]
 struct WakerGuard<'lua, 'a> {
-    lua: &'lua Lua,
+    lua: &'lua RawLua,
     prev: NonNull<Waker>,
     _phantom: PhantomData<&'a ()>,
 }
@@ -560,7 +536,7 @@ struct WakerGuard<'lua, 'a> {
 #[cfg(feature = "async")]
 impl<'lua, 'a> WakerGuard<'lua, 'a> {
     #[inline]
-    pub fn new(lua: &'lua Lua, waker: &'a Waker) -> Result<WakerGuard<'lua, 'a>> {
+    pub fn new(lua: &'lua RawLua, waker: &'a Waker) -> Result<WakerGuard<'lua, 'a>> {
         let prev = unsafe { lua.set_waker(NonNull::from(waker)) };
         Ok(WakerGuard {
             lua,
@@ -571,7 +547,7 @@ impl<'lua, 'a> WakerGuard<'lua, 'a> {
 }
 
 #[cfg(feature = "async")]
-impl<'lua, 'a> Drop for WakerGuard<'lua, 'a> {
+impl Drop for WakerGuard<'_, '_> {
     fn drop(&mut self) {
         unsafe { self.lua.set_waker(self.prev) };
     }
@@ -581,5 +557,12 @@ impl<'lua, 'a> Drop for WakerGuard<'lua, 'a> {
 mod assertions {
     use super::*;
 
+    #[cfg(not(feature = "send"))]
     static_assertions::assert_not_impl_any!(Thread: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Thread: Send, Sync);
+    #[cfg(all(feature = "async", not(feature = "send")))]
+    static_assertions::assert_not_impl_any!(AsyncThread<(), ()>: Send);
+    #[cfg(all(feature = "async", feature = "send"))]
+    static_assertions::assert_impl_all!(AsyncThread<(), ()>: Send, Sync);
 }

src/traits.rs

@@ -0,0 +1,311 @@
+use std::os::raw::c_int;
+use std::string::String as StdString;
+use std::sync::Arc;
+
+use crate::error::{Error, Result};
+use crate::multi::MultiValue;
+use crate::private::Sealed;
+use crate::state::{Lua, RawLua};
+use crate::types::MaybeSend;
+use crate::util::{check_stack, short_type_name};
+use crate::value::Value;
+
+#[cfg(feature = "async")]
+use std::future::Future;
+
+/// Trait for types convertible to [`Value`].
+pub trait IntoLua: Sized {
+    /// Performs the conversion.
+    fn into_lua(self, lua: &Lua) -> Result<Value>;
+
+    /// Pushes the value into the Lua stack.
+    ///
+    /// # Safety
+    /// This method does not check Lua stack space.
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_value(&self.into_lua(lua.lua())?)
+    }
+}
+
+/// Trait for types convertible from [`Value`].
+pub trait FromLua: Sized {
+    /// Performs the conversion.
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self>;
+
+    /// Performs the conversion for an argument (eg. function argument).
+    ///
+    /// `i` is the argument index (position),
+    /// `to` is a function name that received the argument.
+    #[doc(hidden)]
+    #[inline]
+    fn from_lua_arg(arg: Value, i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
+        Self::from_lua(arg, lua).map_err(|err| Error::BadArgument {
+            to: to.map(|s| s.to_string()),
+            pos: i,
+            name: None,
+            cause: Arc::new(err),
+        })
+    }
+
+    /// Performs the conversion for a value in the Lua stack at index `idx`.
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        Self::from_lua(lua.stack_value(idx, None), lua.lua())
+    }
+
+    /// Same as `from_lua_arg` but for a value in the Lua stack at index `idx`.
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn from_stack_arg(idx: c_int, i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
+        Self::from_stack(idx, lua).map_err(|err| Error::BadArgument {
+            to: to.map(|s| s.to_string()),
+            pos: i,
+            name: None,
+            cause: Arc::new(err),
+        })
+    }
+}
+
+/// Trait for types convertible to any number of Lua values.
+///
+/// This is a generalization of [`IntoLua`], allowing any number of resulting Lua values instead of
+/// just one. Any type that implements [`IntoLua`] will automatically implement this trait.
+pub trait IntoLuaMulti: Sized {
+    /// Performs the conversion.
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue>;
+
+    /// Pushes the values into the Lua stack.
+    ///
+    /// Returns number of pushed values.
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        let values = self.into_lua_multi(lua.lua())?;
+        let len: c_int = values.len().try_into().unwrap();
+        unsafe {
+            check_stack(lua.state(), len + 1)?;
+            for val in &values {
+                lua.push_value(val)?;
+            }
+        }
+        Ok(len)
+    }
+}
+
+/// Trait for types that can be created from an arbitrary number of Lua values.
+///
+/// This is a generalization of [`FromLua`], allowing an arbitrary number of Lua values to
+/// participate in the conversion. Any type that implements [`FromLua`] will automatically
+/// implement this trait.
+pub trait FromLuaMulti: Sized {
+    /// Performs the conversion.
+    ///
+    /// In case `values` contains more values than needed to perform the conversion, the excess
+    /// values should be ignored. This reflects the semantics of Lua when calling a function or
+    /// assigning values. Similarly, if not enough values are given, conversions should assume that
+    /// any missing values are nil.
+    fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>;
+
+    /// Performs the conversion for a list of arguments.
+    ///
+    /// `i` is an index (position) of the first argument,
+    /// `to` is a function name that received the arguments.
+    #[doc(hidden)]
+    #[inline]
+    fn from_lua_args(args: MultiValue, i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
+        let _ = (i, to);
+        Self::from_lua_multi(args, lua)
+    }
+
+    /// Performs the conversion for a number of values in the Lua stack.
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn from_stack_multi(nvals: c_int, lua: &RawLua) -> Result<Self> {
+        let mut values = MultiValue::with_capacity(nvals as usize);
+        for idx in 0..nvals {
+            values.push_back(lua.stack_value(-nvals + idx, None));
+        }
+        Self::from_lua_multi(values, lua.lua())
+    }
+
+    /// Same as `from_lua_args` but for a number of values in the Lua stack.
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn from_stack_args(nargs: c_int, i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
+        let _ = (i, to);
+        Self::from_stack_multi(nargs, lua)
+    }
+}
+
+/// A trait for types that can be used as Lua objects (usually table and userdata).
+pub trait ObjectLike: Sealed {
+    /// Gets the value associated to `key` from the object, assuming it has `__index` metamethod.
+    fn get<V: FromLua>(&self, key: impl IntoLua) -> Result<V>;
+
+    /// Sets the value associated to `key` in the object, assuming it has `__newindex` metamethod.
+    fn set(&self, key: impl IntoLua, value: impl IntoLua) -> Result<()>;
+
+    /// Calls the object as a function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the object as its first argument, followed by the passed
+    /// arguments.
+    fn call<R>(&self, args: impl IntoLuaMulti) -> Result<R>
+    where
+        R: FromLuaMulti;
+
+    /// Asynchronously calls the object as a function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the object as its first argument, followed by the passed
+    /// arguments.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    where
+        R: FromLuaMulti;
+
+    /// Gets the function associated to key `name` from the object and calls it,
+    /// passing the object itself along with `args` as function arguments.
+    fn call_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> Result<R>
+    where
+        R: FromLuaMulti;
+
+    /// Gets the function associated to key `name` from the object and asynchronously calls it,
+    /// passing the object itself along with `args` as function arguments.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// This might invoke the `__index` metamethod.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    where
+        R: FromLuaMulti;
+
+    /// Gets the function associated to key `name` from the object and calls it,
+    /// passing `args` as function arguments.
+    ///
+    /// This might invoke the `__index` metamethod.
+    fn call_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> Result<R>
+    where
+        R: FromLuaMulti;
+
+    /// Gets the function associated to key `name` from the object and asynchronously calls it,
+    /// passing `args` as function arguments.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// This might invoke the `__index` metamethod.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    where
+        R: FromLuaMulti;
+
+    /// Converts the object to a string in a human-readable format.
+    ///
+    /// This might invoke the `__tostring` metamethod.
+    fn to_string(&self) -> Result<StdString>;
+}
+
+/// A trait for types that can be used as Lua functions.
+pub trait LuaNativeFn<A: FromLuaMulti> {
+    type Output: IntoLuaMulti;
+
+    fn call(&self, args: A) -> Self::Output;
+}
+
+/// A trait for types with mutable state that can be used as Lua functions.
+pub trait LuaNativeFnMut<A: FromLuaMulti> {
+    type Output: IntoLuaMulti;
+
+    fn call(&mut self, args: A) -> Self::Output;
+}
+
+/// A trait for types that returns a future and can be used as Lua functions.
+#[cfg(feature = "async")]
+pub trait LuaNativeAsyncFn<A: FromLuaMulti> {
+    type Output: IntoLuaMulti;
+
+    fn call(&self, args: A) -> impl Future<Output = Self::Output> + MaybeSend + 'static;
+}
+
+macro_rules! impl_lua_native_fn {
+    ($($A:ident),*) => {
+        impl<FN, $($A,)* R> LuaNativeFn<($($A,)*)> for FN
+        where
+            FN: Fn($($A,)*) -> R + MaybeSend + 'static,
+            ($($A,)*): FromLuaMulti,
+            R: IntoLuaMulti,
+        {
+            type Output = R;
+
+            #[allow(non_snake_case)]
+            fn call(&self, args: ($($A,)*)) -> Self::Output {
+                let ($($A,)*) = args;
+                self($($A,)*)
+            }
+        }
+
+        impl<FN, $($A,)* R> LuaNativeFnMut<($($A,)*)> for FN
+        where
+            FN: FnMut($($A,)*) -> R + MaybeSend + 'static,
+            ($($A,)*): FromLuaMulti,
+            R: IntoLuaMulti,
+        {
+            type Output = R;
+
+            #[allow(non_snake_case)]
+            fn call(&mut self, args: ($($A,)*)) -> Self::Output {
+                let ($($A,)*) = args;
+                self($($A,)*)
+            }
+        }
+
+        #[cfg(feature = "async")]
+        impl<FN, $($A,)* Fut, R> LuaNativeAsyncFn<($($A,)*)> for FN
+        where
+            FN: Fn($($A,)*) -> Fut + MaybeSend + 'static,
+            ($($A,)*): FromLuaMulti,
+            Fut: Future<Output = R> + MaybeSend + 'static,
+            R: IntoLuaMulti,
+        {
+            type Output = R;
+
+            #[allow(non_snake_case)]
+            fn call(&self, args: ($($A,)*)) -> impl Future<Output = Self::Output> + MaybeSend + 'static {
+                let ($($A,)*) = args;
+                self($($A,)*)
+            }
+        }
+    };
+}
+
+impl_lua_native_fn!();
+impl_lua_native_fn!(A);
+impl_lua_native_fn!(A, B);
+impl_lua_native_fn!(A, B, C);
+impl_lua_native_fn!(A, B, C, D);
+impl_lua_native_fn!(A, B, C, D, E);
+impl_lua_native_fn!(A, B, C, D, E, F);
+impl_lua_native_fn!(A, B, C, D, E, F, G);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
+impl_lua_native_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
+
+pub(crate) trait ShortTypeName {
+    #[inline(always)]
+    fn type_name() -> StdString {
+        short_type_name::<Self>()
+    }
+}
+
+impl<T> ShortTypeName for T {}

src/types.rs

@@ -1,93 +1,97 @@
-use std::any::{Any, TypeId};
-use std::cell::{Cell, Ref, RefCell, RefMut, UnsafeCell};
-use std::hash::{Hash, Hasher};
-use std::ops::{Deref, DerefMut};
+use std::cell::UnsafeCell;
 use std::os::raw::{c_int, c_void};
-use std::result::Result as StdResult;
-use std::sync::atomic::{AtomicI32, Ordering};
-use std::sync::{Arc, Mutex};
-use std::{fmt, mem, ptr};
-
-use rustc_hash::FxHashMap;
+use std::rc::Rc;
 
 use crate::error::Result;
 #[cfg(not(feature = "luau"))]
 use crate::hook::Debug;
-use crate::lua::{ExtraData, Lua};
+use crate::state::{ExtraData, Lua, RawLua};
 
-#[cfg(feature = "async")]
-use {crate::value::MultiValue, futures_util::future::LocalBoxFuture};
+// Re-export mutex wrappers
+pub(crate) use sync::{ArcReentrantMutexGuard, ReentrantMutex, ReentrantMutexGuard, XRc, XWeak};
 
-#[cfg(feature = "unstable")]
-use {crate::lua::LuaInner, std::marker::PhantomData};
+#[cfg(all(feature = "async", feature = "send"))]
+pub(crate) type BoxFuture<'a, T> = futures_util::future::BoxFuture<'a, T>;
 
-#[cfg(all(feature = "luau", feature = "serialize"))]
-use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
+#[cfg(all(feature = "async", not(feature = "send")))]
+pub(crate) type BoxFuture<'a, T> = futures_util::future::LocalBoxFuture<'a, T>;
+
+pub use app_data::{AppData, AppDataRef, AppDataRefMut};
+pub use either::Either;
+pub use registry_key::RegistryKey;
+pub(crate) use value_ref::ValueRef;
 
 /// Type of Lua integer numbers.
 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);
 
-pub(crate) type Callback<'lua, 'a> = Box<dyn Fn(&'lua Lua, c_int) -> Result<c_int> + 'a>;
+#[cfg(feature = "send")]
+unsafe impl Send for LightUserData {}
+#[cfg(feature = "send")]
+unsafe impl Sync for LightUserData {}
+
+#[cfg(feature = "send")]
+pub(crate) type Callback = Box<dyn Fn(&RawLua, c_int) -> Result<c_int> + Send + 'static>;
+
+#[cfg(not(feature = "send"))]
+pub(crate) type Callback = Box<dyn Fn(&RawLua, c_int) -> Result<c_int> + 'static>;
+
+pub(crate) type ScopedCallback<'s> = Box<dyn Fn(&RawLua, c_int) -> Result<c_int> + 's>;
 
 pub(crate) struct Upvalue<T> {
     pub(crate) data: T,
-    pub(crate) extra: Arc<UnsafeCell<ExtraData>>,
+    pub(crate) extra: XRc<UnsafeCell<ExtraData>>,
 }
 
-pub(crate) type CallbackUpvalue = Upvalue<Callback<'static, 'static>>;
+pub(crate) type CallbackUpvalue = Upvalue<Option<Callback>>;
+
+#[cfg(all(feature = "async", feature = "send"))]
+pub(crate) type AsyncCallback =
+    Box<dyn for<'a> Fn(&'a RawLua, c_int) -> BoxFuture<'a, Result<c_int>> + Send + 'static>;
+
+#[cfg(all(feature = "async", not(feature = "send")))]
+pub(crate) type AsyncCallback =
+    Box<dyn for<'a> Fn(&'a RawLua, c_int) -> BoxFuture<'a, Result<c_int>> + 'static>;
 
 #[cfg(feature = "async")]
-pub(crate) type AsyncCallback<'lua, 'a> =
-    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> LocalBoxFuture<'lua, Result<c_int>> + 'a>;
+pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback>;
 
 #[cfg(feature = "async")]
-pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback<'static, 'static>>;
+pub(crate) type AsyncPollUpvalue = Upvalue<BoxFuture<'static, Result<c_int>>>;
 
-#[cfg(feature = "async")]
-pub(crate) type AsyncPollUpvalue = Upvalue<LocalBoxFuture<'static, Result<c_int>>>;
-
-/// Type to set next Luau VM action after executing interrupt function.
-#[cfg(any(feature = "luau", doc))]
-#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+/// Type to set next Lua VM action after executing interrupt or hook function.
 pub enum VmState {
     Continue,
+    /// Yield the current thread.
+    ///
+    /// Supported by Lua 5.3+ and Luau.
     Yield,
 }
 
 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()> + Send>;
+pub(crate) type HookCallback = Rc<dyn Fn(&Lua, Debug) -> Result<VmState> + Send>;
 
 #[cfg(all(not(feature = "send"), not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()>>;
+pub(crate) type HookCallback = Rc<dyn Fn(&Lua, Debug) -> Result<VmState>>;
 
-#[cfg(all(feature = "luau", feature = "send"))]
-pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState> + Send>;
+#[cfg(all(feature = "send", feature = "luau"))]
+pub(crate) type InterruptCallback = Rc<dyn Fn(&Lua) -> Result<VmState> + Send>;
 
-#[cfg(all(feature = "luau", not(feature = "send")))]
-pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState>>;
+#[cfg(all(not(feature = "send"), feature = "luau"))]
+pub(crate) type InterruptCallback = Rc<dyn Fn(&Lua) -> Result<VmState>>;
 
 #[cfg(all(feature = "send", feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;
+pub(crate) type WarnCallback = XRc<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;
 
 #[cfg(all(not(feature = "send"), feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()>>;
+pub(crate) type WarnCallback = XRc<dyn Fn(&Lua, &str, bool) -> Result<()>>;
 
+/// A trait that adds `Send` requirement if `send` feature is enabled.
 #[cfg(feature = "send")]
 pub trait MaybeSend: Send {}
 #[cfg(feature = "send")]
@@ -98,441 +102,35 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}
 
-/// A Luau vector type.
-///
-/// By default vectors are 3-dimensional, but can be 4-dimensional
-/// if the `luau-vector4` feature is enabled.
-#[cfg(any(feature = "luau", doc))]
-#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
-pub struct Vector(pub(crate) [f32; Self::SIZE]);
-
-#[cfg(any(feature = "luau", doc))]
-impl fmt::Display for Vector {
-    #[rustfmt::skip]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        #[cfg(not(feature = "luau-vector4"))]
-        return write!(f, "vector({}, {}, {})", self.x(), self.y(), self.z());
-        #[cfg(feature = "luau-vector4")]
-        return write!(f, "vector({}, {}, {}, {})", self.x(), self.y(), self.z(), self.w());
-    }
-}
-
-#[cfg(any(feature = "luau", doc))]
-impl Vector {
-    pub(crate) const SIZE: usize = if cfg!(feature = "luau-vector4") { 4 } else { 3 };
-
-    /// Creates a new vector.
-    #[cfg(not(feature = "luau-vector4"))]
-    pub const fn new(x: f32, y: f32, z: f32) -> Self {
-        Self([x, y, z])
-    }
-
-    /// Creates a new vector.
-    #[cfg(feature = "luau-vector4")]
-    pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
-        Self([x, y, z, w])
-    }
-
-    /// Creates a new vector with all components set to `0.0`.
-    #[doc(hidden)]
-    pub const fn zero() -> Self {
-        Self([0.0; Self::SIZE])
-    }
-
-    /// Returns 1st component of the vector.
-    pub const fn x(&self) -> f32 {
-        self.0[0]
-    }
-
-    /// Returns 2nd component of the vector.
-    pub const fn y(&self) -> f32 {
-        self.0[1]
-    }
-
-    /// Returns 3rd component of the vector.
-    pub const fn z(&self) -> f32 {
-        self.0[2]
-    }
-
-    /// Returns 4th component of the vector.
-    #[cfg(any(feature = "luau-vector4", doc))]
-    #[cfg_attr(docsrs, doc(cfg(feature = "luau-vector4")))]
-    pub const fn w(&self) -> f32 {
-        self.0[3]
-    }
-}
-
-#[cfg(all(feature = "luau", feature = "serialize"))]
-impl Serialize for Vector {
-    fn serialize<S: Serializer>(&self, serializer: S) -> StdResult<S::Ok, S::Error> {
-        let mut ts = serializer.serialize_tuple_struct("Vector", Self::SIZE)?;
-        ts.serialize_field(&self.x())?;
-        ts.serialize_field(&self.y())?;
-        ts.serialize_field(&self.z())?;
-        #[cfg(feature = "luau-vector4")]
-        ts.serialize_field(&self.w())?;
-        ts.end()
-    }
-}
-
-#[cfg(any(feature = "luau", doc))]
-impl PartialEq<[f32; Self::SIZE]> for Vector {
-    #[inline]
-    fn eq(&self, other: &[f32; Self::SIZE]) -> bool {
-        self.0 == *other
-    }
-}
-
 pub(crate) struct DestructedUserdata;
 
-/// An auto generated key into the Lua registry.
-///
-/// This is a handle to a value stored inside the Lua registry. It is not automatically
-/// garbage collected on Drop, but it can be removed with [`Lua::remove_registry_value`],
-/// and instances not manually removed can be garbage collected with [`Lua::expire_registry_values`].
-///
-/// Be warned, If you place this into Lua via a [`UserData`] type or a rust callback, it is *very
-/// easy* to accidentally cause reference cycles that the Lua garbage collector cannot resolve.
-/// Instead of placing a [`RegistryKey`] into a [`UserData`] type, prefer instead to use
-/// [`AnyUserData::set_user_value`] / [`AnyUserData::user_value`].
-///
-/// [`UserData`]: crate::UserData
-/// [`RegistryKey`]: crate::RegistryKey
-/// [`Lua::remove_registry_value`]: crate::Lua::remove_registry_value
-/// [`Lua::expire_registry_values`]: crate::Lua::expire_registry_values
-/// [`AnyUserData::set_user_value`]: crate::AnyUserData::set_user_value
-/// [`AnyUserData::user_value`]: crate::AnyUserData::user_value
-pub struct RegistryKey {
-    pub(crate) registry_id: AtomicI32,
-    pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
+pub(crate) trait LuaType {
+    const TYPE_ID: c_int;
 }
 
-impl fmt::Debug for RegistryKey {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "RegistryKey({})", self.id())
-    }
+impl LuaType for bool {
+    const TYPE_ID: c_int = ffi::LUA_TBOOLEAN;
 }
 
-impl Hash for RegistryKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id().hash(state)
-    }
+impl LuaType for Number {
+    const TYPE_ID: c_int = ffi::LUA_TNUMBER;
 }
 
-impl PartialEq for RegistryKey {
-    fn eq(&self, other: &RegistryKey) -> bool {
-        self.id() == other.id() && Arc::ptr_eq(&self.unref_list, &other.unref_list)
-    }
+impl LuaType for LightUserData {
+    const TYPE_ID: c_int = ffi::LUA_TLIGHTUSERDATA;
 }
 
-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 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(registry_id);
-            }
-        }
-    }
-}
-
-impl 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: AtomicI32::new(id),
-            unref_list,
-        }
-    }
-
-    /// 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
-    }
-}
-
-pub(crate) struct LuaRef<'lua> {
-    pub(crate) lua: &'lua Lua,
-    pub(crate) index: c_int,
-    pub(crate) drop: bool,
-}
-
-impl<'lua> LuaRef<'lua> {
-    pub(crate) const fn new(lua: &'lua Lua, index: c_int) -> Self {
-        LuaRef {
-            lua,
-            index,
-            drop: true,
-        }
-    }
-
-    #[inline]
-    pub(crate) fn to_pointer(&self) -> *const c_void {
-        unsafe { ffi::lua_topointer(self.lua.ref_thread(), self.index) }
-    }
-
-    #[cfg(feature = "unstable")]
-    #[inline]
-    pub(crate) fn into_owned(self) -> LuaOwnedRef {
-        assert!(self.drop, "Cannot turn non-drop reference into owned");
-        let owned_ref = LuaOwnedRef::new(self.lua.clone(), self.index);
-        mem::forget(self);
-        owned_ref
-    }
-}
-
-impl<'lua> fmt::Debug for LuaRef<'lua> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Ref({:p})", self.to_pointer())
-    }
-}
-
-impl<'lua> Clone for LuaRef<'lua> {
-    fn clone(&self) -> Self {
-        self.lua.clone_ref(self)
-    }
-}
-
-impl<'lua> Drop for LuaRef<'lua> {
-    fn drop(&mut self) {
-        if self.drop {
-            self.lua.drop_ref_index(self.index);
-        }
-    }
-}
-
-impl<'lua> PartialEq for LuaRef<'lua> {
-    fn eq(&self, other: &Self) -> bool {
-        let ref_thread = self.lua.ref_thread();
-        assert!(
-            ref_thread == other.lua.ref_thread(),
-            "Lua instance passed Value created from a different main Lua state"
-        );
-        unsafe { ffi::lua_rawequal(ref_thread, self.index, other.index) == 1 }
-    }
-}
-
-#[cfg(feature = "unstable")]
-pub(crate) struct LuaOwnedRef {
-    pub(crate) inner: Arc<LuaInner>,
-    pub(crate) index: c_int,
-    _non_send: PhantomData<*const ()>,
-}
-
-#[cfg(feature = "unstable")]
-impl fmt::Debug for LuaOwnedRef {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "OwnedRef({:p})", self.to_ref().to_pointer())
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl Clone for LuaOwnedRef {
-    fn clone(&self) -> Self {
-        self.to_ref().clone().into_owned()
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl Drop for LuaOwnedRef {
-    fn drop(&mut self) {
-        let lua: &Lua = unsafe { mem::transmute(&self.inner) };
-        lua.drop_ref_index(self.index);
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl LuaOwnedRef {
-    pub(crate) const fn new(inner: Arc<LuaInner>, index: c_int) -> Self {
-        LuaOwnedRef {
-            inner,
-            index,
-            _non_send: PhantomData,
-        }
-    }
-
-    pub(crate) const fn to_ref(&self) -> LuaRef {
-        LuaRef {
-            lua: unsafe { mem::transmute(&self.inner) },
-            index: self.index,
-            drop: false,
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct AppData {
-    #[cfg(not(feature = "send"))]
-    container: UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any>>>>,
-    #[cfg(feature = "send")]
-    container: UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any + Send>>>>,
-    borrow: Cell<usize>,
-}
-
-impl AppData {
-    #[track_caller]
-    pub(crate) fn insert<T: MaybeSend + 'static>(&self, data: T) -> Option<T> {
-        match self.try_insert(data) {
-            Ok(data) => data,
-            Err(_) => panic!("cannot mutably borrow app data container"),
-        }
-    }
-
-    pub(crate) fn try_insert<T: MaybeSend + 'static>(&self, data: T) -> StdResult<Option<T>, T> {
-        if self.borrow.get() != 0 {
-            return Err(data);
-        }
-        // SAFETY: we checked that there are no other references to the container
-        Ok(unsafe { &mut *self.container.get() }
-            .insert(TypeId::of::<T>(), RefCell::new(Box::new(data)))
-            .and_then(|data| data.into_inner().downcast::<T>().ok().map(|data| *data)))
-    }
-
-    #[track_caller]
-    pub(crate) fn borrow<T: 'static>(&self) -> Option<AppDataRef<T>> {
-        let data = unsafe { &*self.container.get() }
-            .get(&TypeId::of::<T>())?
-            .borrow();
-        self.borrow.set(self.borrow.get() + 1);
-        Some(AppDataRef {
-            data: Ref::filter_map(data, |data| data.downcast_ref()).ok()?,
-            borrow: &self.borrow,
-        })
-    }
-
-    #[track_caller]
-    pub(crate) fn borrow_mut<T: 'static>(&self) -> Option<AppDataRefMut<T>> {
-        let data = unsafe { &*self.container.get() }
-            .get(&TypeId::of::<T>())?
-            .borrow_mut();
-        self.borrow.set(self.borrow.get() + 1);
-        Some(AppDataRefMut {
-            data: RefMut::filter_map(data, |data| data.downcast_mut()).ok()?,
-            borrow: &self.borrow,
-        })
-    }
-
-    #[track_caller]
-    pub(crate) fn remove<T: 'static>(&self) -> Option<T> {
-        if self.borrow.get() != 0 {
-            panic!("cannot mutably borrow app data container");
-        }
-        // SAFETY: we checked that there are no other references to the container
-        unsafe { &mut *self.container.get() }
-            .remove(&TypeId::of::<T>())?
-            .into_inner()
-            .downcast::<T>()
-            .ok()
-            .map(|data| *data)
-    }
-}
-
-/// A wrapper type for an immutably borrowed value from an app data container.
-///
-/// This type is similar to [`Ref`].
-pub struct AppDataRef<'a, T: ?Sized + 'a> {
-    data: Ref<'a, T>,
-    borrow: &'a Cell<usize>,
-}
-
-impl<T: ?Sized> Drop for AppDataRef<'_, T> {
-    fn drop(&mut self) {
-        self.borrow.set(self.borrow.get() - 1);
-    }
-}
-
-impl<T: ?Sized> Deref for AppDataRef<'_, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.data
-    }
-}
-
-impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRef<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRef<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-/// A wrapper type for a mutably borrowed value from an app data container.
-///
-/// This type is similar to [`RefMut`].
-pub struct AppDataRefMut<'a, T: ?Sized + 'a> {
-    data: RefMut<'a, T>,
-    borrow: &'a Cell<usize>,
-}
-
-impl<T: ?Sized> Drop for AppDataRefMut<'_, T> {
-    fn drop(&mut self) {
-        self.borrow.set(self.borrow.get() - 1);
-    }
-}
-
-impl<T: ?Sized> Deref for AppDataRefMut<'_, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.data
-    }
-}
-
-impl<T: ?Sized> DerefMut for AppDataRefMut<'_, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.data
-    }
-}
-
-impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRefMut<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRefMut<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
+mod app_data;
+mod registry_key;
+mod sync;
+mod value_ref;
 
 #[cfg(test)]
 mod assertions {
     use super::*;
 
-    static_assertions::assert_impl_all!(RegistryKey: Send, Sync);
-    static_assertions::assert_not_impl_any!(LuaRef: Send);
-
-    #[cfg(feature = "unstable")]
-    static_assertions::assert_not_impl_any!(LuaOwnedRef: Send);
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(ValueRef: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(ValueRef: Send, Sync);
 }

src/types/app_data.rs

@@ -0,0 +1,212 @@
+use std::any::{Any, TypeId};
+use std::cell::{BorrowError, BorrowMutError, Cell, Ref, RefCell, RefMut, UnsafeCell};
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+use std::result::Result as StdResult;
+
+use rustc_hash::FxHashMap;
+
+use super::MaybeSend;
+use crate::state::LuaGuard;
+
+#[cfg(not(feature = "send"))]
+type Container = UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any>>>>;
+
+#[cfg(feature = "send")]
+type Container = UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any + Send>>>>;
+
+/// A container for arbitrary data associated with the Lua state.
+#[derive(Debug, Default)]
+pub struct AppData {
+    container: Container,
+    borrow: Cell<usize>,
+}
+
+impl AppData {
+    #[track_caller]
+    pub(crate) fn insert<T: MaybeSend + 'static>(&self, data: T) -> Option<T> {
+        match self.try_insert(data) {
+            Ok(data) => data,
+            Err(_) => panic!("cannot mutably borrow app data container"),
+        }
+    }
+
+    pub(crate) fn try_insert<T: MaybeSend + 'static>(&self, data: T) -> StdResult<Option<T>, T> {
+        if self.borrow.get() != 0 {
+            return Err(data);
+        }
+        // SAFETY: we checked that there are no other references to the container
+        Ok(unsafe { &mut *self.container.get() }
+            .insert(TypeId::of::<T>(), RefCell::new(Box::new(data)))
+            .and_then(|data| data.into_inner().downcast::<T>().ok().map(|data| *data)))
+    }
+
+    #[inline]
+    #[track_caller]
+    pub(crate) fn borrow<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRef<T>> {
+        match self.try_borrow(guard) {
+            Ok(data) => data,
+            Err(err) => panic!("already mutably borrowed: {err:?}"),
+        }
+    }
+
+    pub(crate) fn try_borrow<T: 'static>(
+        &self,
+        guard: Option<LuaGuard>,
+    ) -> Result<Option<AppDataRef<T>>, BorrowError> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())
+            .map(|c| c.try_borrow())
+            .transpose()?
+            .and_then(|data| Ref::filter_map(data, |data| data.downcast_ref()).ok());
+        match data {
+            Some(data) => {
+                self.borrow.set(self.borrow.get() + 1);
+                Ok(Some(AppDataRef {
+                    data,
+                    borrow: &self.borrow,
+                    _guard: guard,
+                }))
+            }
+            None => Ok(None),
+        }
+    }
+
+    #[inline]
+    #[track_caller]
+    pub(crate) fn borrow_mut<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRefMut<T>> {
+        match self.try_borrow_mut(guard) {
+            Ok(data) => data,
+            Err(err) => panic!("already borrowed: {err:?}"),
+        }
+    }
+
+    pub(crate) fn try_borrow_mut<T: 'static>(
+        &self,
+        guard: Option<LuaGuard>,
+    ) -> Result<Option<AppDataRefMut<T>>, BorrowMutError> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())
+            .map(|c| c.try_borrow_mut())
+            .transpose()?
+            .and_then(|data| RefMut::filter_map(data, |data| data.downcast_mut()).ok());
+        match data {
+            Some(data) => {
+                self.borrow.set(self.borrow.get() + 1);
+                Ok(Some(AppDataRefMut {
+                    data,
+                    borrow: &self.borrow,
+                    _guard: guard,
+                }))
+            }
+            None => Ok(None),
+        }
+    }
+
+    #[track_caller]
+    pub(crate) fn remove<T: 'static>(&self) -> Option<T> {
+        if self.borrow.get() != 0 {
+            panic!("cannot mutably borrow app data container");
+        }
+        // SAFETY: we checked that there are no other references to the container
+        unsafe { &mut *self.container.get() }
+            .remove(&TypeId::of::<T>())?
+            .into_inner()
+            .downcast::<T>()
+            .ok()
+            .map(|data| *data)
+    }
+}
+
+/// A wrapper type for an immutably borrowed value from an app data container.
+///
+/// This type is similar to [`Ref`].
+pub struct AppDataRef<'a, T: ?Sized + 'a> {
+    data: Ref<'a, T>,
+    borrow: &'a Cell<usize>,
+    _guard: Option<LuaGuard>,
+}
+
+impl<T: ?Sized> Drop for AppDataRef<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRef<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+/// A wrapper type for a mutably borrowed value from an app data container.
+///
+/// This type is similar to [`RefMut`].
+pub struct AppDataRefMut<'a, T: ?Sized + 'a> {
+    data: RefMut<'a, T>,
+    borrow: &'a Cell<usize>,
+    _guard: Option<LuaGuard>,
+}
+
+impl<T: ?Sized> Drop for AppDataRefMut<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRefMut<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized> DerefMut for AppDataRefMut<'_, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(AppData: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(AppData: Send);
+
+    // Must be !Send
+    static_assertions::assert_not_impl_any!(AppDataRef<()>: Send);
+    static_assertions::assert_not_impl_any!(AppDataRefMut<()>: Send);
+}

src/types/registry_key.rs

@@ -0,0 +1,100 @@
+use std::hash::{Hash, Hasher};
+use std::os::raw::c_int;
+use std::sync::Arc;
+use std::{fmt, mem, ptr};
+
+use parking_lot::Mutex;
+
+/// An auto generated key into the Lua registry.
+///
+/// This is a handle to a value stored inside the Lua registry. It is not automatically
+/// garbage collected on Drop, but it can be removed with [`Lua::remove_registry_value`],
+/// and instances not manually removed can be garbage collected with
+/// [`Lua::expire_registry_values`].
+///
+/// Be warned, If you place this into Lua via a [`UserData`] type or a Rust callback, it is *easy*
+/// to accidentally cause reference cycles that the Lua garbage collector cannot resolve. Instead of
+/// placing a [`RegistryKey`] into a [`UserData`] type, consider to use
+/// [`AnyUserData::set_user_value`].
+///
+/// [`UserData`]: crate::UserData
+/// [`RegistryKey`]: crate::RegistryKey
+/// [`Lua::remove_registry_value`]: crate::Lua::remove_registry_value
+/// [`Lua::expire_registry_values`]: crate::Lua::expire_registry_values
+/// [`AnyUserData::set_user_value`]: crate::AnyUserData::set_user_value
+pub struct RegistryKey {
+    pub(crate) registry_id: i32,
+    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.id())
+    }
+}
+
+impl Hash for RegistryKey {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.id().hash(state)
+    }
+}
+
+impl PartialEq for RegistryKey {
+    fn eq(&self, other: &RegistryKey) -> bool {
+        self.id() == other.id() && Arc::ptr_eq(&self.unref_list, &other.unref_list)
+    }
+}
+
+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 registry_id > ffi::LUA_REFNIL {
+            let mut unref_list = self.unref_list.lock();
+            if let Some(list) = unref_list.as_mut() {
+                list.push(registry_id);
+            }
+        }
+    }
+}
+
+impl 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,
+            unref_list,
+        }
+    }
+
+    /// Returns the underlying Lua reference of this `RegistryKey`
+    #[inline(always)]
+    pub fn id(&self) -> c_int {
+        self.registry_id
+    }
+
+    /// Sets the unique Lua reference key of this `RegistryKey`
+    #[inline(always)]
+    pub(crate) fn set_id(&mut self, id: c_int) {
+        self.registry_id = id;
+    }
+
+    /// 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
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_impl_all!(RegistryKey: Send, Sync);
+}

src/types/sync.rs

@@ -0,0 +1,77 @@
+#[cfg(feature = "send")]
+mod inner {
+    use parking_lot::{RawMutex, RawThreadId};
+    use std::sync::{Arc, Weak};
+
+    pub(crate) type XRc<T> = Arc<T>;
+    pub(crate) type XWeak<T> = Weak<T>;
+
+    pub(crate) type ReentrantMutex<T> = parking_lot::ReentrantMutex<T>;
+
+    pub(crate) type ReentrantMutexGuard<'a, T> = parking_lot::ReentrantMutexGuard<'a, T>;
+
+    pub(crate) type ArcReentrantMutexGuard<T> =
+        parking_lot::lock_api::ArcReentrantMutexGuard<RawMutex, RawThreadId, T>;
+}
+
+#[cfg(not(feature = "send"))]
+mod inner {
+    use std::ops::Deref;
+    use std::rc::{Rc, Weak};
+
+    pub(crate) type XRc<T> = Rc<T>;
+    pub(crate) type XWeak<T> = Weak<T>;
+
+    pub(crate) struct ReentrantMutex<T>(T);
+
+    impl<T> ReentrantMutex<T> {
+        #[inline(always)]
+        pub(crate) fn new(val: T) -> Self {
+            ReentrantMutex(val)
+        }
+
+        #[inline(always)]
+        pub(crate) fn lock(&self) -> ReentrantMutexGuard<T> {
+            ReentrantMutexGuard(&self.0)
+        }
+
+        #[inline(always)]
+        pub(crate) fn lock_arc(self: &XRc<Self>) -> ArcReentrantMutexGuard<T> {
+            ArcReentrantMutexGuard(Rc::clone(self))
+        }
+
+        #[inline(always)]
+        pub(crate) fn into_lock_arc(self: XRc<Self>) -> ArcReentrantMutexGuard<T> {
+            ArcReentrantMutexGuard(self)
+        }
+
+        #[inline(always)]
+        pub(crate) fn data_ptr(&self) -> *const T {
+            &self.0 as *const _
+        }
+    }
+
+    pub(crate) struct ReentrantMutexGuard<'a, T>(&'a T);
+
+    impl<T> Deref for ReentrantMutexGuard<'_, T> {
+        type Target = T;
+
+        #[inline(always)]
+        fn deref(&self) -> &Self::Target {
+            self.0
+        }
+    }
+
+    pub(crate) struct ArcReentrantMutexGuard<T>(XRc<ReentrantMutex<T>>);
+
+    impl<T> Deref for ArcReentrantMutexGuard<T> {
+        type Target = T;
+
+        #[inline(always)]
+        fn deref(&self) -> &Self::Target {
+            &self.0 .0
+        }
+    }
+}
+
+pub(crate) use inner::{ArcReentrantMutexGuard, ReentrantMutex, ReentrantMutexGuard, XRc, XWeak};

src/types/value_ref.rs

@@ -0,0 +1,71 @@
+use std::fmt;
+use std::os::raw::{c_int, c_void};
+
+use crate::state::{RawLua, WeakLua};
+
+/// A reference to a Lua (complex) value stored in the Lua auxiliary thread.
+pub struct ValueRef {
+    pub(crate) lua: WeakLua,
+    pub(crate) index: c_int,
+    pub(crate) drop: bool,
+}
+
+impl ValueRef {
+    #[inline]
+    pub(crate) fn new(lua: &RawLua, index: c_int) -> Self {
+        ValueRef {
+            lua: lua.weak().clone(),
+            index,
+            drop: true,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn to_pointer(&self) -> *const c_void {
+        let lua = self.lua.lock();
+        unsafe { ffi::lua_topointer(lua.ref_thread(), self.index) }
+    }
+
+    /// Returns a copy of the value, which is valid as long as the original value is held.
+    #[inline]
+    pub(crate) fn copy(&self) -> Self {
+        ValueRef {
+            lua: self.lua.clone(),
+            index: self.index,
+            drop: false,
+        }
+    }
+}
+
+impl fmt::Debug for ValueRef {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Ref({:p})", self.to_pointer())
+    }
+}
+
+impl Clone for ValueRef {
+    fn clone(&self) -> Self {
+        unsafe { self.lua.lock().clone_ref(self) }
+    }
+}
+
+impl Drop for ValueRef {
+    fn drop(&mut self) {
+        if self.drop {
+            if let Some(lua) = self.lua.try_lock() {
+                unsafe { lua.drop_ref(self) };
+            }
+        }
+    }
+}
+
+impl PartialEq for ValueRef {
+    fn eq(&self, other: &Self) -> bool {
+        assert!(
+            self.lua == other.lua,
+            "Lua instance passed Value created from a different main Lua state"
+        );
+        let lua = self.lua.lock();
+        unsafe { ffi::lua_rawequal(lua.ref_thread(), self.index, other.index) == 1 }
+    }
+}

src/userdata/cell.rs

@@ -0,0 +1,298 @@
+use std::cell::{RefCell, UnsafeCell};
+
+#[cfg(feature = "serialize")]
+use serde::ser::{Serialize, Serializer};
+
+use crate::error::{Error, Result};
+use crate::types::XRc;
+
+use super::lock::{RawLock, UserDataLock};
+use super::r#ref::{UserDataRef, UserDataRefMut};
+
+#[cfg(all(feature = "serialize", not(feature = "send")))]
+type DynSerialize = dyn erased_serde::Serialize;
+
+#[cfg(all(feature = "serialize", feature = "send"))]
+type DynSerialize = dyn erased_serde::Serialize + Send;
+
+pub(crate) enum UserDataStorage<T> {
+    Owned(UserDataVariant<T>),
+    Scoped(ScopedUserDataVariant<T>),
+}
+
+// A enum for storing userdata values.
+// It's stored inside a Lua VM and protected by the outer `ReentrantMutex`.
+pub(crate) enum UserDataVariant<T> {
+    Default(XRc<UserDataCell<T>>),
+    #[cfg(feature = "serialize")]
+    Serializable(XRc<UserDataCell<Box<DynSerialize>>>, bool), // bool is `is_sync`
+}
+
+impl<T> Clone for UserDataVariant<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        match self {
+            Self::Default(inner) => Self::Default(XRc::clone(inner)),
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner, is_sync) => Self::Serializable(XRc::clone(inner), *is_sync),
+        }
+    }
+}
+
+impl<T> UserDataVariant<T> {
+    #[inline(always)]
+    pub(super) fn try_borrow_scoped<R>(&self, f: impl FnOnce(&T) -> R) -> Result<R> {
+        // We don't need to check for `T: Sync` because when this method is used (internally),
+        // Lua mutex is already locked.
+        // If non-`Sync` userdata is already borrowed by another thread (via `UserDataRef`), it will be
+        // exclusively locked.
+        let _guard = (self.raw_lock().try_lock_shared_guarded()).map_err(|_| Error::UserDataBorrowError)?;
+        Ok(f(unsafe { &*self.as_ptr() }))
+    }
+
+    // Mutably borrows the wrapped value in-place.
+    #[inline(always)]
+    fn try_borrow_scoped_mut<R>(&self, f: impl FnOnce(&mut T) -> R) -> Result<R> {
+        let _guard =
+            (self.raw_lock().try_lock_exclusive_guarded()).map_err(|_| Error::UserDataBorrowMutError)?;
+        Ok(f(unsafe { &mut *self.as_ptr() }))
+    }
+
+    // Immutably borrows the wrapped value and returns an owned reference.
+    #[inline(always)]
+    fn try_borrow_owned(&self) -> Result<UserDataRef<T>> {
+        UserDataRef::try_from(self.clone())
+    }
+
+    // Mutably borrows the wrapped value and returns an owned reference.
+    #[inline(always)]
+    fn try_borrow_owned_mut(&self) -> Result<UserDataRefMut<T>> {
+        UserDataRefMut::try_from(self.clone())
+    }
+
+    // Returns the wrapped value.
+    //
+    // This method checks that we have exclusive access to the value.
+    fn into_inner(self) -> Result<T> {
+        if !self.raw_lock().try_lock_exclusive() {
+            return Err(Error::UserDataBorrowMutError);
+        }
+        Ok(match self {
+            Self::Default(inner) => XRc::into_inner(inner).unwrap().value.into_inner(),
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner, _) => unsafe {
+                let raw = Box::into_raw(XRc::into_inner(inner).unwrap().value.into_inner());
+                *Box::from_raw(raw as *mut T)
+            },
+        })
+    }
+
+    #[inline(always)]
+    fn strong_count(&self) -> usize {
+        match self {
+            Self::Default(inner) => XRc::strong_count(inner),
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner, _) => XRc::strong_count(inner),
+        }
+    }
+
+    #[inline(always)]
+    pub(super) fn raw_lock(&self) -> &RawLock {
+        match self {
+            Self::Default(inner) => &inner.raw_lock,
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner, _) => &inner.raw_lock,
+        }
+    }
+
+    #[inline(always)]
+    pub(super) fn as_ptr(&self) -> *mut T {
+        match self {
+            Self::Default(inner) => inner.value.get(),
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner, _) => unsafe { &mut **(inner.value.get() as *mut Box<T>) },
+        }
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl Serialize for UserDataStorage<()> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        match self {
+            Self::Owned(variant @ UserDataVariant::Serializable(inner, is_sync)) => unsafe {
+                #[cfg(feature = "send")]
+                if *is_sync {
+                    let _guard = (variant.raw_lock().try_lock_shared_guarded())
+                        .map_err(|_| serde::ser::Error::custom(Error::UserDataBorrowError))?;
+                    (*inner.value.get()).serialize(serializer)
+                } else {
+                    let _guard = (variant.raw_lock().try_lock_exclusive_guarded())
+                        .map_err(|_| serde::ser::Error::custom(Error::UserDataBorrowError))?;
+                    (*inner.value.get()).serialize(serializer)
+                }
+                #[cfg(not(feature = "send"))]
+                {
+                    let _ = is_sync;
+                    let _guard = (variant.raw_lock().try_lock_shared_guarded())
+                        .map_err(|_| serde::ser::Error::custom(Error::UserDataBorrowError))?;
+                    (*inner.value.get()).serialize(serializer)
+                }
+            },
+            _ => Err(serde::ser::Error::custom("cannot serialize <userdata>")),
+        }
+    }
+}
+
+/// A type that provides interior mutability for a userdata value (thread-safe).
+pub(crate) struct UserDataCell<T> {
+    raw_lock: RawLock,
+    value: UnsafeCell<T>,
+}
+
+#[cfg(feature = "send")]
+unsafe impl<T: Send> Send for UserDataCell<T> {}
+#[cfg(feature = "send")]
+unsafe impl<T: Send> Sync for UserDataCell<T> {}
+
+impl<T> UserDataCell<T> {
+    #[inline(always)]
+    fn new(value: T) -> Self {
+        UserDataCell {
+            raw_lock: RawLock::INIT,
+            value: UnsafeCell::new(value),
+        }
+    }
+}
+
+pub(crate) enum ScopedUserDataVariant<T> {
+    Ref(*const T),
+    RefMut(RefCell<*mut T>),
+    Boxed(RefCell<*mut T>),
+}
+
+impl<T> Drop for ScopedUserDataVariant<T> {
+    #[inline]
+    fn drop(&mut self) {
+        if let Self::Boxed(value) = self {
+            if let Ok(value) = value.try_borrow_mut() {
+                unsafe { drop(Box::from_raw(*value)) };
+            }
+        }
+    }
+}
+
+impl<T: 'static> UserDataStorage<T> {
+    #[inline(always)]
+    pub(crate) fn new(data: T) -> Self {
+        Self::Owned(UserDataVariant::Default(XRc::new(UserDataCell::new(data))))
+    }
+
+    #[inline(always)]
+    pub(crate) fn new_ref(data: &T) -> Self {
+        Self::Scoped(ScopedUserDataVariant::Ref(data))
+    }
+
+    #[inline(always)]
+    pub(crate) fn new_ref_mut(data: &mut T) -> Self {
+        Self::Scoped(ScopedUserDataVariant::RefMut(RefCell::new(data)))
+    }
+
+    #[cfg(feature = "serialize")]
+    #[inline(always)]
+    pub(crate) fn new_ser(data: T) -> Self
+    where
+        T: Serialize + crate::types::MaybeSend,
+    {
+        let data = Box::new(data) as Box<DynSerialize>;
+        let is_sync = super::util::is_sync::<T>();
+        let variant = UserDataVariant::Serializable(XRc::new(UserDataCell::new(data)), is_sync);
+        Self::Owned(variant)
+    }
+
+    #[cfg(feature = "serialize")]
+    #[inline(always)]
+    pub(crate) fn is_serializable(&self) -> bool {
+        matches!(self, Self::Owned(UserDataVariant::Serializable(..)))
+    }
+
+    // Immutably borrows the wrapped value and returns an owned reference.
+    #[inline(always)]
+    pub(crate) fn try_borrow_owned(&self) -> Result<UserDataRef<T>> {
+        match self {
+            Self::Owned(data) => data.try_borrow_owned(),
+            Self::Scoped(_) => Err(Error::UserDataTypeMismatch),
+        }
+    }
+
+    // Mutably borrows the wrapped value and returns an owned reference.
+    #[inline(always)]
+    pub(crate) fn try_borrow_owned_mut(&self) -> Result<UserDataRefMut<T>> {
+        match self {
+            Self::Owned(data) => data.try_borrow_owned_mut(),
+            Self::Scoped(_) => Err(Error::UserDataTypeMismatch),
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn into_inner(self) -> Result<T> {
+        match self {
+            Self::Owned(data) => data.into_inner(),
+            Self::Scoped(_) => Err(Error::UserDataTypeMismatch),
+        }
+    }
+}
+
+impl<T> UserDataStorage<T> {
+    #[inline(always)]
+    pub(crate) fn new_scoped(data: T) -> Self {
+        let data = Box::into_raw(Box::new(data));
+        Self::Scoped(ScopedUserDataVariant::Boxed(RefCell::new(data)))
+    }
+
+    /// Returns `true` if it's safe to destroy the container.
+    ///
+    /// It's safe to destroy the container if the reference count is greater than 1 or the lock is
+    /// not acquired.
+    #[inline(always)]
+    pub(crate) fn is_safe_to_destroy(&self) -> bool {
+        match self {
+            Self::Owned(variant) => variant.strong_count() > 1 || !variant.raw_lock().is_locked(),
+            Self::Scoped(_) => false,
+        }
+    }
+
+    /// Returns `true` if the container has exclusive access to the value.
+    #[inline(always)]
+    pub(crate) fn has_exclusive_access(&self) -> bool {
+        match self {
+            Self::Owned(variant) => !variant.raw_lock().is_locked(),
+            Self::Scoped(_) => false,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn try_borrow_scoped<R>(&self, f: impl FnOnce(&T) -> R) -> Result<R> {
+        match self {
+            Self::Owned(data) => data.try_borrow_scoped(f),
+            Self::Scoped(ScopedUserDataVariant::Ref(value)) => Ok(f(unsafe { &**value })),
+            Self::Scoped(ScopedUserDataVariant::RefMut(value) | ScopedUserDataVariant::Boxed(value)) => {
+                let t = value.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
+                Ok(f(unsafe { &**t }))
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate) fn try_borrow_scoped_mut<R>(&self, f: impl FnOnce(&mut T) -> R) -> Result<R> {
+        match self {
+            Self::Owned(data) => data.try_borrow_scoped_mut(f),
+            Self::Scoped(ScopedUserDataVariant::Ref(_)) => Err(Error::UserDataBorrowMutError),
+            Self::Scoped(ScopedUserDataVariant::RefMut(value) | ScopedUserDataVariant::Boxed(value)) => {
+                let mut t = value
+                    .try_borrow_mut()
+                    .map_err(|_| Error::UserDataBorrowMutError)?;
+                Ok(f(unsafe { &mut **t }))
+            }
+        }
+    }
+}

src/userdata/lock.rs

@@ -0,0 +1,144 @@
+pub(crate) trait UserDataLock {
+    const INIT: Self;
+
+    fn is_locked(&self) -> bool;
+    fn try_lock_shared(&self) -> bool;
+    fn try_lock_exclusive(&self) -> bool;
+
+    unsafe fn unlock_shared(&self);
+    unsafe fn unlock_exclusive(&self);
+
+    fn try_lock_shared_guarded(&self) -> Result<LockGuard<'_, Self>, ()> {
+        if self.try_lock_shared() {
+            Ok(LockGuard {
+                lock: self,
+                exclusive: false,
+            })
+        } else {
+            Err(())
+        }
+    }
+
+    fn try_lock_exclusive_guarded(&self) -> Result<LockGuard<'_, Self>, ()> {
+        if self.try_lock_exclusive() {
+            Ok(LockGuard {
+                lock: self,
+                exclusive: true,
+            })
+        } else {
+            Err(())
+        }
+    }
+}
+
+pub(crate) struct LockGuard<'a, L: UserDataLock + ?Sized> {
+    lock: &'a L,
+    exclusive: bool,
+}
+
+impl<L: UserDataLock + ?Sized> Drop for LockGuard<'_, L> {
+    fn drop(&mut self) {
+        unsafe {
+            if self.exclusive {
+                self.lock.unlock_exclusive();
+            } else {
+                self.lock.unlock_shared();
+            }
+        }
+    }
+}
+
+pub(crate) use lock_impl::RawLock;
+
+#[cfg(not(feature = "send"))]
+#[cfg(not(tarpaulin_include))]
+mod lock_impl {
+    use std::cell::Cell;
+
+    // Positive values represent the number of read references.
+    // Negative values represent the number of write references (only one allowed).
+    pub(crate) type RawLock = Cell<isize>;
+
+    const UNUSED: isize = 0;
+
+    impl super::UserDataLock for RawLock {
+        #[allow(clippy::declare_interior_mutable_const)]
+        const INIT: Self = Cell::new(UNUSED);
+
+        #[inline(always)]
+        fn is_locked(&self) -> bool {
+            self.get() != UNUSED
+        }
+
+        #[inline(always)]
+        fn try_lock_shared(&self) -> bool {
+            let flag = self.get().wrapping_add(1);
+            if flag <= UNUSED {
+                return false;
+            }
+            self.set(flag);
+            true
+        }
+
+        #[inline(always)]
+        fn try_lock_exclusive(&self) -> bool {
+            let flag = self.get();
+            if flag != UNUSED {
+                return false;
+            }
+            self.set(UNUSED - 1);
+            true
+        }
+
+        #[inline(always)]
+        unsafe fn unlock_shared(&self) {
+            let flag = self.get();
+            debug_assert!(flag > UNUSED);
+            self.set(flag - 1);
+        }
+
+        #[inline(always)]
+        unsafe fn unlock_exclusive(&self) {
+            let flag = self.get();
+            debug_assert!(flag < UNUSED);
+            self.set(flag + 1);
+        }
+    }
+}
+
+#[cfg(feature = "send")]
+mod lock_impl {
+    use parking_lot::lock_api::RawRwLock;
+
+    pub(crate) type RawLock = parking_lot::RawRwLock;
+
+    impl super::UserDataLock for RawLock {
+        #[allow(clippy::declare_interior_mutable_const)]
+        const INIT: Self = <Self as parking_lot::lock_api::RawRwLock>::INIT;
+
+        #[inline(always)]
+        fn is_locked(&self) -> bool {
+            RawRwLock::is_locked(self)
+        }
+
+        #[inline(always)]
+        fn try_lock_shared(&self) -> bool {
+            RawRwLock::try_lock_shared(self)
+        }
+
+        #[inline(always)]
+        fn try_lock_exclusive(&self) -> bool {
+            RawRwLock::try_lock_exclusive(self)
+        }
+
+        #[inline(always)]
+        unsafe fn unlock_shared(&self) {
+            RawRwLock::unlock_shared(self)
+        }
+
+        #[inline(always)]
+        unsafe fn unlock_exclusive(&self) {
+            RawRwLock::unlock_exclusive(self)
+        }
+    }
+}

src/userdata/object.rs

@@ -0,0 +1,93 @@
+use std::string::String as StdString;
+
+use crate::error::{Error, Result};
+use crate::table::Table;
+use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, ObjectLike};
+use crate::userdata::AnyUserData;
+use crate::value::Value;
+use crate::Function;
+
+#[cfg(feature = "async")]
+use futures_util::future::{self, Either, Future};
+
+impl ObjectLike for AnyUserData {
+    #[inline]
+    fn get<V: FromLua>(&self, key: impl IntoLua) -> Result<V> {
+        // `lua_gettable` method used under the hood can work with any Lua value
+        // that has `__index` metamethod
+        Table(self.0.copy()).get_protected(key)
+    }
+
+    #[inline]
+    fn set(&self, key: impl IntoLua, value: impl IntoLua) -> Result<()> {
+        // `lua_settable` method used under the hood can work with any Lua value
+        // that has `__newindex` metamethod
+        Table(self.0.copy()).set_protected(key, value)
+    }
+
+    #[inline]
+    fn call<R>(&self, args: impl IntoLuaMulti) -> Result<R>
+    where
+        R: FromLuaMulti,
+    {
+        Function(self.0.copy()).call(args)
+    }
+
+    #[cfg(feature = "async")]
+    #[inline]
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    where
+        R: FromLuaMulti,
+    {
+        Function(self.0.copy()).call_async(args)
+    }
+
+    #[inline]
+    fn call_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> Result<R>
+    where
+        R: FromLuaMulti,
+    {
+        self.call_function(name, (self, args))
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    where
+        R: FromLuaMulti,
+    {
+        self.call_async_function(name, (self, args))
+    }
+
+    fn call_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> Result<R>
+    where
+        R: FromLuaMulti,
+    {
+        match self.get(name)? {
+            Value::Function(func) => func.call(args),
+            val => {
+                let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
+                Err(Error::RuntimeError(msg))
+            }
+        }
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>>
+    where
+        R: FromLuaMulti,
+    {
+        match self.get(name) {
+            Ok(Value::Function(func)) => Either::Left(func.call_async(args)),
+            Ok(val) => {
+                let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
+                Either::Right(future::ready(Err(Error::RuntimeError(msg))))
+            }
+            Err(err) => Either::Right(future::ready(Err(err))),
+        }
+    }
+
+    #[inline]
+    fn to_string(&self) -> Result<StdString> {
+        Value::UserData(AnyUserData(self.0.copy())).to_string()
+    }
+}

src/userdata/ref.rs

@@ -0,0 +1,474 @@
+use std::any::{type_name, TypeId};
+use std::ops::{Deref, DerefMut};
+use std::os::raw::c_int;
+use std::{fmt, mem};
+
+use crate::error::{Error, Result};
+use crate::state::{Lua, RawLua};
+use crate::traits::FromLua;
+use crate::userdata::AnyUserData;
+use crate::util::get_userdata;
+use crate::value::Value;
+
+use super::cell::{UserDataStorage, UserDataVariant};
+use super::lock::{LockGuard, RawLock, UserDataLock};
+use super::util::is_sync;
+
+#[cfg(feature = "userdata-wrappers")]
+use {
+    parking_lot::{
+        Mutex as MutexPL, MutexGuard as MutexGuardPL, RwLock as RwLockPL,
+        RwLockReadGuard as RwLockReadGuardPL, RwLockWriteGuard as RwLockWriteGuardPL,
+    },
+    std::sync::Arc,
+};
+#[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+use {
+    std::cell::{Ref, RefCell, RefMut},
+    std::rc::Rc,
+};
+
+/// A wrapper type for a userdata value that provides read access.
+///
+/// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
+pub struct UserDataRef<T: 'static> {
+    // It's important to drop the guard first, as it refers to the `inner` data.
+    _guard: LockGuard<'static, RawLock>,
+    inner: UserDataRefInner<T>,
+}
+
+impl<T> Deref for UserDataRef<T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        &self.inner
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for UserDataRef<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for UserDataRef<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T> TryFrom<UserDataVariant<T>> for UserDataRef<T> {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(variant: UserDataVariant<T>) -> Result<Self> {
+        let guard = if !cfg!(feature = "send") || is_sync::<T>() {
+            variant.raw_lock().try_lock_shared_guarded()
+        } else {
+            variant.raw_lock().try_lock_exclusive_guarded()
+        };
+        let guard = guard.map_err(|_| Error::UserDataBorrowError)?;
+        let guard = unsafe { mem::transmute::<LockGuard<_>, LockGuard<'static, _>>(guard) };
+        Ok(UserDataRef::from_parts(UserDataRefInner::Default(variant), guard))
+    }
+}
+
+impl<T: 'static> FromLua for UserDataRef<T> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
+        try_value_to_userdata::<T>(value)?.borrow()
+    }
+
+    #[inline]
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        Self::borrow_from_stack(lua, lua.state(), idx)
+    }
+}
+
+impl<T: 'static> UserDataRef<T> {
+    #[inline(always)]
+    fn from_parts(inner: UserDataRefInner<T>, guard: LockGuard<'static, RawLock>) -> Self {
+        Self { _guard: guard, inner }
+    }
+
+    #[cfg(feature = "userdata-wrappers")]
+    fn remap<U>(
+        self,
+        f: impl FnOnce(UserDataVariant<T>) -> Result<UserDataRefInner<U>>,
+    ) -> Result<UserDataRef<U>> {
+        match &self.inner {
+            UserDataRefInner::Default(variant) => {
+                let inner = f(variant.clone())?;
+                Ok(UserDataRef::from_parts(inner, self._guard))
+            }
+            _ => Err(Error::UserDataTypeMismatch),
+        }
+    }
+
+    pub(crate) unsafe fn borrow_from_stack(
+        lua: &RawLua,
+        state: *mut ffi::lua_State,
+        idx: c_int,
+    ) -> Result<Self> {
+        let type_id = lua.get_userdata_type_id::<T>(state, idx)?;
+        match type_id {
+            Some(type_id) if type_id == TypeId::of::<T>() => {
+                let ud = get_userdata::<UserDataStorage<T>>(state, idx);
+                (*ud).try_borrow_owned()
+            }
+
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Some(type_id) if type_id == TypeId::of::<Rc<T>>() => {
+                let ud = get_userdata::<UserDataStorage<Rc<T>>>(state, idx);
+                ((*ud).try_borrow_owned()).and_then(|ud| ud.transform_rc())
+            }
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Some(type_id) if type_id == TypeId::of::<Rc<RefCell<T>>>() => {
+                let ud = get_userdata::<UserDataStorage<Rc<RefCell<T>>>>(state, idx);
+                ((*ud).try_borrow_owned()).and_then(|ud| ud.transform_rc_refcell())
+            }
+
+            #[cfg(feature = "userdata-wrappers")]
+            Some(type_id) if type_id == TypeId::of::<Arc<T>>() => {
+                let ud = get_userdata::<UserDataStorage<Arc<T>>>(state, idx);
+                ((*ud).try_borrow_owned()).and_then(|ud| ud.transform_arc())
+            }
+            #[cfg(feature = "userdata-wrappers")]
+            Some(type_id) if type_id == TypeId::of::<Arc<MutexPL<T>>>() => {
+                let ud = get_userdata::<UserDataStorage<Arc<MutexPL<T>>>>(state, idx);
+                ((*ud).try_borrow_owned()).and_then(|ud| ud.transform_arc_mutex_pl())
+            }
+            #[cfg(feature = "userdata-wrappers")]
+            Some(type_id) if type_id == TypeId::of::<Arc<RwLockPL<T>>>() => {
+                let ud = get_userdata::<UserDataStorage<Arc<RwLockPL<T>>>>(state, idx);
+                ((*ud).try_borrow_owned()).and_then(|ud| ud.transform_arc_rwlock_pl())
+            }
+            _ => Err(Error::UserDataTypeMismatch),
+        }
+    }
+}
+
+#[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+impl<T> UserDataRef<Rc<T>> {
+    fn transform_rc(self) -> Result<UserDataRef<T>> {
+        self.remap(|variant| Ok(UserDataRefInner::Rc(variant)))
+    }
+}
+
+#[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+impl<T> UserDataRef<Rc<RefCell<T>>> {
+    fn transform_rc_refcell(self) -> Result<UserDataRef<T>> {
+        self.remap(|variant| unsafe {
+            let obj = &*variant.as_ptr();
+            let r#ref = obj.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
+            let borrow = std::mem::transmute::<Ref<T>, Ref<'static, T>>(r#ref);
+            Ok(UserDataRefInner::RcRefCell(borrow, variant))
+        })
+    }
+}
+
+#[cfg(feature = "userdata-wrappers")]
+impl<T> UserDataRef<Arc<T>> {
+    fn transform_arc(self) -> Result<UserDataRef<T>> {
+        self.remap(|variant| Ok(UserDataRefInner::Arc(variant)))
+    }
+}
+
+#[cfg(feature = "userdata-wrappers")]
+impl<T> UserDataRef<Arc<MutexPL<T>>> {
+    fn transform_arc_mutex_pl(self) -> Result<UserDataRef<T>> {
+        self.remap(|variant| unsafe {
+            let obj = &*variant.as_ptr();
+            let guard = obj.try_lock().ok_or(Error::UserDataBorrowError)?;
+            let borrow = std::mem::transmute::<MutexGuardPL<T>, MutexGuardPL<'static, T>>(guard);
+            Ok(UserDataRefInner::ArcMutexPL(borrow, variant))
+        })
+    }
+}
+
+#[cfg(feature = "userdata-wrappers")]
+impl<T> UserDataRef<Arc<RwLockPL<T>>> {
+    fn transform_arc_rwlock_pl(self) -> Result<UserDataRef<T>> {
+        self.remap(|variant| unsafe {
+            let obj = &*variant.as_ptr();
+            let guard = obj.try_read().ok_or(Error::UserDataBorrowError)?;
+            let borrow = std::mem::transmute::<RwLockReadGuardPL<T>, RwLockReadGuardPL<'static, T>>(guard);
+            Ok(UserDataRefInner::ArcRwLockPL(borrow, variant))
+        })
+    }
+}
+
+#[allow(unused)]
+enum UserDataRefInner<T: 'static> {
+    Default(UserDataVariant<T>),
+
+    #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+    Rc(UserDataVariant<Rc<T>>),
+    #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+    RcRefCell(Ref<'static, T>, UserDataVariant<Rc<RefCell<T>>>),
+
+    #[cfg(feature = "userdata-wrappers")]
+    Arc(UserDataVariant<Arc<T>>),
+    #[cfg(feature = "userdata-wrappers")]
+    ArcMutexPL(MutexGuardPL<'static, T>, UserDataVariant<Arc<MutexPL<T>>>),
+    #[cfg(feature = "userdata-wrappers")]
+    ArcRwLockPL(RwLockReadGuardPL<'static, T>, UserDataVariant<Arc<RwLockPL<T>>>),
+}
+
+impl<T> Deref for UserDataRefInner<T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        match self {
+            Self::Default(inner) => unsafe { &*inner.as_ptr() },
+
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Self::Rc(inner) => unsafe { &*Rc::as_ptr(&*inner.as_ptr()) },
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Self::RcRefCell(x, ..) => x,
+
+            #[cfg(feature = "userdata-wrappers")]
+            Self::Arc(inner) => unsafe { &*Arc::as_ptr(&*inner.as_ptr()) },
+            #[cfg(feature = "userdata-wrappers")]
+            Self::ArcMutexPL(x, ..) => x,
+            #[cfg(feature = "userdata-wrappers")]
+            Self::ArcRwLockPL(x, ..) => x,
+        }
+    }
+}
+
+/// A wrapper type for a userdata value that provides read and write access.
+///
+/// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
+pub struct UserDataRefMut<T: 'static> {
+    // It's important to drop the guard first, as it refers to the `inner` data.
+    _guard: LockGuard<'static, RawLock>,
+    inner: UserDataRefMutInner<T>,
+}
+
+impl<T> Deref for UserDataRefMut<T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for UserDataRefMut<T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for UserDataRefMut<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for UserDataRefMut<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T> TryFrom<UserDataVariant<T>> for UserDataRefMut<T> {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(variant: UserDataVariant<T>) -> Result<Self> {
+        let guard = variant.raw_lock().try_lock_exclusive_guarded();
+        let guard = guard.map_err(|_| Error::UserDataBorrowMutError)?;
+        let guard = unsafe { mem::transmute::<LockGuard<_>, LockGuard<'static, _>>(guard) };
+        Ok(UserDataRefMut::from_parts(
+            UserDataRefMutInner::Default(variant),
+            guard,
+        ))
+    }
+}
+
+impl<T: 'static> FromLua for UserDataRefMut<T> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
+        try_value_to_userdata::<T>(value)?.borrow_mut()
+    }
+
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        Self::borrow_from_stack(lua, lua.state(), idx)
+    }
+}
+
+impl<T: 'static> UserDataRefMut<T> {
+    #[inline(always)]
+    fn from_parts(inner: UserDataRefMutInner<T>, guard: LockGuard<'static, RawLock>) -> Self {
+        Self { _guard: guard, inner }
+    }
+
+    #[cfg(feature = "userdata-wrappers")]
+    fn remap<U>(
+        self,
+        f: impl FnOnce(UserDataVariant<T>) -> Result<UserDataRefMutInner<U>>,
+    ) -> Result<UserDataRefMut<U>> {
+        match &self.inner {
+            UserDataRefMutInner::Default(variant) => {
+                let inner = f(variant.clone())?;
+                Ok(UserDataRefMut::from_parts(inner, self._guard))
+            }
+            _ => Err(Error::UserDataTypeMismatch),
+        }
+    }
+
+    pub(crate) unsafe fn borrow_from_stack(
+        lua: &RawLua,
+        state: *mut ffi::lua_State,
+        idx: c_int,
+    ) -> Result<Self> {
+        let type_id = lua.get_userdata_type_id::<T>(state, idx)?;
+        match type_id {
+            Some(type_id) if type_id == TypeId::of::<T>() => {
+                let ud = get_userdata::<UserDataStorage<T>>(state, idx);
+                (*ud).try_borrow_owned_mut()
+            }
+
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Some(type_id) if type_id == TypeId::of::<Rc<T>>() => Err(Error::UserDataBorrowMutError),
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Some(type_id) if type_id == TypeId::of::<Rc<RefCell<T>>>() => {
+                let ud = get_userdata::<UserDataStorage<Rc<RefCell<T>>>>(state, idx);
+                ((*ud).try_borrow_owned_mut()).and_then(|ud| ud.transform_rc_refcell())
+            }
+
+            #[cfg(feature = "userdata-wrappers")]
+            Some(type_id) if type_id == TypeId::of::<Arc<T>>() => Err(Error::UserDataBorrowMutError),
+            #[cfg(feature = "userdata-wrappers")]
+            Some(type_id) if type_id == TypeId::of::<Arc<MutexPL<T>>>() => {
+                let ud = get_userdata::<UserDataStorage<Arc<MutexPL<T>>>>(state, idx);
+                ((*ud).try_borrow_owned_mut()).and_then(|ud| ud.transform_arc_mutex_pl())
+            }
+            #[cfg(feature = "userdata-wrappers")]
+            Some(type_id) if type_id == TypeId::of::<Arc<RwLockPL<T>>>() => {
+                let ud = get_userdata::<UserDataStorage<Arc<RwLockPL<T>>>>(state, idx);
+                ((*ud).try_borrow_owned_mut()).and_then(|ud| ud.transform_arc_rwlock_pl())
+            }
+            _ => Err(Error::UserDataTypeMismatch),
+        }
+    }
+}
+
+#[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+impl<T> UserDataRefMut<Rc<RefCell<T>>> {
+    fn transform_rc_refcell(self) -> Result<UserDataRefMut<T>> {
+        self.remap(|variant| unsafe {
+            let obj = &*variant.as_ptr();
+            let refmut = obj.try_borrow_mut().map_err(|_| Error::UserDataBorrowMutError)?;
+            let borrow = std::mem::transmute::<RefMut<T>, RefMut<'static, T>>(refmut);
+            Ok(UserDataRefMutInner::RcRefCell(borrow, variant))
+        })
+    }
+}
+
+#[cfg(feature = "userdata-wrappers")]
+impl<T> UserDataRefMut<Arc<MutexPL<T>>> {
+    fn transform_arc_mutex_pl(self) -> Result<UserDataRefMut<T>> {
+        self.remap(|variant| unsafe {
+            let obj = &*variant.as_ptr();
+            let guard = obj.try_lock().ok_or(Error::UserDataBorrowMutError)?;
+            let borrow = std::mem::transmute::<MutexGuardPL<T>, MutexGuardPL<'static, T>>(guard);
+            Ok(UserDataRefMutInner::ArcMutexPL(borrow, variant))
+        })
+    }
+}
+
+#[cfg(feature = "userdata-wrappers")]
+impl<T> UserDataRefMut<Arc<RwLockPL<T>>> {
+    fn transform_arc_rwlock_pl(self) -> Result<UserDataRefMut<T>> {
+        self.remap(|variant| unsafe {
+            let obj = &*variant.as_ptr();
+            let guard = obj.try_write().ok_or(Error::UserDataBorrowMutError)?;
+            let borrow = std::mem::transmute::<RwLockWriteGuardPL<T>, RwLockWriteGuardPL<'static, T>>(guard);
+            Ok(UserDataRefMutInner::ArcRwLockPL(borrow, variant))
+        })
+    }
+}
+
+#[allow(unused)]
+enum UserDataRefMutInner<T: 'static> {
+    Default(UserDataVariant<T>),
+
+    #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+    RcRefCell(RefMut<'static, T>, UserDataVariant<Rc<RefCell<T>>>),
+
+    #[cfg(feature = "userdata-wrappers")]
+    ArcMutexPL(MutexGuardPL<'static, T>, UserDataVariant<Arc<MutexPL<T>>>),
+    #[cfg(feature = "userdata-wrappers")]
+    ArcRwLockPL(RwLockWriteGuardPL<'static, T>, UserDataVariant<Arc<RwLockPL<T>>>),
+}
+
+impl<T> Deref for UserDataRefMutInner<T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        match self {
+            Self::Default(inner) => unsafe { &*inner.as_ptr() },
+
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Self::RcRefCell(x, ..) => x,
+
+            #[cfg(feature = "userdata-wrappers")]
+            Self::ArcMutexPL(x, ..) => x,
+            #[cfg(feature = "userdata-wrappers")]
+            Self::ArcRwLockPL(x, ..) => x,
+        }
+    }
+}
+
+impl<T> DerefMut for UserDataRefMutInner<T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        match self {
+            Self::Default(inner) => unsafe { &mut *inner.as_ptr() },
+
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            Self::RcRefCell(x, ..) => x,
+
+            #[cfg(feature = "userdata-wrappers")]
+            Self::ArcMutexPL(x, ..) => x,
+            #[cfg(feature = "userdata-wrappers")]
+            Self::ArcRwLockPL(x, ..) => x,
+        }
+    }
+}
+
+#[inline]
+fn try_value_to_userdata<T>(value: Value) -> Result<AnyUserData> {
+    match value {
+        Value::UserData(ud) => Ok(ud),
+        _ => Err(Error::FromLuaConversionError {
+            from: value.type_name(),
+            to: "userdata".to_string(),
+            message: Some(format!("expected userdata of type {}", type_name::<T>())),
+        }),
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(UserDataRef<()>: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_not_impl_all!(UserDataRef<std::rc::Rc<()>>: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(UserDataRefMut<()>: Sync, Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_not_impl_all!(UserDataRefMut<std::rc::Rc<()>>: Send, Sync);
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_all!(UserDataRef<()>: Send, Sync);
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_all!(UserDataRefMut<()>: Send, Sync);
+}

src/userdata/registry.rs

@@ -0,0 +1,657 @@
+#![allow(clippy::await_holding_refcell_ref, clippy::await_holding_lock)]
+
+use std::any::TypeId;
+use std::cell::RefCell;
+use std::marker::PhantomData;
+use std::os::raw::c_void;
+use std::string::String as StdString;
+
+use crate::error::{Error, Result};
+use crate::state::{Lua, LuaGuard};
+use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti};
+use crate::types::{Callback, MaybeSend};
+use crate::userdata::{
+    borrow_userdata_scoped, borrow_userdata_scoped_mut, AnyUserData, MetaMethod, TypeIdHints, UserData,
+    UserDataFields, UserDataMethods, UserDataStorage,
+};
+use crate::util::short_type_name;
+use crate::value::Value;
+
+#[cfg(feature = "async")]
+use {
+    crate::types::AsyncCallback,
+    crate::userdata::{UserDataRef, UserDataRefMut},
+    std::future::{self, Future},
+};
+
+#[derive(Clone, Copy)]
+enum UserDataType {
+    Shared(TypeIdHints),
+    Unique(*mut c_void),
+}
+
+/// Handle to registry for userdata methods and metamethods.
+pub struct UserDataRegistry<T> {
+    lua: LuaGuard,
+    raw: RawUserDataRegistry,
+    r#type: UserDataType,
+    _phantom: PhantomData<T>,
+}
+
+pub(crate) struct RawUserDataRegistry {
+    // Fields
+    pub(crate) fields: Vec<(String, Result<Value>)>,
+    pub(crate) field_getters: Vec<(String, Callback)>,
+    pub(crate) field_setters: Vec<(String, Callback)>,
+    pub(crate) meta_fields: Vec<(String, Result<Value>)>,
+
+    // Methods
+    pub(crate) methods: Vec<(String, Callback)>,
+    #[cfg(feature = "async")]
+    pub(crate) async_methods: Vec<(String, AsyncCallback)>,
+    pub(crate) meta_methods: Vec<(String, Callback)>,
+    #[cfg(feature = "async")]
+    pub(crate) async_meta_methods: Vec<(String, AsyncCallback)>,
+
+    pub(crate) destructor: ffi::lua_CFunction,
+    pub(crate) type_id: Option<TypeId>,
+    pub(crate) type_name: StdString,
+}
+
+impl UserDataType {
+    #[inline]
+    pub(crate) fn type_id(&self) -> Option<TypeId> {
+        match self {
+            UserDataType::Shared(hints) => Some(hints.type_id()),
+            UserDataType::Unique(_) => None,
+        }
+    }
+}
+
+#[cfg(feature = "send")]
+unsafe impl Send for UserDataType {}
+
+impl<T: 'static> UserDataRegistry<T> {
+    #[inline(always)]
+    pub(crate) fn new(lua: &Lua) -> Self {
+        Self::with_type(lua, UserDataType::Shared(TypeIdHints::new::<T>()))
+    }
+}
+
+impl<T> UserDataRegistry<T> {
+    #[inline(always)]
+    pub(crate) fn new_unique(lua: &Lua, ud_ptr: *mut c_void) -> Self {
+        Self::with_type(lua, UserDataType::Unique(ud_ptr))
+    }
+
+    #[inline(always)]
+    fn with_type(lua: &Lua, r#type: UserDataType) -> Self {
+        let raw = RawUserDataRegistry {
+            fields: Vec::new(),
+            field_getters: Vec::new(),
+            field_setters: Vec::new(),
+            meta_fields: Vec::new(),
+            methods: Vec::new(),
+            #[cfg(feature = "async")]
+            async_methods: Vec::new(),
+            meta_methods: Vec::new(),
+            #[cfg(feature = "async")]
+            async_meta_methods: Vec::new(),
+            destructor: super::util::destroy_userdata_storage::<T>,
+            type_id: r#type.type_id(),
+            type_name: short_type_name::<T>(),
+        };
+
+        UserDataRegistry {
+            lua: lua.lock_arc(),
+            raw,
+            r#type,
+            _phantom: PhantomData,
+        }
+    }
+
+    fn box_method<M, A, R>(&self, name: &str, method: M) -> Callback
+    where
+        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                $res.map_err(|err| Error::bad_self_argument(&name, err))?
+            };
+        }
+
+        let target_type = self.r#type;
+        Box::new(move |rawlua, nargs| unsafe {
+            if nargs == 0 {
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                try_self_arg!(Err(err));
+            }
+            let state = rawlua.state();
+            // Find absolute "self" index before processing args
+            let self_index = ffi::lua_absindex(state, -nargs);
+            // Self was at position 1, so we pass 2 here
+            let args = A::from_stack_args(nargs - 1, 2, Some(&name), rawlua);
+
+            match target_type {
+                #[rustfmt::skip]
+                UserDataType::Shared(type_hints) => {
+                    let type_id = try_self_arg!(rawlua.get_userdata_type_id::<T>(state, self_index));
+                    try_self_arg!(borrow_userdata_scoped(state, self_index, type_id, type_hints, |ud| {
+                        method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
+                    }))
+                }
+                UserDataType::Unique(target_ptr) if ffi::lua_touserdata(state, self_index) == target_ptr => {
+                    let ud = target_ptr as *mut UserDataStorage<T>;
+                    try_self_arg!((*ud).try_borrow_scoped(|ud| {
+                        method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
+                    }))
+                }
+                UserDataType::Unique(_) => {
+                    try_self_arg!(rawlua.get_userdata_type_id::<T>(state, self_index));
+                    Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch))
+                }
+            }
+        })
+    }
+
+    fn box_method_mut<M, A, R>(&self, name: &str, method: M) -> Callback
+    where
+        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                $res.map_err(|err| Error::bad_self_argument(&name, err))?
+            };
+        }
+
+        let method = RefCell::new(method);
+        let target_type = self.r#type;
+        Box::new(move |rawlua, nargs| unsafe {
+            let mut method = method.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
+            if nargs == 0 {
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                try_self_arg!(Err(err));
+            }
+            let state = rawlua.state();
+            // Find absolute "self" index before processing args
+            let self_index = ffi::lua_absindex(state, -nargs);
+            // Self was at position 1, so we pass 2 here
+            let args = A::from_stack_args(nargs - 1, 2, Some(&name), rawlua);
+
+            match target_type {
+                #[rustfmt::skip]
+                UserDataType::Shared(type_hints) => {
+                    let type_id = try_self_arg!(rawlua.get_userdata_type_id::<T>(state, self_index));
+                    try_self_arg!(borrow_userdata_scoped_mut(state, self_index, type_id, type_hints, |ud| {
+                        method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
+                    }))
+                }
+                UserDataType::Unique(target_ptr) if ffi::lua_touserdata(state, self_index) == target_ptr => {
+                    let ud = target_ptr as *mut UserDataStorage<T>;
+                    try_self_arg!((*ud).try_borrow_scoped_mut(|ud| {
+                        method(rawlua.lua(), ud, args?)?.push_into_stack_multi(rawlua)
+                    }))
+                }
+                UserDataType::Unique(_) => {
+                    try_self_arg!(rawlua.get_userdata_type_id::<T>(state, self_index));
+                    Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch))
+                }
+            }
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_method<M, A, MR, R>(&self, name: &str, method: M) -> AsyncCallback
+    where
+        T: 'static,
+        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                match $res {
+                    Ok(res) => res,
+                    Err(err) => return Box::pin(future::ready(Err(Error::bad_self_argument(&name, err)))),
+                }
+            };
+        }
+
+        Box::new(move |rawlua, nargs| unsafe {
+            if nargs == 0 {
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                try_self_arg!(Err(err));
+            }
+            // Stack will be empty when polling the future, keep `self` on the ref thread
+            let self_ud = try_self_arg!(AnyUserData::from_stack(-nargs, rawlua));
+            let args = A::from_stack_args(nargs - 1, 2, Some(&name), rawlua);
+
+            let self_ud = try_self_arg!(self_ud.borrow());
+            let args = match args {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let lua = rawlua.lua();
+            let fut = method(lua.clone(), self_ud, args);
+            // Lua is locked when the future is polled
+            Box::pin(async move { fut.await?.push_into_stack_multi(lua.raw_lua()) })
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_method_mut<M, A, MR, R>(&self, name: &str, method: M) -> AsyncCallback
+    where
+        T: 'static,
+        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                match $res {
+                    Ok(res) => res,
+                    Err(err) => return Box::pin(future::ready(Err(Error::bad_self_argument(&name, err)))),
+                }
+            };
+        }
+
+        Box::new(move |rawlua, nargs| unsafe {
+            if nargs == 0 {
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                try_self_arg!(Err(err));
+            }
+            // Stack will be empty when polling the future, keep `self` on the ref thread
+            let self_ud = try_self_arg!(AnyUserData::from_stack(-nargs, rawlua));
+            let args = A::from_stack_args(nargs - 1, 2, Some(&name), rawlua);
+
+            let self_ud = try_self_arg!(self_ud.borrow_mut());
+            let args = match args {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let lua = rawlua.lua();
+            let fut = method(lua.clone(), self_ud, args);
+            // Lua is locked when the future is polled
+            Box::pin(async move { fut.await?.push_into_stack_multi(lua.raw_lua()) })
+        })
+    }
+
+    fn box_function<F, A, R>(&self, name: &str, function: F) -> Callback
+    where
+        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        Box::new(move |lua, nargs| unsafe {
+            let args = A::from_stack_args(nargs, 1, Some(&name), lua)?;
+            function(lua.lua(), args)?.push_into_stack_multi(lua)
+        })
+    }
+
+    fn box_function_mut<F, A, R>(&self, name: &str, function: F) -> Callback
+    where
+        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        let function = RefCell::new(function);
+        Box::new(move |lua, nargs| unsafe {
+            let function = &mut *function
+                .try_borrow_mut()
+                .map_err(|_| Error::RecursiveMutCallback)?;
+            let args = A::from_stack_args(nargs, 1, Some(&name), lua)?;
+            function(lua.lua(), args)?.push_into_stack_multi(lua)
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_function<F, A, FR, R>(&self, name: &str, function: F) -> AsyncCallback
+    where
+        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        FR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        Box::new(move |rawlua, nargs| unsafe {
+            let args = match A::from_stack_args(nargs, 1, Some(&name), rawlua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let lua = rawlua.lua();
+            let fut = function(lua.clone(), args);
+            Box::pin(async move { fut.await?.push_into_stack_multi(lua.raw_lua()) })
+        })
+    }
+
+    pub(crate) fn check_meta_field(lua: &Lua, name: &str, value: impl IntoLua) -> Result<Value> {
+        let value = value.into_lua(lua)?;
+        if name == MetaMethod::Index || name == MetaMethod::NewIndex {
+            match value {
+                Value::Nil | Value::Table(_) | Value::Function(_) => {}
+                _ => {
+                    return Err(Error::MetaMethodTypeError {
+                        method: name.to_string(),
+                        type_name: value.type_name(),
+                        message: Some("expected nil, table or function".to_string()),
+                    })
+                }
+            }
+        }
+        value.into_lua(lua)
+    }
+
+    #[inline(always)]
+    pub(crate) fn into_raw(self) -> RawUserDataRegistry {
+        self.raw
+    }
+}
+
+// Returns function name for the type `T`, without the module path
+fn get_function_name<T>(name: &str) -> StdString {
+    format!("{}.{name}", short_type_name::<T>())
+}
+
+impl<T> UserDataFields<T> for UserDataRegistry<T> {
+    fn add_field<V>(&mut self, name: impl ToString, value: V)
+    where
+        V: IntoLua + 'static,
+    {
+        let name = name.to_string();
+        self.raw.fields.push((name, value.into_lua(self.lua.lua())));
+    }
+
+    fn add_field_method_get<M, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&Lua, &T) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua,
+    {
+        let name = name.to_string();
+        let callback = self.box_method(&name, move |lua, data, ()| method(lua, data));
+        self.raw.field_getters.push((name, callback));
+    }
+
+    fn add_field_method_set<M, A>(&mut self, name: impl ToString, method: M)
+    where
+        M: FnMut(&Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
+        A: FromLua,
+    {
+        let name = name.to_string();
+        let callback = self.box_method_mut(&name, method);
+        self.raw.field_setters.push((name, callback));
+    }
+
+    fn add_field_function_get<F, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&Lua, AnyUserData) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua,
+    {
+        let name = name.to_string();
+        let callback = self.box_function(&name, function);
+        self.raw.field_getters.push((name, callback));
+    }
+
+    fn add_field_function_set<F, A>(&mut self, name: impl ToString, mut function: F)
+    where
+        F: FnMut(&Lua, AnyUserData, A) -> Result<()> + MaybeSend + 'static,
+        A: FromLua,
+    {
+        let name = name.to_string();
+        let callback = self.box_function_mut(&name, move |lua, (data, val)| function(lua, data, val));
+        self.raw.field_setters.push((name, callback));
+    }
+
+    fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
+    where
+        V: IntoLua + 'static,
+    {
+        let lua = self.lua.lua();
+        let name = name.to_string();
+        let field = Self::check_meta_field(lua, &name, value).and_then(|v| v.into_lua(lua));
+        self.raw.meta_fields.push((name, field));
+    }
+
+    fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
+    where
+        F: FnOnce(&Lua) -> Result<R> + 'static,
+        R: IntoLua,
+    {
+        let lua = self.lua.lua();
+        let name = name.to_string();
+        let field = f(lua).and_then(|v| Self::check_meta_field(lua, &name, v).and_then(|v| v.into_lua(lua)));
+        self.raw.meta_fields.push((name, field));
+    }
+}
+
+impl<T> UserDataMethods<T> for UserDataRegistry<T> {
+    fn add_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_method(&name, method);
+        self.raw.methods.push((name, callback));
+    }
+
+    fn add_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_method_mut(&name, method);
+        self.raw.methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        T: 'static,
+        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_async_method(&name, method);
+        self.raw.async_methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        T: 'static,
+        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_async_method_mut(&name, method);
+        self.raw.async_methods.push((name, callback));
+    }
+
+    fn add_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_function(&name, function);
+        self.raw.methods.push((name, callback));
+    }
+
+    fn add_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_function_mut(&name, function);
+        self.raw.methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        FR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_async_function(&name, function);
+        self.raw.async_methods.push((name, callback));
+    }
+
+    fn add_meta_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_method(&name, method);
+        self.raw.meta_methods.push((name, callback));
+    }
+
+    fn add_meta_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_method_mut(&name, method);
+        self.raw.meta_methods.push((name, callback));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        T: 'static,
+        M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_async_method(&name, method);
+        self.raw.async_meta_methods.push((name, callback));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        T: 'static,
+        M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_async_method_mut(&name, method);
+        self.raw.async_meta_methods.push((name, callback));
+    }
+
+    fn add_meta_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_function(&name, function);
+        self.raw.meta_methods.push((name, callback));
+    }
+
+    fn add_meta_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_function_mut(&name, function);
+        self.raw.meta_methods.push((name, callback));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(Lua, A) -> FR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        FR: Future<Output = Result<R>> + MaybeSend + 'static,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = self.box_async_function(&name, function);
+        self.raw.async_meta_methods.push((name, callback));
+    }
+}
+
+macro_rules! lua_userdata_impl {
+    ($type:ty) => {
+        impl<T: UserData + 'static> UserData for $type {
+            fn register(registry: &mut UserDataRegistry<Self>) {
+                let mut orig_registry = UserDataRegistry::new(registry.lua.lua());
+                T::register(&mut orig_registry);
+
+                // Copy all fields, methods, etc. from the original registry
+                (registry.raw.fields).extend(orig_registry.raw.fields);
+                (registry.raw.field_getters).extend(orig_registry.raw.field_getters);
+                (registry.raw.field_setters).extend(orig_registry.raw.field_setters);
+                (registry.raw.meta_fields).extend(orig_registry.raw.meta_fields);
+                (registry.raw.methods).extend(orig_registry.raw.methods);
+                #[cfg(feature = "async")]
+                (registry.raw.async_methods).extend(orig_registry.raw.async_methods);
+                (registry.raw.meta_methods).extend(orig_registry.raw.meta_methods);
+                #[cfg(feature = "async")]
+                (registry.raw.async_meta_methods).extend(orig_registry.raw.async_meta_methods);
+            }
+        }
+    };
+}
+
+// A special proxy object for UserData
+pub(crate) struct UserDataProxy<T>(pub(crate) PhantomData<T>);
+
+lua_userdata_impl!(UserDataProxy<T>);
+
+#[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+lua_userdata_impl!(std::rc::Rc<T>);
+#[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+lua_userdata_impl!(std::rc::Rc<std::cell::RefCell<T>>);
+#[cfg(feature = "userdata-wrappers")]
+lua_userdata_impl!(std::sync::Arc<T>);
+#[cfg(feature = "userdata-wrappers")]
+lua_userdata_impl!(std::sync::Arc<std::sync::Mutex<T>>);
+#[cfg(feature = "userdata-wrappers")]
+lua_userdata_impl!(std::sync::Arc<std::sync::RwLock<T>>);
+#[cfg(feature = "userdata-wrappers")]
+lua_userdata_impl!(std::sync::Arc<parking_lot::Mutex<T>>);
+#[cfg(feature = "userdata-wrappers")]
+lua_userdata_impl!(std::sync::Arc<parking_lot::RwLock<T>>);
+
+#[cfg(test)]
+mod assertions {
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(super::RawUserDataRegistry: Send);
+}

src/userdata/util.rs

@@ -0,0 +1,468 @@
+use std::any::TypeId;
+use std::cell::Cell;
+use std::marker::PhantomData;
+use std::os::raw::c_int;
+use std::ptr;
+
+use super::UserDataStorage;
+use crate::error::{Error, Result};
+use crate::util::{get_userdata, rawget_field, rawset_field, take_userdata};
+
+// This is a trick to check if a type is `Sync` or not.
+// It uses leaked specialization feature from stdlib.
+struct IsSync<'a, T> {
+    is_sync: &'a Cell<bool>,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Clone for IsSync<'_, T> {
+    fn clone(&self) -> Self {
+        self.is_sync.set(false);
+        IsSync {
+            is_sync: self.is_sync,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T: Sync> Copy for IsSync<'_, T> {}
+
+pub(crate) fn is_sync<T>() -> bool {
+    let is_sync = Cell::new(true);
+    let _ = [IsSync::<T> {
+        is_sync: &is_sync,
+        _marker: PhantomData,
+    }]
+    .clone();
+    is_sync.get()
+}
+
+// Userdata type hints,  used to match types of wrapped userdata
+#[derive(Clone, Copy)]
+pub(crate) struct TypeIdHints {
+    t: TypeId,
+
+    #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+    rc: TypeId,
+    #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+    rc_refcell: TypeId,
+
+    #[cfg(feature = "userdata-wrappers")]
+    arc: TypeId,
+    #[cfg(feature = "userdata-wrappers")]
+    arc_mutex: TypeId,
+    #[cfg(feature = "userdata-wrappers")]
+    arc_rwlock: TypeId,
+    #[cfg(feature = "userdata-wrappers")]
+    arc_pl_mutex: TypeId,
+    #[cfg(feature = "userdata-wrappers")]
+    arc_pl_rwlock: TypeId,
+}
+
+impl TypeIdHints {
+    pub(crate) fn new<T: 'static>() -> Self {
+        Self {
+            t: TypeId::of::<T>(),
+
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            rc: TypeId::of::<std::rc::Rc<T>>(),
+            #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+            rc_refcell: TypeId::of::<std::rc::Rc<std::cell::RefCell<T>>>(),
+
+            #[cfg(feature = "userdata-wrappers")]
+            arc: TypeId::of::<std::sync::Arc<T>>(),
+            #[cfg(feature = "userdata-wrappers")]
+            arc_mutex: TypeId::of::<std::sync::Arc<std::sync::Mutex<T>>>(),
+            #[cfg(feature = "userdata-wrappers")]
+            arc_rwlock: TypeId::of::<std::sync::Arc<std::sync::RwLock<T>>>(),
+            #[cfg(feature = "userdata-wrappers")]
+            arc_pl_mutex: TypeId::of::<std::sync::Arc<parking_lot::Mutex<T>>>(),
+            #[cfg(feature = "userdata-wrappers")]
+            arc_pl_rwlock: TypeId::of::<std::sync::Arc<parking_lot::RwLock<T>>>(),
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn type_id(&self) -> TypeId {
+        self.t
+    }
+}
+
+pub(crate) unsafe fn borrow_userdata_scoped<T, R>(
+    state: *mut ffi::lua_State,
+    idx: c_int,
+    type_id: Option<TypeId>,
+    type_hints: TypeIdHints,
+    f: impl FnOnce(&T) -> R,
+) -> Result<R> {
+    match type_id {
+        Some(type_id) if type_id == type_hints.t => {
+            let ud = get_userdata::<UserDataStorage<T>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| f(ud))
+        }
+
+        #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+        Some(type_id) if type_id == type_hints.rc => {
+            let ud = get_userdata::<UserDataStorage<std::rc::Rc<T>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| f(ud))
+        }
+        #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+        Some(type_id) if type_id == type_hints.rc_refcell => {
+            let ud = get_userdata::<UserDataStorage<std::rc::Rc<std::cell::RefCell<T>>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| {
+                let ud = ud.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
+                Ok(f(&ud))
+            })?
+        }
+
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<T>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| f(ud))
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_mutex => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<std::sync::Mutex<T>>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| {
+                let ud = ud.try_lock().map_err(|_| Error::UserDataBorrowError)?;
+                Ok(f(&ud))
+            })?
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_rwlock => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<std::sync::RwLock<T>>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| {
+                let ud = ud.try_read().map_err(|_| Error::UserDataBorrowError)?;
+                Ok(f(&ud))
+            })?
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_pl_mutex => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<parking_lot::Mutex<T>>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| {
+                let ud = ud.try_lock().ok_or(Error::UserDataBorrowError)?;
+                Ok(f(&ud))
+            })?
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_pl_rwlock => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<parking_lot::RwLock<T>>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| {
+                let ud = ud.try_read().ok_or(Error::UserDataBorrowError)?;
+                Ok(f(&ud))
+            })?
+        }
+        _ => Err(Error::UserDataTypeMismatch),
+    }
+}
+
+pub(crate) unsafe fn borrow_userdata_scoped_mut<T, R>(
+    state: *mut ffi::lua_State,
+    idx: c_int,
+    type_id: Option<TypeId>,
+    type_hints: TypeIdHints,
+    f: impl FnOnce(&mut T) -> R,
+) -> Result<R> {
+    match type_id {
+        Some(type_id) if type_id == type_hints.t => {
+            let ud = get_userdata::<UserDataStorage<T>>(state, idx);
+            (*ud).try_borrow_scoped_mut(|ud| f(ud))
+        }
+
+        #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+        Some(type_id) if type_id == type_hints.rc => {
+            let ud = get_userdata::<UserDataStorage<std::rc::Rc<T>>>(state, idx);
+            (*ud).try_borrow_scoped_mut(|ud| match std::rc::Rc::get_mut(ud) {
+                Some(ud) => Ok(f(ud)),
+                None => Err(Error::UserDataBorrowMutError),
+            })?
+        }
+        #[cfg(all(feature = "userdata-wrappers", not(feature = "send")))]
+        Some(type_id) if type_id == type_hints.rc_refcell => {
+            let ud = get_userdata::<UserDataStorage<std::rc::Rc<std::cell::RefCell<T>>>>(state, idx);
+            (*ud).try_borrow_scoped(|ud| {
+                let mut ud = ud.try_borrow_mut().map_err(|_| Error::UserDataBorrowMutError)?;
+                Ok(f(&mut ud))
+            })?
+        }
+
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<T>>>(state, idx);
+            (*ud).try_borrow_scoped_mut(|ud| match std::sync::Arc::get_mut(ud) {
+                Some(ud) => Ok(f(ud)),
+                None => Err(Error::UserDataBorrowMutError),
+            })?
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_mutex => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<std::sync::Mutex<T>>>>(state, idx);
+            (*ud).try_borrow_scoped_mut(|ud| {
+                let mut ud = ud.try_lock().map_err(|_| Error::UserDataBorrowMutError)?;
+                Ok(f(&mut ud))
+            })?
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_rwlock => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<std::sync::RwLock<T>>>>(state, idx);
+            (*ud).try_borrow_scoped_mut(|ud| {
+                let mut ud = ud.try_write().map_err(|_| Error::UserDataBorrowMutError)?;
+                Ok(f(&mut ud))
+            })?
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_pl_mutex => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<parking_lot::Mutex<T>>>>(state, idx);
+            (*ud).try_borrow_scoped_mut(|ud| {
+                let mut ud = ud.try_lock().ok_or(Error::UserDataBorrowMutError)?;
+                Ok(f(&mut ud))
+            })?
+        }
+        #[cfg(feature = "userdata-wrappers")]
+        Some(type_id) if type_id == type_hints.arc_pl_rwlock => {
+            let ud = get_userdata::<UserDataStorage<std::sync::Arc<parking_lot::RwLock<T>>>>(state, idx);
+            (*ud).try_borrow_scoped_mut(|ud| {
+                let mut ud = ud.try_write().ok_or(Error::UserDataBorrowMutError)?;
+                Ok(f(&mut ud))
+            })?
+        }
+        _ => Err(Error::UserDataTypeMismatch),
+    }
+}
+
+// Populates the given table with the appropriate members to be a userdata metatable for the given
+// type. This function takes the given table at the `metatable` index, and adds an appropriate
+// `__gc` member to it for the given type and a `__metatable` entry to protect the table from script
+// access. The function also, if given a `field_getters` or `methods` tables, will create an
+// `__index` metamethod (capturing previous one) to lookup in `field_getters` first, then `methods`
+// and falling back to the captured `__index` if no matches found.
+// The same is also applicable for `__newindex` metamethod and `field_setters` table.
+// Internally uses 9 stack spaces and does not call checkstack.
+pub(crate) unsafe fn init_userdata_metatable(
+    state: *mut ffi::lua_State,
+    metatable: c_int,
+    field_getters: Option<c_int>,
+    field_setters: Option<c_int>,
+    methods: Option<c_int>,
+) -> Result<()> {
+    if field_getters.is_some() || methods.is_some() {
+        // Push `__index` generator function
+        init_userdata_metatable_index(state)?;
+
+        let index_type = rawget_field(state, metatable, "__index")?;
+        match index_type {
+            ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
+                for &idx in &[field_getters, methods] {
+                    if let Some(idx) = idx {
+                        ffi::lua_pushvalue(state, idx);
+                    } else {
+                        ffi::lua_pushnil(state);
+                    }
+                }
+
+                // Generate `__index`
+                protect_lua!(state, 4, 1, fn(state) ffi::lua_call(state, 3, 1))?;
+            }
+            _ => mlua_panic!("improper `__index` type: {}", index_type),
+        }
+
+        rawset_field(state, metatable, "__index")?;
+    }
+
+    if let Some(field_setters) = field_setters {
+        // Push `__newindex` generator function
+        init_userdata_metatable_newindex(state)?;
+
+        let newindex_type = rawget_field(state, metatable, "__newindex")?;
+        match newindex_type {
+            ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
+                ffi::lua_pushvalue(state, field_setters);
+                // Generate `__newindex`
+                protect_lua!(state, 3, 1, fn(state) ffi::lua_call(state, 2, 1))?;
+            }
+            _ => mlua_panic!("improper `__newindex` type: {}", newindex_type),
+        }
+
+        rawset_field(state, metatable, "__newindex")?;
+    }
+
+    ffi::lua_pushboolean(state, 0);
+    rawset_field(state, metatable, "__metatable")?;
+
+    Ok(())
+}
+
+unsafe extern "C-unwind" fn lua_error_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_error(state);
+}
+
+unsafe extern "C-unwind" fn lua_isfunction_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_pushboolean(state, ffi::lua_isfunction(state, -1));
+    1
+}
+
+unsafe extern "C-unwind" fn lua_istable_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_pushboolean(state, ffi::lua_istable(state, -1));
+    1
+}
+
+unsafe fn init_userdata_metatable_index(state: *mut ffi::lua_State) -> Result<()> {
+    let index_key = &USERDATA_METATABLE_INDEX as *const u8 as *const _;
+    if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, index_key) == ffi::LUA_TFUNCTION {
+        return Ok(());
+    }
+    ffi::lua_pop(state, 1);
+
+    // Create and cache `__index` generator
+    let code = cr#"
+        local error, isfunction, istable = ...
+        return function (__index, field_getters, methods)
+            -- Common case: has field getters and index is a table
+            if field_getters ~= nil and methods == nil and istable(__index) then
+                return function (self, key)
+                    local field_getter = field_getters[key]
+                    if field_getter ~= nil then
+                        return field_getter(self)
+                    end
+                    return __index[key]
+                end
+            end
+
+            return function (self, key)
+                if field_getters ~= nil then
+                    local field_getter = field_getters[key]
+                    if field_getter ~= nil then
+                        return field_getter(self)
+                    end
+                end
+
+                if methods ~= nil then
+                    local method = methods[key]
+                    if method ~= nil then
+                        return method
+                    end
+                end
+
+                if isfunction(__index) then
+                    return __index(self, key)
+                elseif __index == nil then
+                    error("attempt to get an unknown field '"..key.."'")
+                else
+                    return __index[key]
+                end
+            end
+        end
+    "#;
+    protect_lua!(state, 0, 1, |state| {
+        let ret = ffi::luaL_loadbuffer(state, code.as_ptr(), code.count_bytes(), cstr!("__mlua_index"));
+        if ret != ffi::LUA_OK {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushcfunction(state, lua_error_impl);
+        ffi::lua_pushcfunction(state, lua_isfunction_impl);
+        ffi::lua_pushcfunction(state, lua_istable_impl);
+        ffi::lua_call(state, 3, 1);
+
+        #[cfg(feature = "luau-jit")]
+        if ffi::luau_codegen_supported() != 0 {
+            ffi::luau_codegen_compile(state, -1);
+        }
+
+        // Store in the registry
+        ffi::lua_pushvalue(state, -1);
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, index_key);
+    })
+}
+
+unsafe fn init_userdata_metatable_newindex(state: *mut ffi::lua_State) -> Result<()> {
+    let newindex_key = &USERDATA_METATABLE_NEWINDEX as *const u8 as *const _;
+    if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, newindex_key) == ffi::LUA_TFUNCTION {
+        return Ok(());
+    }
+    ffi::lua_pop(state, 1);
+
+    // Create and cache `__newindex` generator
+    let code = cr#"
+        local error, isfunction = ...
+        return function (__newindex, field_setters)
+            return function (self, key, value)
+                if field_setters ~= nil then
+                    local field_setter = field_setters[key]
+                    if field_setter ~= nil then
+                        field_setter(self, value)
+                        return
+                    end
+                end
+
+                if isfunction(__newindex) then
+                    __newindex(self, key, value)
+                elseif __newindex == nil then
+                    error("attempt to set an unknown field '"..key.."'")
+                else
+                    __newindex[key] = value
+                end
+            end
+        end
+    "#;
+    protect_lua!(state, 0, 1, |state| {
+        let ret = ffi::luaL_loadbuffer(state, code.as_ptr(), code.count_bytes(), cstr!("__mlua_newindex"));
+        if ret != ffi::LUA_OK {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushcfunction(state, lua_error_impl);
+        ffi::lua_pushcfunction(state, lua_isfunction_impl);
+        ffi::lua_call(state, 2, 1);
+
+        #[cfg(feature = "luau-jit")]
+        if ffi::luau_codegen_supported() != 0 {
+            ffi::luau_codegen_compile(state, -1);
+        }
+
+        // Store in the registry
+        ffi::lua_pushvalue(state, -1);
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, newindex_key);
+    })
+}
+
+// This method is called by Lua GC when it's time to collect the userdata.
+//
+// This method is usually used to collect internal userdata.
+#[cfg(not(feature = "luau"))]
+pub(crate) unsafe extern "C-unwind" fn collect_userdata<T>(state: *mut ffi::lua_State) -> c_int {
+    let ud = get_userdata::<T>(state, -1);
+    ptr::drop_in_place(ud);
+    0
+}
+
+// This method is called by Luau GC when it's time to collect the userdata.
+#[cfg(feature = "luau")]
+pub(crate) unsafe extern "C" fn collect_userdata<T>(
+    state: *mut ffi::lua_State,
+    ud: *mut std::os::raw::c_void,
+) {
+    // Almost none Lua operations are allowed when destructor is running,
+    // so we need to set a flag to prevent calling any Lua functions
+    let extra = (*ffi::lua_callbacks(state)).userdata as *mut crate::state::ExtraData;
+    (*extra).running_userdata_gc = true;
+    // Luau does not support _any_ panics in destructors (they are declared as "C", NOT as "C-unwind"),
+    // so any panics will trigger `abort()`.
+    ptr::drop_in_place(ud as *mut T);
+    (*extra).running_userdata_gc = false;
+}
+
+// This method can be called by user or Lua GC to destroy the userdata.
+// It checks if the userdata is safe to destroy and sets the "destroyed" metatable
+// to prevent further GC collection.
+pub(super) unsafe extern "C-unwind" fn destroy_userdata_storage<T>(state: *mut ffi::lua_State) -> c_int {
+    let ud = get_userdata::<UserDataStorage<T>>(state, -1);
+    if (*ud).is_safe_to_destroy() {
+        take_userdata::<UserDataStorage<T>>(state);
+        ffi::lua_pushboolean(state, 1);
+    } else {
+        ffi::lua_pushboolean(state, 0);
+    }
+    1
+}
+
+static USERDATA_METATABLE_INDEX: u8 = 0;
+static USERDATA_METATABLE_NEWINDEX: u8 = 0;

src/userdata_ext.rs

@@ -1,190 +0,0 @@
-use crate::error::{Error, Result};
-use crate::private::Sealed;
-use crate::userdata::{AnyUserData, MetaMethod};
-use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
-
-#[cfg(feature = "async")]
-use futures_util::future::{self, LocalBoxFuture};
-
-/// An extension trait for [`AnyUserData`] that provides a variety of convenient functionality.
-pub trait AnyUserDataExt<'lua>: Sealed {
-    /// Gets the value associated to `key` from the userdata, assuming it has `__index` metamethod.
-    fn get<K: IntoLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V>;
-
-    /// Sets the value associated to `key` in the userdata, assuming it has `__newindex` metamethod.
-    fn set<K: IntoLua<'lua>, V: IntoLua<'lua>>(&self, key: K, value: V) -> Result<()>;
-
-    /// Calls the userdata as a function assuming it has `__call` metamethod.
-    ///
-    /// The metamethod is called with the userdata as its first argument, followed by the passed arguments.
-    fn call<A, R>(&self, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>;
-
-    /// Asynchronously calls the userdata as a function assuming it has `__call` metamethod.
-    ///
-    /// The metamethod is called with the userdata as its first argument, followed by the passed arguments.
-    #[cfg(feature = "async")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async<A, R>(&self, args: A) -> LocalBoxFuture<'lua, Result<R>>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua;
-
-    /// Calls the userdata method, assuming it has `__index` metamethod
-    /// and a function associated to `name`.
-    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>;
-
-    /// Gets the function associated to `key` from the table and asynchronously executes it,
-    /// passing the table itself along with `args` as function arguments and returning Future.
-    ///
-    /// Requires `feature = "async"`
-    ///
-    /// This might invoke the `__index` metamethod.
-    #[cfg(feature = "async")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_method<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua;
-
-    /// Gets the function associated to `key` from the table and executes it,
-    /// passing `args` as function arguments.
-    ///
-    /// This is a shortcut for
-    /// `table.get::<_, Function>(key)?.call(args)`
-    ///
-    /// This might invoke the `__index` metamethod.
-    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>;
-
-    /// Gets the function associated to `key` from the table and asynchronously executes it,
-    /// passing `args` as function arguments and returning Future.
-    ///
-    /// Requires `feature = "async"`
-    ///
-    /// This might invoke the `__index` metamethod.
-    #[cfg(feature = "async")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_function<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua;
-}
-
-impl<'lua> AnyUserDataExt<'lua> for AnyUserData<'lua> {
-    fn get<K: IntoLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
-        let metatable = self.get_metatable()?;
-        match metatable.get::<Value>(MetaMethod::Index)? {
-            Value::Table(table) => table.raw_get(key),
-            Value::Function(func) => func.call((self.clone(), key)),
-            _ => Err(Error::runtime("attempt to index a userdata value")),
-        }
-    }
-
-    fn set<K: IntoLua<'lua>, V: IntoLua<'lua>>(&self, key: K, value: V) -> Result<()> {
-        let metatable = self.get_metatable()?;
-        match metatable.get::<Value>(MetaMethod::NewIndex)? {
-            Value::Table(table) => table.raw_set(key, value),
-            Value::Function(func) => func.call((self.clone(), key, value)),
-            _ => Err(Error::runtime("attempt to index a userdata value")),
-        }
-    }
-
-    fn call<A, R>(&self, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
-    {
-        let metatable = self.get_metatable()?;
-        match metatable.get::<Value>(MetaMethod::Call)? {
-            Value::Function(func) => func.call((self.clone(), args)),
-            _ => Err(Error::runtime("attempt to call a userdata value")),
-        }
-    }
-
-    #[cfg(feature = "async")]
-    fn call_async<A, R>(&self, args: A) -> LocalBoxFuture<'lua, Result<R>>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua,
-    {
-        let metatable = match self.get_metatable() {
-            Ok(metatable) => metatable,
-            Err(err) => return Box::pin(future::err(err)),
-        };
-        match metatable.get::<Value>(MetaMethod::Call) {
-            Ok(Value::Function(func)) => {
-                let mut args = match args.into_lua_multi(self.0.lua) {
-                    Ok(args) => args,
-                    Err(e) => return Box::pin(future::err(e)),
-                };
-                args.push_front(Value::UserData(self.clone()));
-                Box::pin(async move { func.call_async(args).await })
-            }
-            Ok(_) => Box::pin(future::err(Error::runtime(
-                "attempt to call a userdata value",
-            ))),
-            Err(err) => Box::pin(future::err(err)),
-        }
-    }
-
-    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
-    {
-        self.call_function(name, (self.clone(), args))
-    }
-
-    #[cfg(feature = "async")]
-    fn call_async_method<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua,
-    {
-        self.call_async_function(name, (self.clone(), args))
-    }
-
-    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
-    {
-        match self.get(name)? {
-            Value::Function(func) => func.call(args),
-            val => {
-                let msg = format!("attempt to call a {} value", val.type_name());
-                Err(Error::runtime(msg))
-            }
-        }
-    }
-
-    #[cfg(feature = "async")]
-    fn call_async_function<A, R>(&self, name: &str, args: A) -> LocalBoxFuture<'lua, Result<R>>
-    where
-        A: IntoLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'lua,
-    {
-        match self.get(name) {
-            Ok(Value::Function(func)) => {
-                let args = match args.into_lua_multi(self.0.lua) {
-                    Ok(args) => args,
-                    Err(e) => return Box::pin(future::err(e)),
-                };
-                Box::pin(async move { func.call_async(args).await })
-            }
-            Ok(val) => {
-                let msg = format!("attempt to call a {} value", val.type_name());
-                Box::pin(future::err(Error::runtime(msg)))
-            }
-            Err(err) => Box::pin(future::err(err)),
-        }
-    }
-}

src/userdata_impl.rs

@@ -1,797 +0,0 @@
-#![allow(clippy::await_holding_refcell_ref, clippy::await_holding_lock)]
-
-use std::any::TypeId;
-use std::cell::{Ref, RefCell, RefMut};
-use std::marker::PhantomData;
-use std::os::raw::c_int;
-use std::string::String as StdString;
-use std::sync::{Arc, Mutex, RwLock};
-
-use crate::error::{Error, Result};
-use crate::lua::Lua;
-use crate::types::{Callback, MaybeSend};
-use crate::userdata::{
-    AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
-};
-use crate::util::{get_userdata, short_type_name};
-use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
-
-#[cfg(not(feature = "send"))]
-use std::rc::Rc;
-
-#[cfg(feature = "async")]
-use {crate::types::AsyncCallback, futures_util::future, std::future::Future};
-
-/// Handle to registry for userdata methods and metamethods.
-pub struct UserDataRegistry<'lua, T: 'static> {
-    // Fields
-    pub(crate) fields: Vec<(String, Callback<'lua, 'static>)>,
-    pub(crate) field_getters: Vec<(String, Callback<'lua, 'static>)>,
-    pub(crate) field_setters: Vec<(String, Callback<'lua, 'static>)>,
-    pub(crate) meta_fields: Vec<(String, Callback<'lua, 'static>)>,
-
-    // Methods
-    pub(crate) methods: Vec<(String, Callback<'lua, 'static>)>,
-    #[cfg(feature = "async")]
-    pub(crate) async_methods: Vec<(String, AsyncCallback<'lua, 'static>)>,
-    pub(crate) meta_methods: Vec<(String, Callback<'lua, 'static>)>,
-    #[cfg(feature = "async")]
-    pub(crate) async_meta_methods: Vec<(String, AsyncCallback<'lua, 'static>)>,
-
-    _type: PhantomData<T>,
-}
-
-impl<'lua, T: 'static> UserDataRegistry<'lua, T> {
-    pub(crate) const fn new() -> Self {
-        UserDataRegistry {
-            fields: Vec::new(),
-            field_getters: Vec::new(),
-            field_setters: Vec::new(),
-            meta_fields: Vec::new(),
-            methods: Vec::new(),
-            #[cfg(feature = "async")]
-            async_methods: Vec::new(),
-            meta_methods: Vec::new(),
-            #[cfg(feature = "async")]
-            async_meta_methods: Vec::new(),
-            _type: PhantomData,
-        }
-    }
-
-    fn box_method<M, A, R>(name: &str, method: M) -> Callback<'lua, 'static>
-    where
-        M: Fn(&'lua Lua, &T, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = get_function_name::<T>(name);
-        macro_rules! try_self_arg {
-            ($res:expr) => {
-                $res.map_err(|err| Error::bad_self_argument(&name, err))?
-            };
-            ($res:expr, $err:expr) => {
-                $res.map_err(|_| Error::bad_self_argument(&name, $err))?
-            };
-        }
-
-        Box::new(move |lua, nargs| unsafe {
-            if nargs == 0 {
-                let err = Error::from_lua_conversion("missing argument", "userdata", None);
-                try_self_arg!(Err(err));
-            }
-            let state = lua.state();
-            // Find absolute "self" index before processing args
-            let index = ffi::lua_absindex(state, -nargs);
-            // Self was at position 1, so we pass 2 here
-            let args = A::from_stack_args(nargs - 1, 2, Some(&name), lua);
-
-            match try_self_arg!(lua.get_userdata_type_id(index)) {
-                Some(id) if id == TypeId::of::<T>() => {
-                    let ud = try_self_arg!(get_userdata_ref::<T>(state, index));
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                #[cfg(not(feature = "send"))]
-                Some(id) if id == TypeId::of::<Rc<T>>() => {
-                    let ud = try_self_arg!(get_userdata_ref::<Rc<T>>(state, index));
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                #[cfg(not(feature = "send"))]
-                Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                    let ud = try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(state, index));
-                    let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                Some(id) if id == TypeId::of::<Arc<T>>() => {
-                    let ud = try_self_arg!(get_userdata_ref::<Arc<T>>(state, index));
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                    let ud = try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(state, index));
-                    let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                #[cfg(feature = "parking_lot")]
-                Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                    let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(state, index);
-                    let ud = try_self_arg!(ud);
-                    let ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                    let ud = try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(state, index));
-                    let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                #[cfg(feature = "parking_lot")]
-                Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                    let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(state, index);
-                    let ud = try_self_arg!(ud);
-                    let ud = try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
-                    method(lua, &ud, args?)?.push_into_stack_multi(lua)
-                }
-                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
-            }
-        })
-    }
-
-    fn box_method_mut<M, A, R>(name: &str, method: M) -> Callback<'lua, 'static>
-    where
-        M: FnMut(&'lua Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = get_function_name::<T>(name);
-        macro_rules! try_self_arg {
-            ($res:expr) => {
-                $res.map_err(|err| Error::bad_self_argument(&name, err))?
-            };
-            ($res:expr, $err:expr) => {
-                $res.map_err(|_| Error::bad_self_argument(&name, $err))?
-            };
-        }
-
-        let method = RefCell::new(method);
-        Box::new(move |lua, nargs| unsafe {
-            let mut method = method
-                .try_borrow_mut()
-                .map_err(|_| Error::RecursiveMutCallback)?;
-            if nargs == 0 {
-                let err = Error::from_lua_conversion("missing argument", "userdata", None);
-                try_self_arg!(Err(err));
-            }
-            let state = lua.state();
-            // Find absolute "self" index before processing args
-            let index = ffi::lua_absindex(state, -nargs);
-            // Self was at position 1, so we pass 2 here
-            let args = A::from_stack_args(nargs - 1, 2, Some(&name), lua);
-
-            match try_self_arg!(lua.get_userdata_type_id(index)) {
-                Some(id) if id == TypeId::of::<T>() => {
-                    let mut ud = try_self_arg!(get_userdata_mut::<T>(state, index));
-                    method(lua, &mut ud, args?)?.push_into_stack_multi(lua)
-                }
-                #[cfg(not(feature = "send"))]
-                Some(id) if id == TypeId::of::<Rc<T>>() => Err(Error::UserDataBorrowMutError),
-                #[cfg(not(feature = "send"))]
-                Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                    let ud = try_self_arg!(get_userdata_mut::<Rc<RefCell<T>>>(state, index));
-                    let mut ud = try_self_arg!(ud.try_borrow_mut(), Error::UserDataBorrowMutError);
-                    method(lua, &mut ud, args?)?.push_into_stack_multi(lua)
-                }
-                Some(id) if id == TypeId::of::<Arc<T>>() => Err(Error::UserDataBorrowMutError),
-                Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                    let ud = try_self_arg!(get_userdata_mut::<Arc<Mutex<T>>>(state, index));
-                    let mut ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowMutError);
-                    method(lua, &mut ud, args?)?.push_into_stack_multi(lua)
-                }
-                #[cfg(feature = "parking_lot")]
-                Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                    let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(state, index);
-                    let ud = try_self_arg!(ud);
-                    let mut ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowMutError));
-                    method(lua, &mut ud, args?)?.push_into_stack_multi(lua)
-                }
-                Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                    let ud = try_self_arg!(get_userdata_mut::<Arc<RwLock<T>>>(state, index));
-                    let mut ud = try_self_arg!(ud.try_write(), Error::UserDataBorrowMutError);
-                    method(lua, &mut ud, args?)?.push_into_stack_multi(lua)
-                }
-                #[cfg(feature = "parking_lot")]
-                Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                    let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(state, index);
-                    let ud = try_self_arg!(ud);
-                    let mut ud = try_self_arg!(ud.try_write().ok_or(Error::UserDataBorrowMutError));
-                    method(lua, &mut ud, args?)?.push_into_stack_multi(lua)
-                }
-                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
-            }
-        })
-    }
-
-    #[cfg(feature = "async")]
-    fn box_async_method<'s, M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'lua, 'static>
-    where
-        'lua: 's,
-        T: 'static,
-        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 's,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = Arc::new(get_function_name::<T>(name));
-        let method = Arc::new(method);
-
-        Box::new(move |lua, mut args| unsafe {
-            let name = name.clone();
-            let method = method.clone();
-            macro_rules! try_self_arg {
-                ($res:expr) => {
-                    $res.map_err(|err| Error::bad_self_argument(&name, err))?
-                };
-                ($res:expr, $err:expr) => {
-                    $res.map_err(|_| Error::bad_self_argument(&name, $err))?
-                };
-            }
-
-            Box::pin(async move {
-                let this = args.pop_front().ok_or_else(|| {
-                    Error::from_lua_conversion("missing argument", "userdata", None)
-                });
-                let this = try_self_arg!(AnyUserData::from_lua(try_self_arg!(this), lua));
-                let args = A::from_lua_args(args, 2, Some(&name), lua);
-
-                let (ref_thread, index) = (lua.ref_thread(), this.0.index);
-                match try_self_arg!(this.type_id()) {
-                    Some(id) if id == TypeId::of::<T>() => {
-                        let ud = try_self_arg!(get_userdata_ref::<T>(ref_thread, index));
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(not(feature = "send"))]
-                    Some(id) if id == TypeId::of::<Rc<T>>() => {
-                        let ud = try_self_arg!(get_userdata_ref::<Rc<T>>(ref_thread, index));
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(not(feature = "send"))]
-                    Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                        let ud =
-                            try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(ref_thread, index));
-                        let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    Some(id) if id == TypeId::of::<Arc<T>>() => {
-                        let ud = try_self_arg!(get_userdata_ref::<Arc<T>>(ref_thread, index));
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                        let ud =
-                            try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(ref_thread, index));
-                        let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(feature = "parking_lot")]
-                    Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                        let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(ref_thread, index);
-                        let ud = try_self_arg!(ud);
-                        let ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                        let ud =
-                            try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(ref_thread, index));
-                        let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(feature = "parking_lot")]
-                    Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                        let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(ref_thread, index);
-                        let ud = try_self_arg!(ud);
-                        let ud = try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
-                        let ud = std::mem::transmute::<&T, &T>(&ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
-                }
-            })
-        })
-    }
-
-    #[cfg(feature = "async")]
-    fn box_async_method_mut<'s, M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'lua, 'static>
-    where
-        'lua: 's,
-        T: 'static,
-        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 's,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = Arc::new(get_function_name::<T>(name));
-        let method = Arc::new(method);
-
-        Box::new(move |lua, mut args| unsafe {
-            let name = name.clone();
-            let method = method.clone();
-            macro_rules! try_self_arg {
-                ($res:expr) => {
-                    $res.map_err(|err| Error::bad_self_argument(&name, err))?
-                };
-                ($res:expr, $err:expr) => {
-                    $res.map_err(|_| Error::bad_self_argument(&name, $err))?
-                };
-            }
-
-            Box::pin(async move {
-                let this = args.pop_front().ok_or_else(|| {
-                    Error::from_lua_conversion("missing argument", "userdata", None)
-                });
-                let this = try_self_arg!(AnyUserData::from_lua(try_self_arg!(this), lua));
-                let args = A::from_lua_args(args, 2, Some(&name), lua);
-
-                let (ref_thread, index) = (lua.ref_thread(), this.0.index);
-                match try_self_arg!(this.type_id()) {
-                    Some(id) if id == TypeId::of::<T>() => {
-                        let mut ud = try_self_arg!(get_userdata_mut::<T>(ref_thread, index));
-                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(not(feature = "send"))]
-                    Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                        Err(Error::UserDataBorrowMutError)
-                    }
-                    #[cfg(not(feature = "send"))]
-                    Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                        let ud =
-                            try_self_arg!(get_userdata_mut::<Rc<RefCell<T>>>(ref_thread, index));
-                        let mut ud =
-                            try_self_arg!(ud.try_borrow_mut(), Error::UserDataBorrowMutError);
-                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(not(feature = "send"))]
-                    Some(id) if id == TypeId::of::<Arc<T>>() => Err(Error::UserDataBorrowMutError),
-                    Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                        let ud =
-                            try_self_arg!(get_userdata_mut::<Arc<Mutex<T>>>(ref_thread, index));
-                        let mut ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowMutError);
-                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(feature = "parking_lot")]
-                    Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                        let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(ref_thread, index);
-                        let ud = try_self_arg!(ud);
-                        let mut ud =
-                            try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowMutError));
-                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                        let ud =
-                            try_self_arg!(get_userdata_mut::<Arc<RwLock<T>>>(ref_thread, index));
-                        let mut ud = try_self_arg!(ud.try_write(), Error::UserDataBorrowMutError);
-                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    #[cfg(feature = "parking_lot")]
-                    Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                        let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(ref_thread, index);
-                        let ud = try_self_arg!(ud);
-                        let mut ud =
-                            try_self_arg!(ud.try_write().ok_or(Error::UserDataBorrowMutError));
-                        let ud = std::mem::transmute::<&mut T, &mut T>(&mut ud);
-                        method(lua, ud, args?).await?.push_into_stack_multi(lua)
-                    }
-                    _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
-                }
-            })
-        })
-    }
-
-    fn box_function<F, A, R>(name: &str, function: F) -> Callback<'lua, 'static>
-    where
-        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = get_function_name::<T>(name);
-        Box::new(move |lua, nargs| unsafe {
-            let args = A::from_stack_args(nargs, 1, Some(&name), lua)?;
-            function(lua, args)?.push_into_stack_multi(lua)
-        })
-    }
-
-    fn box_function_mut<F, A, R>(name: &str, function: F) -> Callback<'lua, 'static>
-    where
-        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = get_function_name::<T>(name);
-        let function = RefCell::new(function);
-        Box::new(move |lua, nargs| unsafe {
-            let function = &mut *function
-                .try_borrow_mut()
-                .map_err(|_| Error::RecursiveMutCallback)?;
-            let args = A::from_stack_args(nargs, 1, Some(&name), lua)?;
-            function(lua, args)?.push_into_stack_multi(lua)
-        })
-    }
-
-    #[cfg(feature = "async")]
-    fn box_async_function<F, A, FR, R>(name: &str, function: F) -> AsyncCallback<'lua, 'static>
-    where
-        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        FR: Future<Output = Result<R>> + 'lua,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = get_function_name::<T>(name);
-        Box::new(move |lua, args| unsafe {
-            let args = match A::from_lua_args(args, 1, Some(&name), lua) {
-                Ok(args) => args,
-                Err(e) => return Box::pin(future::err(e)),
-            };
-            let fut = function(lua, args);
-            Box::pin(async move { fut.await?.push_into_stack_multi(lua) })
-        })
-    }
-
-    pub(crate) fn check_meta_field<V>(lua: &'lua Lua, name: &str, value: V) -> Result<Value<'lua>>
-    where
-        V: IntoLua<'lua>,
-    {
-        let value = value.into_lua(lua)?;
-        if name == MetaMethod::Index || name == MetaMethod::NewIndex {
-            match value {
-                Value::Nil | Value::Table(_) | Value::Function(_) => {}
-                _ => {
-                    return Err(Error::MetaMethodTypeError {
-                        method: name.to_string(),
-                        type_name: value.type_name(),
-                        message: Some("expected nil, table or function".to_string()),
-                    })
-                }
-            }
-        }
-        value.into_lua(lua)
-    }
-}
-
-// Returns function name for the type `T`, without the module path
-fn get_function_name<T>(name: &str) -> StdString {
-    format!("{}.{name}", short_type_name::<T>())
-}
-
-impl<'lua, T: 'static> UserDataFields<'lua, T> for UserDataRegistry<'lua, T> {
-    fn add_field<V>(&mut self, name: impl AsRef<str>, value: V)
-    where
-        V: IntoLua<'lua> + Clone + 'static,
-    {
-        let name = name.as_ref().to_string();
-        self.fields.push((
-            name,
-            Box::new(move |lua, _| unsafe { value.clone().push_into_stack_multi(lua) }),
-        ));
-    }
-
-    fn add_field_method_get<M, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        M: Fn(&'lua Lua, &T) -> Result<R> + MaybeSend + 'static,
-        R: IntoLua<'lua>,
-    {
-        let name = name.as_ref();
-        let method = Self::box_method(name, move |lua, data, ()| method(lua, data));
-        self.field_getters.push((name.into(), method));
-    }
-
-    fn add_field_method_set<M, A>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        M: FnMut(&'lua Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
-        A: FromLua<'lua>,
-    {
-        let name = name.as_ref();
-        let method = Self::box_method_mut(name, method);
-        self.field_setters.push((name.into(), method));
-    }
-
-    fn add_field_function_get<F, R>(&mut self, name: impl AsRef<str>, function: F)
-    where
-        F: Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R> + MaybeSend + 'static,
-        R: IntoLua<'lua>,
-    {
-        let name = name.as_ref();
-        let func = Self::box_function(name, function);
-        self.field_getters.push((name.into(), func));
-    }
-
-    fn add_field_function_set<F, A>(&mut self, name: impl AsRef<str>, mut function: F)
-    where
-        F: FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()> + MaybeSend + 'static,
-        A: FromLua<'lua>,
-    {
-        let name = name.as_ref();
-        let func = Self::box_function_mut(name, move |lua, (data, val)| function(lua, data, val));
-        self.field_setters.push((name.into(), func));
-    }
-
-    fn add_meta_field<V>(&mut self, name: impl AsRef<str>, value: V)
-    where
-        V: IntoLua<'lua> + Clone + 'static,
-    {
-        let name = name.as_ref().to_string();
-        let name2 = name.clone();
-        self.meta_fields.push((
-            name,
-            Box::new(move |lua, _| unsafe {
-                Self::check_meta_field(lua, &name2, value.clone())?.push_into_stack_multi(lua)
-            }),
-        ));
-    }
-
-    fn add_meta_field_with<F, R>(&mut self, name: impl AsRef<str>, f: F)
-    where
-        F: Fn(&'lua Lua) -> Result<R> + MaybeSend + 'static,
-        R: IntoLua<'lua>,
-    {
-        let name = name.as_ref().to_string();
-        let name2 = name.clone();
-        self.meta_fields.push((
-            name,
-            Box::new(move |lua, _| unsafe {
-                Self::check_meta_field(lua, &name2, f(lua)?)?.push_into_stack_multi(lua)
-            }),
-        ));
-    }
-
-    // Below are internal methods
-
-    fn append_fields_from<S>(&mut self, other: UserDataRegistry<'lua, S>) {
-        self.fields.extend(other.fields);
-        self.field_getters.extend(other.field_getters);
-        self.field_setters.extend(other.field_setters);
-        self.meta_fields.extend(other.meta_fields);
-    }
-}
-
-impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistry<'lua, T> {
-    fn add_method<M, A, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        M: Fn(&'lua Lua, &T, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.methods
-            .push((name.into(), Self::box_method(name, method)));
-    }
-
-    fn add_method_mut<M, A, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        M: FnMut(&'lua Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.methods
-            .push((name.into(), Self::box_method_mut(name, method)));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_method<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        'lua: 's,
-        T: 'static,
-        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 's,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.async_methods
-            .push((name.into(), Self::box_async_method(name, method)));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_method_mut<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        'lua: 's,
-        T: 'static,
-        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 's,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.async_methods
-            .push((name.into(), Self::box_async_method_mut(name, method)));
-    }
-
-    fn add_function<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
-    where
-        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.methods
-            .push((name.into(), Self::box_function(name, function)));
-    }
-
-    fn add_function_mut<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
-    where
-        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.methods
-            .push((name.into(), Self::box_function_mut(name, function)));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_function<F, A, FR, R>(&mut self, name: impl AsRef<str>, function: F)
-    where
-        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        FR: Future<Output = Result<R>> + 'lua,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.async_methods
-            .push((name.into(), Self::box_async_function(name, function)));
-    }
-
-    fn add_meta_method<M, A, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        M: Fn(&'lua Lua, &T, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.meta_methods
-            .push((name.into(), Self::box_method(name, method)));
-    }
-
-    fn add_meta_method_mut<M, A, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        M: FnMut(&'lua Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.meta_methods
-            .push((name.into(), Self::box_method_mut(name, method)));
-    }
-
-    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        'lua: 's,
-        T: 'static,
-        M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 's,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.async_meta_methods
-            .push((name.into(), Self::box_async_method(name, method)));
-    }
-
-    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method_mut<'s, M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
-    where
-        'lua: 's,
-        T: 'static,
-        M: Fn(&'lua Lua, &'s mut T, A) -> MR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        MR: Future<Output = Result<R>> + 's,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.async_meta_methods
-            .push((name.into(), Self::box_async_method_mut(name, method)));
-    }
-
-    fn add_meta_function<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
-    where
-        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.meta_methods
-            .push((name.into(), Self::box_function(name, function)));
-    }
-
-    fn add_meta_function_mut<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
-    where
-        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.meta_methods
-            .push((name.into(), Self::box_function_mut(name, function)));
-    }
-
-    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl AsRef<str>, function: F)
-    where
-        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
-        A: FromLuaMulti<'lua>,
-        FR: Future<Output = Result<R>> + 'lua,
-        R: IntoLuaMulti<'lua>,
-    {
-        let name = name.as_ref();
-        self.async_meta_methods
-            .push((name.into(), Self::box_async_function(name, function)));
-    }
-
-    // Below are internal methods used in generated code
-
-    fn append_methods_from<S>(&mut self, other: UserDataRegistry<'lua, S>) {
-        self.methods.extend(other.methods);
-        #[cfg(feature = "async")]
-        self.async_methods.extend(other.async_methods);
-        self.meta_methods.extend(other.meta_methods);
-        #[cfg(feature = "async")]
-        self.async_meta_methods.extend(other.async_meta_methods);
-    }
-}
-
-#[inline]
-unsafe fn get_userdata_ref<'a, T>(state: *mut ffi::lua_State, index: c_int) -> Result<Ref<'a, T>> {
-    (*get_userdata::<UserDataCell<T>>(state, index)).try_borrow()
-}
-
-#[inline]
-unsafe fn get_userdata_mut<'a, T>(
-    state: *mut ffi::lua_State,
-    index: c_int,
-) -> Result<RefMut<'a, T>> {
-    (*get_userdata::<UserDataCell<T>>(state, index)).try_borrow_mut()
-}
-
-macro_rules! lua_userdata_impl {
-    ($type:ty) => {
-        impl<T: UserData + 'static> UserData for $type {
-            fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
-                let mut orig_fields = UserDataRegistry::new();
-                T::add_fields(&mut orig_fields);
-                fields.append_fields_from(orig_fields);
-            }
-
-            fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-                let mut orig_methods = UserDataRegistry::new();
-                T::add_methods(&mut orig_methods);
-                methods.append_methods_from(orig_methods);
-            }
-        }
-    };
-}
-
-#[cfg(not(feature = "send"))]
-lua_userdata_impl!(Rc<T>);
-#[cfg(not(feature = "send"))]
-lua_userdata_impl!(Rc<RefCell<T>>);
-
-lua_userdata_impl!(Arc<T>);
-lua_userdata_impl!(Arc<Mutex<T>>);
-lua_userdata_impl!(Arc<RwLock<T>>);
-#[cfg(feature = "parking_lot")]
-lua_userdata_impl!(Arc<parking_lot::Mutex<T>>);
-#[cfg(feature = "parking_lot")]
-lua_userdata_impl!(Arc<parking_lot::RwLock<T>>);
-
-// A special proxy object for UserData
-pub(crate) struct UserDataProxy<T>(pub(crate) PhantomData<T>);
-
-lua_userdata_impl!(UserDataProxy<T>);

src/util/error.rs

@@ -0,0 +1,423 @@
+use std::any::Any;
+use std::fmt::Write as _;
+use std::mem::MaybeUninit;
+use std::os::raw::{c_int, c_void};
+use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
+use std::ptr;
+use std::sync::Arc;
+
+use crate::error::{Error, Result};
+use crate::memory::MemoryState;
+use crate::util::{
+    check_stack, get_internal_userdata, init_internal_metatable, push_internal_userdata, push_string,
+    push_table, rawset_field, to_string, TypeKey, DESTRUCTED_USERDATA_METATABLE,
+};
+
+static WRAPPED_FAILURE_TYPE_KEY: u8 = 0;
+
+pub(crate) enum WrappedFailure {
+    None,
+    Error(Error),
+    Panic(Option<Box<dyn Any + Send + 'static>>),
+}
+
+impl TypeKey for WrappedFailure {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &WRAPPED_FAILURE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+impl WrappedFailure {
+    pub(crate) unsafe fn new_userdata(state: *mut ffi::lua_State) -> *mut Self {
+        // Unprotected calls always return `Ok`
+        push_internal_userdata(state, WrappedFailure::None, false).unwrap()
+    }
+}
+
+// In the context of a lua callback, this will call the given function and if the given function
+// returns an error, *or if the given function panics*, this will result in a call to `lua_error` (a
+// longjmp). The error or panic is wrapped in such a way that when calling `pop_error` back on
+// the Rust side, it will resume the panic.
+//
+// This function assumes the structure of the stack at the beginning of a callback, that the only
+// elements on the stack are the arguments to the callback.
+//
+// This function uses some of the bottom of the stack for error handling, the given callback will be
+// given the number of arguments available as an argument, and should return the number of returns
+// as normal, but cannot assume that the arguments available start at 0.
+unsafe fn callback_error<F, R>(state: *mut ffi::lua_State, f: F) -> R
+where
+    F: FnOnce(c_int) -> Result<R>,
+{
+    let nargs = ffi::lua_gettop(state);
+
+    // We need 2 extra stack spaces to store preallocated memory and error/panic metatable
+    let extra_stack = if nargs < 2 { 2 - nargs } else { 1 };
+    ffi::luaL_checkstack(
+        state,
+        extra_stack,
+        cstr!("not enough stack space for callback error handling"),
+    );
+
+    // We cannot shadow Rust errors with Lua ones, we pre-allocate enough memory
+    // to store a wrapped error or panic *before* we proceed.
+    let ud = WrappedFailure::new_userdata(state);
+    ffi::lua_rotate(state, 1, 1);
+
+    match catch_unwind(AssertUnwindSafe(|| f(nargs))) {
+        Ok(Ok(r)) => {
+            ffi::lua_remove(state, 1);
+            r
+        }
+        Ok(Err(err)) => {
+            ffi::lua_settop(state, 1);
+
+            // Build `CallbackError` with traceback
+            let traceback = if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+                ffi::luaL_traceback(state, state, ptr::null(), 0);
+                let traceback = to_string(state, -1);
+                ffi::lua_pop(state, 1);
+                traceback
+            } else {
+                "<not enough stack space for traceback>".to_string()
+            };
+            let cause = Arc::new(err);
+            let wrapped_error = WrappedFailure::Error(Error::CallbackError { traceback, cause });
+            ptr::write(ud, wrapped_error);
+            ffi::lua_error(state)
+        }
+        Err(p) => {
+            ffi::lua_settop(state, 1);
+            ptr::write(ud, WrappedFailure::Panic(Some(p)));
+            ffi::lua_error(state)
+        }
+    }
+}
+
+// Pops an error off of the stack and returns it. The specific behavior depends on the type of the
+// error at the top of the stack:
+//   1) If the error is actually a panic, this will continue the panic.
+//   2) If the error on the top of the stack is actually an error, just returns it.
+//   3) Otherwise, interprets the error as the appropriate lua error.
+// Uses 2 stack spaces, does not call checkstack.
+pub(crate) unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
+    mlua_debug_assert!(
+        err_code != ffi::LUA_OK && err_code != ffi::LUA_YIELD,
+        "pop_error called with non-error return code"
+    );
+
+    match get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).as_mut() {
+        Some(WrappedFailure::Error(err)) => {
+            ffi::lua_pop(state, 1);
+            err.clone()
+        }
+        Some(WrappedFailure::Panic(panic)) => {
+            if let Some(p) = panic.take() {
+                resume_unwind(p);
+            } else {
+                Error::PreviouslyResumedPanic
+            }
+        }
+        _ => {
+            let err_string = to_string(state, -1);
+            ffi::lua_pop(state, 1);
+
+            match err_code {
+                ffi::LUA_ERRRUN => Error::RuntimeError(err_string),
+                ffi::LUA_ERRSYNTAX => {
+                    Error::SyntaxError {
+                        // This seems terrible, but as far as I can tell, this is exactly what the
+                        // stock Lua REPL does.
+                        incomplete_input: err_string.ends_with("<eof>") || err_string.ends_with("'<eof>'"),
+                        message: err_string,
+                    }
+                }
+                ffi::LUA_ERRERR => {
+                    // This error is raised when the error handler raises an error too many times
+                    // recursively, and continuing to trigger the error handler would cause a stack
+                    // overflow. It is not very useful to differentiate between this and "ordinary"
+                    // runtime errors, so we handle them the same way.
+                    Error::RuntimeError(err_string)
+                }
+                ffi::LUA_ERRMEM => Error::MemoryError(err_string),
+                #[cfg(any(feature = "lua53", feature = "lua52"))]
+                ffi::LUA_ERRGCMM => Error::GarbageCollectorError(err_string),
+                _ => mlua_panic!("unrecognized lua error code"),
+            }
+        }
+    }
+}
+
+// Call a function that calls into the Lua API and may trigger a Lua error (longjmp) in a safe way.
+// Wraps the inner function in a call to `lua_pcall`, so the inner function only has access to a
+// limited lua stack. `nargs` is the same as the the parameter to `lua_pcall`, and `nresults` is
+// always `LUA_MULTRET`. Provided function must *not* panic, and since it will generally be
+// longjmping, should not contain any values that implements Drop.
+// Internally uses 2 extra stack spaces, and does not call checkstack.
+pub(crate) unsafe fn protect_lua_call(
+    state: *mut ffi::lua_State,
+    nargs: c_int,
+    f: unsafe extern "C-unwind" fn(*mut ffi::lua_State) -> c_int,
+) -> Result<()> {
+    let stack_start = ffi::lua_gettop(state) - nargs;
+
+    MemoryState::relax_limit_with(state, || {
+        ffi::lua_pushcfunction(state, error_traceback);
+        ffi::lua_pushcfunction(state, f);
+    });
+    if nargs > 0 {
+        ffi::lua_rotate(state, stack_start + 1, 2);
+    }
+
+    let ret = ffi::lua_pcall(state, nargs, ffi::LUA_MULTRET, stack_start + 1);
+    ffi::lua_remove(state, stack_start + 1);
+
+    if ret == ffi::LUA_OK {
+        Ok(())
+    } else {
+        Err(pop_error(state, ret))
+    }
+}
+
+// Call a function that calls into the Lua API and may trigger a Lua error (longjmp) in a safe way.
+// Wraps the inner function in a call to `lua_pcall`, so the inner function only has access to a
+// limited lua stack. `nargs` and `nresults` are similar to the parameters of `lua_pcall`, but the
+// given function return type is not the return value count, instead the inner function return
+// values are assumed to match the `nresults` param. Provided function must *not* panic, and since
+// it will generally be longjmping, should not contain any values that implements Drop.
+// Internally uses 3 extra stack spaces, and does not call checkstack.
+pub(crate) unsafe fn protect_lua_closure<F, R>(
+    state: *mut ffi::lua_State,
+    nargs: c_int,
+    nresults: c_int,
+    f: F,
+) -> Result<R>
+where
+    F: FnOnce(*mut ffi::lua_State) -> R,
+    R: Copy,
+{
+    struct Params<F, R: Copy> {
+        function: Option<F>,
+        result: MaybeUninit<R>,
+        nresults: c_int,
+    }
+
+    unsafe extern "C-unwind" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
+    where
+        F: FnOnce(*mut ffi::lua_State) -> R,
+        R: Copy,
+    {
+        let params = ffi::lua_touserdata(state, -1) as *mut Params<F, R>;
+        ffi::lua_pop(state, 1);
+
+        let f = (*params).function.take().unwrap();
+        (*params).result.write(f(state));
+
+        if (*params).nresults == ffi::LUA_MULTRET {
+            ffi::lua_gettop(state)
+        } else {
+            (*params).nresults
+        }
+    }
+
+    let stack_start = ffi::lua_gettop(state) - nargs;
+
+    MemoryState::relax_limit_with(state, || {
+        ffi::lua_pushcfunction(state, error_traceback);
+        ffi::lua_pushcfunction(state, do_call::<F, R>);
+    });
+    if nargs > 0 {
+        ffi::lua_rotate(state, stack_start + 1, 2);
+    }
+
+    let mut params = Params {
+        function: Some(f),
+        result: MaybeUninit::uninit(),
+        nresults,
+    };
+
+    ffi::lua_pushlightuserdata(state, &mut params as *mut Params<F, R> as *mut c_void);
+    let ret = ffi::lua_pcall(state, nargs + 1, nresults, stack_start + 1);
+    ffi::lua_remove(state, stack_start + 1);
+
+    if ret == ffi::LUA_OK {
+        // `LUA_OK` is only returned when the `do_call` function has completed successfully, so
+        // `params.result` is definitely initialized.
+        Ok(params.result.assume_init())
+    } else {
+        Err(pop_error(state, ret))
+    }
+}
+
+pub(crate) unsafe extern "C-unwind" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
+    // Luau calls error handler for memory allocation errors, skip it
+    // See https://github.com/luau-lang/luau/issues/880
+    #[cfg(feature = "luau")]
+    if MemoryState::limit_reached(state) {
+        return 0;
+    }
+
+    if ffi::lua_checkstack(state, 2) == 0 {
+        // If we don't have enough stack space to even check the error type, do
+        // nothing so we don't risk shadowing a rust panic.
+        return 1;
+    }
+
+    if get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
+        let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
+        if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+            ffi::luaL_traceback(state, state, s, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+
+    1
+}
+
+// A variant of `error_traceback` that can safely inspect another (yielded) thread stack
+pub(crate) unsafe fn error_traceback_thread(state: *mut ffi::lua_State, thread: *mut ffi::lua_State) {
+    // Move error object to the main thread to safely call `__tostring` metamethod if present
+    ffi::lua_xmove(thread, state, 1);
+
+    if get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
+        let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
+        if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+            ffi::luaL_traceback(state, thread, s, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+}
+
+// Initialize the error, panic, and destructed userdata metatables.
+pub(crate) unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
+    check_stack(state, 7)?;
+
+    // Create error and panic metatables
+
+    static ERROR_PRINT_BUFFER_KEY: u8 = 0;
+
+    unsafe extern "C-unwind" fn error_tostring(state: *mut ffi::lua_State) -> c_int {
+        callback_error(state, |_| {
+            check_stack(state, 3)?;
+
+            let err_buf = match get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref() {
+                Some(WrappedFailure::Error(error)) => {
+                    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
+                    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
+                    let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
+                    ffi::lua_pop(state, 2);
+
+                    (*err_buf).clear();
+                    // Depending on how the API is used and what error types scripts are given, it may
+                    // be possible to make this consume arbitrary amounts of memory (for example, some
+                    // kind of recursive error structure?)
+                    let _ = write!(&mut (*err_buf), "{error}");
+                    Ok(err_buf)
+                }
+                Some(WrappedFailure::Panic(Some(ref panic))) => {
+                    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
+                    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
+                    let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
+                    (*err_buf).clear();
+                    ffi::lua_pop(state, 2);
+
+                    if let Some(msg) = panic.downcast_ref::<&str>() {
+                        let _ = write!(&mut (*err_buf), "{msg}");
+                    } else if let Some(msg) = panic.downcast_ref::<String>() {
+                        let _ = write!(&mut (*err_buf), "{msg}");
+                    } else {
+                        let _ = write!(&mut (*err_buf), "<panic>");
+                    };
+                    Ok(err_buf)
+                }
+                Some(WrappedFailure::Panic(None)) => Err(Error::PreviouslyResumedPanic),
+                _ => {
+                    // I'm not sure whether this is possible to trigger without bugs in mlua?
+                    Err(Error::UserDataTypeMismatch)
+                }
+            }?;
+
+            push_string(state, (*err_buf).as_bytes(), true)?;
+            (*err_buf).clear();
+
+            Ok(1)
+        })
+    }
+
+    init_internal_metatable::<WrappedFailure>(
+        state,
+        Some(|state| {
+            ffi::lua_pushcfunction(state, error_tostring);
+            rawset_field(state, -2, "__tostring")
+        }),
+    )?;
+
+    // Create destructed userdata metatable
+
+    unsafe extern "C-unwind" fn destructed_error(state: *mut ffi::lua_State) -> c_int {
+        callback_error(state, |_| Err(Error::UserDataDestructed))
+    }
+
+    push_table(state, 0, 26, true)?;
+    ffi::lua_pushcfunction(state, destructed_error);
+    for &method in &[
+        "__add",
+        "__sub",
+        "__mul",
+        "__div",
+        "__mod",
+        "__pow",
+        "__unm",
+        #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
+        "__idiv",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__band",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__bor",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__bxor",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__bnot",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__shl",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__shr",
+        "__concat",
+        "__len",
+        "__eq",
+        "__lt",
+        "__le",
+        "__index",
+        "__newindex",
+        "__call",
+        "__tostring",
+        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit52"))]
+        "__pairs",
+        #[cfg(any(feature = "lua53", feature = "lua52", feature = "luajit52"))]
+        "__ipairs",
+        #[cfg(feature = "luau")]
+        "__iter",
+        #[cfg(feature = "lua54")]
+        "__close",
+    ] {
+        ffi::lua_pushvalue(state, -1);
+        rawset_field(state, -3, method)?;
+    }
+    ffi::lua_pop(state, 1);
+
+    protect_lua!(state, 1, 0, fn(state) {
+        let destructed_mt_key = &DESTRUCTED_USERDATA_METATABLE as *const u8 as *const c_void;
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, destructed_mt_key);
+    })?;
+
+    // Create error print buffer
+    init_internal_metatable::<String>(state, None)?;
+    push_internal_userdata(state, String::new(), true)?;
+    protect_lua!(state, 1, 0, fn(state) {
+        let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
+    })?;
+
+    Ok(())
+}

src/util/short_names.rs

@@ -25,22 +25,17 @@ pub(crate) fn short_type_name<T: ?Sized>() -> String {
 
         // Collapse everything up to the next special character,
         // then skip over it
-        if let Some(special_character_index) = rest_of_string
-            .find(|c: char| [' ', '<', '>', '(', ')', '[', ']', ',', ';'].contains(&c))
+        if let Some(special_character_index) =
+            rest_of_string.find(|c: char| [' ', '<', '>', '(', ')', '[', ']', ',', ';'].contains(&c))
         {
-            let segment_to_collapse = rest_of_string
-                .get(0..special_character_index)
-                .unwrap_or_default();
+            let segment_to_collapse = rest_of_string.get(0..special_character_index).unwrap_or_default();
             parsed_name += collapse_type_name(segment_to_collapse);
             // Insert the special character
-            let special_character =
-                &rest_of_string[special_character_index..=special_character_index];
+            let special_character = &rest_of_string[special_character_index..=special_character_index];
             parsed_name.push_str(special_character);
 
             match special_character {
-                ">" | ")" | "]"
-                    if rest_of_string[special_character_index + 1..].starts_with("::") =>
-                {
+                ">" | ")" | "]" if rest_of_string[special_character_index + 1..].starts_with("::") => {
                     parsed_name.push_str("::");
                     // Move the index past the "::"
                     index += special_character_index + 3;
@@ -77,9 +72,6 @@ mod tests {
             short_type_name::<HashMap<String, Option<[i32; 3]>>>(),
             "HashMap<String, Option<[i32; 3]>>"
         );
-        assert_eq!(
-            short_type_name::<dyn Fn(i32) -> i32>(),
-            "dyn Fn(i32) -> i32"
-        );
+        assert_eq!(short_type_name::<dyn Fn(i32) -> i32>(), "dyn Fn(i32) -> i32");
     }
 }

src/util/types.rs

@@ -0,0 +1,82 @@
+use std::any::Any;
+use std::os::raw::c_void;
+
+use crate::types::{Callback, CallbackUpvalue};
+
+#[cfg(feature = "async")]
+use crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue};
+
+pub(crate) trait TypeKey: Any {
+    fn type_key() -> *const c_void;
+}
+
+static STRING_TYPE_KEY: u8 = 0;
+
+impl TypeKey for String {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &STRING_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+static CALLBACK_TYPE_KEY: u8 = 0;
+
+impl TypeKey for Callback {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &CALLBACK_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+static CALLBACK_UPVALUE_TYPE_KEY: u8 = 0;
+
+impl TypeKey for CallbackUpvalue {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &CALLBACK_UPVALUE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static ASYNC_CALLBACK_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for AsyncCallback {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &ASYNC_CALLBACK_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static ASYNC_CALLBACK_UPVALUE_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for AsyncCallbackUpvalue {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &ASYNC_CALLBACK_UPVALUE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static ASYNC_POLL_UPVALUE_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for AsyncPollUpvalue {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &ASYNC_POLL_UPVALUE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static WAKER_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for Option<std::task::Waker> {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &WAKER_TYPE_KEY as *const u8 as *const c_void
+    }
+}

src/util/userdata.rs

@@ -0,0 +1,170 @@
+use std::os::raw::{c_int, c_void};
+use std::{mem, ptr};
+
+use crate::error::Result;
+use crate::userdata::collect_userdata;
+use crate::util::{check_stack, get_metatable_ptr, push_table, rawset_field, TypeKey};
+
+// Pushes the userdata and attaches a metatable with __gc method.
+// Internally uses 3 stack spaces, does not call checkstack.
+pub(crate) unsafe fn push_internal_userdata<T: TypeKey>(
+    state: *mut ffi::lua_State,
+    t: T,
+    protect: bool,
+) -> Result<*mut T> {
+    #[cfg(not(feature = "luau"))]
+    let ud_ptr = if protect {
+        protect_lua!(state, 0, 1, move |state| {
+            let ud_ptr = ffi::lua_newuserdata(state, const { mem::size_of::<T>() }) as *mut T;
+            ptr::write(ud_ptr, t);
+            ud_ptr
+        })?
+    } else {
+        let ud_ptr = ffi::lua_newuserdata(state, const { mem::size_of::<T>() }) as *mut T;
+        ptr::write(ud_ptr, t);
+        ud_ptr
+    };
+
+    #[cfg(feature = "luau")]
+    let ud_ptr = if protect {
+        protect_lua!(state, 0, 1, move |state| ffi::lua_newuserdata_t::<T>(state, t))?
+    } else {
+        ffi::lua_newuserdata_t::<T>(state, t)
+    };
+
+    get_internal_metatable::<T>(state);
+    ffi::lua_setmetatable(state, -2);
+    Ok(ud_ptr)
+}
+
+#[track_caller]
+pub(crate) unsafe fn get_internal_metatable<T: TypeKey>(state: *mut ffi::lua_State) {
+    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, T::type_key());
+    debug_assert!(ffi::lua_isnil(state, -1) == 0, "internal metatable not found");
+}
+
+// Initialize the internal metatable for a type T (with __gc method).
+// Uses 6 stack spaces and calls checkstack.
+pub(crate) unsafe fn init_internal_metatable<T: TypeKey>(
+    state: *mut ffi::lua_State,
+    customize_fn: Option<fn(*mut ffi::lua_State) -> Result<()>>,
+) -> Result<()> {
+    check_stack(state, 6)?;
+
+    push_table(state, 0, 3, true)?;
+
+    #[cfg(not(feature = "luau"))]
+    {
+        ffi::lua_pushcfunction(state, collect_userdata::<T>);
+        rawset_field(state, -2, "__gc")?;
+    }
+
+    ffi::lua_pushboolean(state, 0);
+    rawset_field(state, -2, "__metatable")?;
+
+    if let Some(f) = customize_fn {
+        f(state)?;
+    }
+
+    protect_lua!(state, 1, 0, |state| {
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, T::type_key());
+    })?;
+
+    Ok(())
+}
+
+// Uses 2 stack spaces, does not call checkstack
+pub(crate) unsafe fn get_internal_userdata<T: TypeKey>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+    mut type_mt_ptr: *const c_void,
+) -> *mut T {
+    let ud = ffi::lua_touserdata(state, index) as *mut T;
+    if ud.is_null() {
+        return ptr::null_mut();
+    }
+    let mt_ptr = get_metatable_ptr(state, index);
+    if type_mt_ptr.is_null() {
+        get_internal_metatable::<T>(state);
+        type_mt_ptr = ffi::lua_topointer(state, -1);
+        ffi::lua_pop(state, 1);
+    }
+    if mt_ptr != type_mt_ptr {
+        return ptr::null_mut();
+    }
+    ud
+}
+
+// Internally uses 3 stack spaces, does not call checkstack.
+#[inline]
+#[cfg(not(feature = "luau"))]
+pub(crate) unsafe fn push_uninit_userdata<T>(state: *mut ffi::lua_State, protect: bool) -> Result<*mut T> {
+    if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdata(state, const { mem::size_of::<T>() }) as *mut T
+        })
+    } else {
+        Ok(ffi::lua_newuserdata(state, const { mem::size_of::<T>() }) as *mut T)
+    }
+}
+
+// Internally uses 3 stack spaces, does not call checkstack.
+#[inline]
+pub(crate) unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<*mut T> {
+    let size = const { mem::size_of::<T>() };
+
+    #[cfg(not(feature = "luau"))]
+    let ud_ptr = if protect {
+        protect_lua!(state, 0, 1, move |state| ffi::lua_newuserdata(state, size))?
+    } else {
+        ffi::lua_newuserdata(state, size)
+    } as *mut T;
+
+    #[cfg(feature = "luau")]
+    let ud_ptr = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdatadtor(state, size, collect_userdata::<T>)
+        })?
+    } else {
+        ffi::lua_newuserdatadtor(state, size, collect_userdata::<T>)
+    } as *mut T;
+
+    ptr::write(ud_ptr, t);
+    Ok(ud_ptr)
+}
+
+#[inline]
+#[track_caller]
+pub(crate) unsafe fn get_userdata<T>(state: *mut ffi::lua_State, index: c_int) -> *mut T {
+    let ud = ffi::lua_touserdata(state, index) as *mut T;
+    mlua_debug_assert!(!ud.is_null(), "userdata pointer is null");
+    ud
+}
+
+// Pops the userdata off of the top of the stack and returns it to rust, invalidating the lua
+// userdata and gives it the special "destructed" userdata metatable. Userdata must not have been
+// previously invalidated, and this method does not check for this.
+// Uses 1 extra stack space and does not call checkstack.
+pub(crate) unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
+    // We set the metatable of userdata on __gc to a special table with no __gc method and with
+    // metamethods that trigger an error on access. We do this so that it will not be double
+    // dropped, and also so that it cannot be used or identified as any particular userdata type
+    // after the first call to __gc.
+    get_destructed_userdata_metatable(state);
+    ffi::lua_setmetatable(state, -2);
+    let ud = get_userdata::<T>(state, -1);
+
+    // Update userdata tag to disable destructor and mark as destructed
+    #[cfg(feature = "luau")]
+    ffi::lua_setuserdatatag(state, -1, 1);
+
+    ffi::lua_pop(state, 1);
+    ptr::read(ud)
+}
+
+pub(crate) unsafe fn get_destructed_userdata_metatable(state: *mut ffi::lua_State) {
+    let key = &DESTRUCTED_USERDATA_METATABLE as *const u8 as *const c_void;
+    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, key);
+}
+
+pub(crate) static DESTRUCTED_USERDATA_METATABLE: u8 = 0;

src/value.rs

@@ -1,15 +1,20 @@
-use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::HashSet;
-use std::iter;
-use std::ops::Index;
-use std::os::raw::{c_int, c_void};
+use std::os::raw::c_void;
 use std::string::String as StdString;
-use std::sync::Arc;
-use std::{fmt, mem, ptr, slice, str, vec};
+use std::{fmt, ptr, str};
 
 use num_traits::FromPrimitive;
 
+use crate::error::{Error, Result};
+use crate::function::Function;
+use crate::string::{BorrowedStr, String};
+use crate::table::Table;
+use crate::thread::Thread;
+use crate::types::{Integer, LightUserData, Number, ValueRef};
+use crate::userdata::AnyUserData;
+use crate::util::{check_stack, StackGuard};
+
 #[cfg(feature = "serialize")]
 use {
     crate::table::SerializableTable,
@@ -18,21 +23,13 @@ use {
     std::{cell::RefCell, rc::Rc, result::Result as StdResult},
 };
 
-use crate::error::{Error, Result};
-use crate::function::Function;
-use crate::lua::Lua;
-use crate::string::String;
-use crate::table::Table;
-use crate::thread::Thread;
-use crate::types::{Integer, LightUserData, Number, SubtypeId};
-use crate::userdata::AnyUserData;
-use crate::util::{check_stack, StackGuard};
-
-/// A dynamically typed Lua value. The `String`, `Table`, `Function`, `Thread`, and `UserData`
-/// variants contain handle types into the internal Lua state. It is a logic error to mix handle
-/// types between separate `Lua` instances, and doing so will result in a panic.
+/// A dynamically typed Lua value.
+///
+/// The non-primitive variants (eg. string/table/function/thread/userdata) contain handle types
+/// into the internal Lua state. It is a logic error to mix handle types between separate
+/// `Lua` instances, and doing so will result in a panic.
 #[derive(Clone)]
-pub enum Value<'lua> {
+pub enum Value {
     /// The Lua value `nil`.
     Nil,
     /// The Lua value `true` or `false`.
@@ -48,34 +45,41 @@ pub enum Value<'lua> {
     /// A Luau vector.
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    Vector(crate::types::Vector),
+    Vector(crate::Vector),
     /// An interned string, managed by Lua.
     ///
     /// Unlike Rust strings, Lua strings may not be valid UTF-8.
-    String(String<'lua>),
+    String(String),
     /// Reference to a Lua table.
-    Table(Table<'lua>),
+    Table(Table),
     /// Reference to a Lua function (or closure).
-    Function(Function<'lua>),
+    Function(Function),
     /// Reference to a Lua thread (or coroutine).
-    Thread(Thread<'lua>),
+    Thread(Thread),
     /// Reference to a userdata object that holds a custom type which implements `UserData`.
+    ///
     /// Special builtin userdata types will be represented as other `Value` variants.
-    UserData(AnyUserData<'lua>),
+    UserData(AnyUserData),
+    /// A Luau buffer.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    Buffer(crate::Buffer),
     /// `Error` is a special builtin userdata type. When received from Lua it is implicitly cloned.
-    Error(Error),
+    Error(Box<Error>),
+    /// Any other value not known to mlua (eg. LuaJIT CData).
+    Other(#[doc(hidden)] ValueRef),
 }
 
 pub use self::Value::Nil;
 
-impl<'lua> Value<'lua> {
+impl Value {
     /// A special value (lightuserdata) to represent null value.
     ///
     /// It can be used in Lua tables without downsides of `nil`.
-    pub const NULL: Value<'static> = Value::LightUserData(LightUserData(ptr::null_mut()));
+    pub const NULL: Value = Value::LightUserData(LightUserData(ptr::null_mut()));
 
     /// Returns type name of this value.
-    pub const fn type_name(&self) -> &'static str {
+    pub fn type_name(&self) -> &'static str {
         match *self {
             Value::Nil => "nil",
             Value::Boolean(_) => "boolean",
@@ -88,27 +92,26 @@ impl<'lua> Value<'lua> {
             Value::Table(_) => "table",
             Value::Function(_) => "function",
             Value::Thread(_) => "thread",
-            Value::UserData(AnyUserData(_, SubtypeId::None)) => "userdata",
+            Value::UserData(_) => "userdata",
             #[cfg(feature = "luau")]
-            Value::UserData(AnyUserData(_, SubtypeId::Buffer)) => "buffer",
-            #[cfg(feature = "luajit")]
-            Value::UserData(AnyUserData(_, SubtypeId::CData)) => "cdata",
+            Value::Buffer(_) => "buffer",
             Value::Error(_) => "error",
+            Value::Other(_) => "other",
         }
     }
 
     /// Compares two values for equality.
     ///
     /// Equality comparisons do not convert strings to numbers or vice versa.
-    /// Tables, Functions, Threads, and Userdata are compared by reference:
+    /// Tables, functions, threads, and userdata are compared by reference:
     /// two objects are considered equal only if they are the same object.
     ///
-    /// If Tables or Userdata have `__eq` metamethod then mlua will try to invoke it.
+    /// If table or userdata have `__eq` metamethod then mlua will try to invoke it.
     /// The first value is checked first. If that value does not define a metamethod
     /// for `__eq`, then mlua will check the second value.
     /// Then mlua calls the metamethod with the two values as arguments, if found.
-    pub fn equals<T: AsRef<Self>>(&self, other: T) -> Result<bool> {
-        match (self, other.as_ref()) {
+    pub fn equals(&self, other: &Self) -> Result<bool> {
+        match (self, other) {
             (Value::Table(a), Value::Table(b)) => a.equals(b),
             (Value::UserData(a), Value::UserData(b)) => a.equals(b),
             (a, b) => Ok(a == b),
@@ -117,28 +120,50 @@ impl<'lua> Value<'lua> {
 
     /// Converts the value to a generic C pointer.
     ///
-    /// The value can be a userdata, a table, a thread, a string, or a function; otherwise it returns NULL.
-    /// Different objects will give different pointers.
+    /// The value can be a userdata, a table, a thread, a string, or a function; otherwise it
+    /// returns NULL. Different objects will give different pointers.
     /// There is no way to convert the pointer back to its original value.
     ///
     /// Typically this function is used only for hashing and debug information.
     #[inline]
     pub fn to_pointer(&self) -> *const c_void {
         match self {
+            Value::String(String(vref)) => {
+                // In Lua < 5.4 (excluding Luau), string pointers are NULL
+                // Use alternative approach
+                let lua = vref.lua.lock();
+                unsafe { ffi::lua_tostring(lua.ref_thread(), vref.index) as *const c_void }
+            }
             Value::LightUserData(ud) => ud.0,
-            Value::String(String(r))
-            | Value::Table(Table(r))
-            | Value::Function(Function(r))
-            | Value::Thread(Thread(r, ..))
-            | Value::UserData(AnyUserData(r, ..)) => r.to_pointer(),
+            Value::Table(Table(vref))
+            | Value::Function(Function(vref))
+            | Value::Thread(Thread(vref, ..))
+            | Value::UserData(AnyUserData(vref))
+            | Value::Other(vref) => vref.to_pointer(),
+            #[cfg(feature = "luau")]
+            Value::Buffer(crate::Buffer(vref)) => vref.to_pointer(),
             _ => ptr::null(),
         }
     }
 
     /// Converts the value to a string.
     ///
-    /// If the value has a metatable with a `__tostring` method, then it will be called to get the result.
+    /// This might invoke the `__tostring` metamethod for non-primitive types (eg. tables,
+    /// functions).
     pub fn to_string(&self) -> Result<StdString> {
+        unsafe fn invoke_to_string(vref: &ValueRef) -> Result<StdString> {
+            let lua = vref.lua.lock();
+            let state = lua.state();
+            let _guard = StackGuard::new(state);
+            check_stack(state, 3)?;
+
+            lua.push_ref(vref);
+            protect_lua!(state, 1, 1, fn(state) {
+                ffi::luaL_tolstring(state, -1, ptr::null_mut());
+            })?;
+            Ok(String(lua.pop_ref()).to_str()?.to_string())
+        }
+
         match self {
             Value::Nil => Ok("nil".to_string()),
             Value::Boolean(b) => Ok(b.to_string()),
@@ -149,20 +174,13 @@ impl<'lua> Value<'lua> {
             #[cfg(feature = "luau")]
             Value::Vector(v) => Ok(v.to_string()),
             Value::String(s) => Ok(s.to_str()?.to_string()),
-            Value::Table(Table(r))
-            | Value::Function(Function(r))
-            | Value::Thread(Thread(r, ..))
-            | Value::UserData(AnyUserData(r, ..)) => unsafe {
-                let state = r.lua.state();
-                let _guard = StackGuard::new(state);
-                check_stack(state, 3)?;
-
-                r.lua.push_ref(r);
-                protect_lua!(state, 1, 1, fn(state) {
-                    ffi::luaL_tolstring(state, -1, ptr::null_mut());
-                })?;
-                Ok(String(r.lua.pop_ref()).to_str()?.to_string())
-            },
+            Value::Table(Table(vref))
+            | Value::Function(Function(vref))
+            | Value::Thread(Thread(vref, ..))
+            | Value::UserData(AnyUserData(vref))
+            | Value::Other(vref) => unsafe { invoke_to_string(vref) },
+            #[cfg(feature = "luau")]
+            Value::Buffer(crate::Buffer(vref)) => unsafe { invoke_to_string(vref) },
             Value::Error(err) => Ok(err.to_string()),
         }
     }
@@ -174,6 +192,8 @@ impl<'lua> Value<'lua> {
     }
 
     /// Returns `true` if the value is a [`NULL`].
+    ///
+    /// [`NULL`]: Value::NULL
     #[inline]
     pub fn is_null(&self) -> bool {
         self == &Self::NULL
@@ -252,7 +272,10 @@ 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> {
-        self.as_integer().map(i64::from)
+        #[cfg(target_pointer_width = "64")]
+        return self.as_integer();
+        #[cfg(not(target_pointer_width = "64"))]
+        return self.as_integer().map(i64::from);
     }
 
     /// Cast the value to `u64`.
@@ -329,19 +352,20 @@ impl<'lua> Value<'lua> {
         }
     }
 
-    /// Cast the value to [`str`].
+    /// Cast the value to [`BorrowedStr`].
     ///
-    /// If the value is a Lua [`String`], try to convert it to [`str`] or return `None` otherwise.
+    /// If the value is a Lua [`String`], try to convert it to [`BorrowedStr`] or return `None`
+    /// otherwise.
     #[inline]
-    pub fn as_str(&self) -> Option<&str> {
+    pub fn as_str(&self) -> Option<BorrowedStr> {
         self.as_string().and_then(|s| s.to_str().ok())
     }
 
-    /// Cast the value to [`Cow<str>`].
+    /// Cast the value to [`StdString`].
     ///
-    /// If the value is a Lua [`String`], converts it to [`Cow<str>`] or returns `None` otherwise.
+    /// If the value is a Lua [`String`], converts it to [`StdString`] or returns `None` otherwise.
     #[inline]
-    pub fn as_string_lossy(&self) -> Option<Cow<str>> {
+    pub fn as_string_lossy(&self) -> Option<StdString> {
         self.as_string().map(|s| s.to_string_lossy())
     }
 
@@ -413,26 +437,45 @@ impl<'lua> Value<'lua> {
         }
     }
 
-    /// Returns `true` if the value is a Buffer wrapped in [`AnyUserData`].
+    /// Cast the value to a [`Buffer`].
+    ///
+    /// If the value is [`Buffer`], returns it or `None` otherwise.
+    ///
+    /// [`Buffer`]: crate::Buffer
     #[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()
+    pub fn as_buffer(&self) -> Option<&crate::Buffer> {
+        match self {
+            Value::Buffer(b) => Some(b),
+            _ => None,
+        }
     }
 
-    /// 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)]
+    /// Returns `true` if the value is a [`Buffer`].
+    ///
+    /// [`Buffer`]: crate::Buffer
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     #[inline]
-    pub fn is_cdata(&self) -> bool {
-        self.as_userdata()
-            .map(|ud| ud.1 == SubtypeId::CData)
-            .unwrap_or_default()
+    pub fn is_buffer(&self) -> bool {
+        self.as_buffer().is_some()
+    }
+
+    /// Returns `true` if the value is an [`Error`].
+    #[inline]
+    pub fn is_error(&self) -> bool {
+        self.as_error().is_some()
+    }
+
+    /// Cast the value to [`Error`].
+    ///
+    /// If the value is an [`Error`], returns it or `None` otherwise.
+    pub fn as_error(&self) -> Option<&Error> {
+        match self {
+            Value::Error(e) => Some(e),
+            _ => None,
+        }
     }
 
     /// Wrap reference to this Value into [`SerializableValue`].
@@ -441,13 +484,13 @@ impl<'lua> Value<'lua> {
     #[cfg(feature = "serialize")]
     #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
     #[doc(hidden)]
-    pub fn to_serializable(&self) -> SerializableValue<'_, 'lua> {
+    pub fn to_serializable(&self) -> SerializableValue {
         SerializableValue::new(self, Default::default(), None)
     }
 
     // Compares two values.
     // Used to sort values for Debug printing.
-    pub(crate) fn cmp(&self, other: &Self) -> Ordering {
+    pub(crate) fn sort_cmp(&self, other: &Self) -> Ordering {
         fn cmp_num(a: Number, b: Number) -> Ordering {
             match (a, b) {
                 _ if a < b => Ordering::Less,
@@ -471,16 +514,19 @@ impl<'lua> Value<'lua> {
             (_, Value::Boolean(_)) => Ordering::Greater,
             // Integer && Number
             (Value::Integer(a), Value::Integer(b)) => a.cmp(b),
-            (&Value::Integer(a), &Value::Number(b)) => cmp_num(a as Number, b),
-            (&Value::Number(a), &Value::Integer(b)) => cmp_num(a, b as Number),
-            (&Value::Number(a), &Value::Number(b)) => cmp_num(a, b),
+            (Value::Integer(a), Value::Number(b)) => cmp_num(*a as Number, *b),
+            (Value::Number(a), Value::Integer(b)) => cmp_num(*a, *b as Number),
+            (Value::Number(a), Value::Number(b)) => cmp_num(*a, *b),
             (Value::Integer(_) | Value::Number(_), _) => Ordering::Less,
             (_, Value::Integer(_) | Value::Number(_)) => Ordering::Greater,
+            // Vector (Luau)
+            #[cfg(feature = "luau")]
+            (Value::Vector(a), Value::Vector(b)) => a.partial_cmp(b).unwrap_or(Ordering::Equal),
             // String
-            (Value::String(a), Value::String(b)) => a.as_bytes().cmp(b.as_bytes()),
+            (Value::String(a), Value::String(b)) => a.as_bytes().cmp(&b.as_bytes()),
             (Value::String(_), _) => Ordering::Less,
             (_, Value::String(_)) => Ordering::Greater,
-            // Other variants can be randomly ordered
+            // Other variants can be ordered by their pointer
             (a, b) => a.to_pointer().cmp(&b.to_pointer()),
         }
     }
@@ -517,17 +563,27 @@ impl<'lua> Value<'lua> {
                     .unwrap_or_else(|| format!("userdata: {:?}", u.to_pointer()));
                 write!(fmt, "{s}")
             }
+            #[cfg(feature = "luau")]
+            buf @ Value::Buffer(_) => write!(fmt, "buffer: {:?}", buf.to_pointer()),
             Value::Error(e) if recursive => write!(fmt, "{e:?}"),
             Value::Error(_) => write!(fmt, "error"),
+            Value::Other(v) => write!(fmt, "other: {:?}", v.to_pointer()),
         }
     }
 }
 
-impl fmt::Debug for Value<'_> {
+impl Default for Value {
+    fn default() -> Self {
+        Self::Nil
+    }
+}
+
+impl fmt::Debug for Value {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         if fmt.alternate() {
             return self.fmt_pretty(fmt, true, 0, &mut HashSet::new());
         }
+
         match self {
             Value::Nil => write!(fmt, "Nil"),
             Value::Boolean(b) => write!(fmt, "Boolean({b})"),
@@ -541,12 +597,15 @@ impl fmt::Debug for Value<'_> {
             Value::Function(f) => write!(fmt, "{f:?}"),
             Value::Thread(t) => write!(fmt, "{t:?}"),
             Value::UserData(ud) => write!(fmt, "{ud:?}"),
+            #[cfg(feature = "luau")]
+            Value::Buffer(buf) => write!(fmt, "{buf:?}"),
             Value::Error(e) => write!(fmt, "Error({e:?})"),
+            Value::Other(v) => write!(fmt, "Other({v:?})"),
         }
     }
 }
 
-impl<'lua> PartialEq for Value<'lua> {
+impl PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Value::Nil, Value::Nil) => true,
@@ -563,30 +622,25 @@ impl<'lua> PartialEq for Value<'lua> {
             (Value::Function(a), Value::Function(b)) => a == b,
             (Value::Thread(a), Value::Thread(b)) => a == b,
             (Value::UserData(a), Value::UserData(b)) => a == b,
+            #[cfg(feature = "luau")]
+            (Value::Buffer(a), Value::Buffer(b)) => a == b,
             _ => false,
         }
     }
 }
 
-impl<'lua> AsRef<Value<'lua>> for Value<'lua> {
-    #[inline]
-    fn as_ref(&self) -> &Self {
-        self
-    }
-}
-
 /// A wrapped [`Value`] with customized serialization behavior.
 #[cfg(feature = "serialize")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
-pub struct SerializableValue<'a, 'lua> {
-    value: &'a Value<'lua>,
+pub struct SerializableValue<'a> {
+    value: &'a Value,
     options: crate::serde::de::Options,
     // In many cases we don't need `visited` map, so don't allocate memory by default
     visited: Option<Rc<RefCell<FxHashSet<*const c_void>>>>,
 }
 
 #[cfg(feature = "serialize")]
-impl<'lua> Serialize for Value<'lua> {
+impl Serialize for Value {
     #[inline]
     fn serialize<S: Serializer>(&self, serializer: S) -> StdResult<S::Ok, S::Error> {
         SerializableValue::new(self, Default::default(), None).serialize(serializer)
@@ -594,10 +648,10 @@ impl<'lua> Serialize for Value<'lua> {
 }
 
 #[cfg(feature = "serialize")]
-impl<'a, 'lua> SerializableValue<'a, 'lua> {
+impl<'a> SerializableValue<'a> {
     #[inline]
     pub(crate) fn new(
-        value: &'a Value<'lua>,
+        value: &'a Value,
         options: crate::serde::de::Options,
         visited: Option<&Rc<RefCell<FxHashSet<*const c_void>>>>,
     ) -> Self {
@@ -646,10 +700,19 @@ impl<'a, 'lua> SerializableValue<'a, 'lua> {
         self.options.sort_keys = enabled;
         self
     }
+
+    /// If true, empty Lua tables will be encoded as array, instead of map.
+    ///
+    /// Default: **false**
+    #[must_use]
+    pub const fn encode_empty_tables_as_array(mut self, enabled: bool) -> Self {
+        self.options.encode_empty_tables_as_array = enabled;
+        self
+    }
 }
 
 #[cfg(feature = "serialize")]
-impl<'a, 'lua> Serialize for SerializableValue<'a, 'lua> {
+impl Serialize for SerializableValue<'_> {
     fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
     where
         S: Serializer,
@@ -671,11 +734,14 @@ impl<'a, 'lua> Serialize for SerializableValue<'a, 'lua> {
             Value::UserData(ud) if ud.is_serializable() || self.options.deny_unsupported_types => {
                 ud.serialize(serializer)
             }
+            #[cfg(feature = "luau")]
+            Value::Buffer(buf) => buf.serialize(serializer),
             Value::Function(_)
             | Value::Thread(_)
             | Value::UserData(_)
             | Value::LightUserData(_)
-            | Value::Error(_) => {
+            | Value::Error(_)
+            | Value::Other(_) => {
                 if self.options.deny_unsupported_types {
                     let msg = format!("cannot serialize <{}>", self.value.type_name());
                     Err(ser::Error::custom(msg))
@@ -687,322 +753,12 @@ impl<'a, 'lua> Serialize for SerializableValue<'a, 'lua> {
     }
 }
 
-/// Trait for types convertible to `Value`.
-pub trait IntoLua<'lua>: Sized {
-    /// Performs the conversion.
-    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>>;
-
-    /// Pushes the value into the Lua stack.
-    ///
-    /// # Safety
-    /// This method does not check Lua stack space.
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn push_into_stack(self, lua: &'lua Lua) -> Result<()> {
-        lua.push_value(self.into_lua(lua)?)
-    }
-}
-
-/// Trait for types convertible from `Value`.
-pub trait FromLua<'lua>: Sized {
-    /// Performs the conversion.
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self>;
-
-    /// Performs the conversion for an argument (eg. function argument).
-    ///
-    /// `i` is the argument index (position),
-    /// `to` is a function name that received the argument.
-    #[doc(hidden)]
-    #[inline]
-    fn from_lua_arg(arg: Value<'lua>, i: usize, to: Option<&str>, lua: &'lua Lua) -> Result<Self> {
-        Self::from_lua(arg, lua).map_err(|err| Error::BadArgument {
-            to: to.map(|s| s.to_string()),
-            pos: i,
-            name: None,
-            cause: Arc::new(err),
-        })
-    }
-
-    /// Performs the conversion for a value in the Lua stack at index `idx`.
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn from_stack(idx: c_int, lua: &'lua Lua) -> Result<Self> {
-        Self::from_lua(lua.stack_value(idx), lua)
-    }
-
-    /// Same as `from_lua_arg` but for a value in the Lua stack at index `idx`.
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn from_stack_arg(
-        idx: c_int,
-        i: usize,
-        to: Option<&str>,
-        lua: &'lua Lua,
-    ) -> Result<Self> {
-        Self::from_stack(idx, lua).map_err(|err| Error::BadArgument {
-            to: to.map(|s| s.to_string()),
-            pos: i,
-            name: None,
-            cause: Arc::new(err),
-        })
-    }
-}
-
-/// Multiple Lua values used for both argument passing and also for multiple return values.
-#[derive(Debug, Clone)]
-pub struct MultiValue<'lua> {
-    vec: Vec<Value<'lua>>,
-    lua: Option<&'lua Lua>,
-}
-
-impl Drop for MultiValue<'_> {
-    fn drop(&mut self) {
-        if let Some(lua) = self.lua {
-            let vec = mem::take(&mut self.vec);
-            lua.push_multivalue_to_pool(vec);
-        }
-    }
-}
-
-impl<'lua> MultiValue<'lua> {
-    /// Creates an empty `MultiValue` containing no values.
-    pub const fn new() -> MultiValue<'lua> {
-        MultiValue {
-            vec: Vec::new(),
-            lua: None,
-        }
-    }
-
-    /// Similar to `new` but can reuse previously used container with allocated capacity.
-    #[inline]
-    pub(crate) fn with_lua_and_capacity(lua: &'lua Lua, capacity: usize) -> MultiValue<'lua> {
-        let vec = lua
-            .pop_multivalue_from_pool()
-            .map(|mut vec| {
-                vec.reserve(capacity);
-                vec
-            })
-            .unwrap_or_else(|| Vec::with_capacity(capacity));
-        MultiValue {
-            vec,
-            lua: Some(lua),
-        }
-    }
-}
-
-impl<'lua> Default for MultiValue<'lua> {
-    #[inline]
-    fn default() -> MultiValue<'lua> {
-        MultiValue::new()
-    }
-}
-
-impl<'lua> FromIterator<Value<'lua>> for MultiValue<'lua> {
-    #[inline]
-    fn from_iter<I: IntoIterator<Item = Value<'lua>>>(iter: I) -> Self {
-        MultiValue::from_vec(Vec::from_iter(iter))
-    }
-}
-
-impl<'lua> IntoIterator for MultiValue<'lua> {
-    type Item = Value<'lua>;
-    type IntoIter = iter::Rev<vec::IntoIter<Value<'lua>>>;
-
-    #[inline]
-    fn into_iter(mut self) -> Self::IntoIter {
-        let vec = mem::take(&mut self.vec);
-        mem::forget(self);
-        vec.into_iter().rev()
-    }
-}
-
-impl<'a, 'lua> IntoIterator for &'a MultiValue<'lua> {
-    type Item = &'a Value<'lua>;
-    type IntoIter = iter::Rev<slice::Iter<'a, Value<'lua>>>;
-
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        self.vec.iter().rev()
-    }
-}
-
-impl<'lua> Index<usize> for MultiValue<'lua> {
-    type Output = Value<'lua>;
-
-    #[inline]
-    fn index(&self, index: usize) -> &Self::Output {
-        if let Some(result) = self.get(index) {
-            result
-        } else {
-            panic!(
-                "index out of bounds: the len is {} but the index is {}",
-                self.len(),
-                index
-            )
-        }
-    }
-}
-
-impl<'lua> MultiValue<'lua> {
-    #[inline]
-    pub fn from_vec(mut vec: Vec<Value<'lua>>) -> MultiValue<'lua> {
-        vec.reverse();
-        MultiValue { vec, lua: None }
-    }
-
-    #[inline]
-    pub fn into_vec(mut self) -> Vec<Value<'lua>> {
-        let mut vec = mem::take(&mut self.vec);
-        mem::forget(self);
-        vec.reverse();
-        vec
-    }
-
-    #[inline]
-    pub fn get(&self, index: usize) -> Option<&Value<'lua>> {
-        if index < self.vec.len() {
-            return self.vec.get(self.vec.len() - index - 1);
-        }
-        None
-    }
-
-    #[inline]
-    pub fn pop_front(&mut self) -> Option<Value<'lua>> {
-        self.vec.pop()
-    }
-
-    #[inline]
-    pub fn push_front(&mut self, value: Value<'lua>) {
-        self.vec.push(value);
-    }
-
-    #[inline]
-    pub fn clear(&mut self) {
-        self.vec.clear();
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.vec.len()
-    }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.vec.is_empty()
-    }
-
-    #[inline]
-    pub fn iter(&self) -> iter::Rev<slice::Iter<Value<'lua>>> {
-        self.vec.iter().rev()
-    }
-
-    #[inline]
-    pub(crate) fn drain_all(&mut self) -> iter::Rev<vec::Drain<Value<'lua>>> {
-        self.vec.drain(..).rev()
-    }
-
-    #[inline]
-    pub(crate) fn refill(
-        &mut self,
-        iter: impl IntoIterator<Item = Result<Value<'lua>>>,
-    ) -> Result<()> {
-        self.vec.clear();
-        for value in iter {
-            self.vec.push(value?);
-        }
-        self.vec.reverse();
-        Ok(())
-    }
-}
-
-/// Trait for types convertible to any number of Lua values.
-///
-/// This is a generalization of `IntoLua`, allowing any number of resulting Lua values instead of just
-/// one. Any type that implements `IntoLua` will automatically implement this trait.
-pub trait IntoLuaMulti<'lua>: Sized {
-    /// Performs the conversion.
-    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>>;
-
-    /// Pushes the values into the Lua stack.
-    ///
-    /// Returns number of pushed values.
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
-        let mut values = self.into_lua_multi(lua)?;
-        let len: c_int = values.len().try_into().unwrap();
-        unsafe {
-            check_stack(lua.state(), len + 1)?;
-            for v in values.drain_all() {
-                lua.push_value(v)?;
-            }
-        }
-        Ok(len)
-    }
-}
-
-/// Trait for types that can be created from an arbitrary number of Lua values.
-///
-/// This is a generalization of `FromLua`, allowing an arbitrary number of Lua values to participate
-/// in the conversion. Any type that implements `FromLua` will automatically implement this trait.
-pub trait FromLuaMulti<'lua>: Sized {
-    /// Performs the conversion.
-    ///
-    /// In case `values` contains more values than needed to perform the conversion, the excess
-    /// values should be ignored. This reflects the semantics of Lua when calling a function or
-    /// assigning values. Similarly, if not enough values are given, conversions should assume that
-    /// any missing values are nil.
-    fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self>;
-
-    /// Performs the conversion for a list of arguments.
-    ///
-    /// `i` is an index (position) of the first argument,
-    /// `to` is a function name that received the arguments.
-    #[doc(hidden)]
-    #[inline]
-    fn from_lua_args(
-        args: MultiValue<'lua>,
-        i: usize,
-        to: Option<&str>,
-        lua: &'lua Lua,
-    ) -> Result<Self> {
-        let _ = (i, to);
-        Self::from_lua_multi(args, lua)
-    }
-
-    /// Performs the conversion for a number of values in the Lua stack.
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn from_stack_multi(nvals: c_int, lua: &'lua Lua) -> Result<Self> {
-        let mut values = MultiValue::with_lua_and_capacity(lua, nvals as usize);
-        for idx in 1..=nvals {
-            values.push_front(lua.stack_value(-idx));
-        }
-        if nvals > 0 {
-            // It's safe to clear the stack as all references moved to ref thread
-            ffi::lua_pop(lua.state(), nvals);
-        }
-        Self::from_lua_multi(values, lua)
-    }
-
-    /// Same as `from_lua_args` but for a number of values in the Lua stack.
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn from_stack_args(
-        nargs: c_int,
-        i: usize,
-        to: Option<&str>,
-        lua: &'lua Lua,
-    ) -> Result<Self> {
-        let _ = (i, to);
-        Self::from_stack_multi(nargs, lua)
-    }
-}
-
 #[cfg(test)]
 mod assertions {
     use super::*;
 
+    #[cfg(not(feature = "send"))]
     static_assertions::assert_not_impl_any!(Value: Send);
-    static_assertions::assert_not_impl_any!(MultiValue: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Value: Send, Sync);
 }

src/vector.rs

@@ -0,0 +1,92 @@
+use std::fmt;
+
+#[cfg(feature = "serialize")]
+use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
+
+/// A Luau vector type.
+///
+/// By default vectors are 3-dimensional, but can be 4-dimensional
+/// if the `luau-vector4` feature is enabled.
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Debug, Default, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Vector(pub(crate) [f32; Self::SIZE]);
+
+impl fmt::Display for Vector {
+    #[rustfmt::skip]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[cfg(not(feature = "luau-vector4"))]
+        return write!(f, "vector({}, {}, {})", self.x(), self.y(), self.z());
+        #[cfg(feature = "luau-vector4")]
+        return write!(f, "vector({}, {}, {}, {})", self.x(), self.y(), self.z(), self.w());
+    }
+}
+
+#[cfg_attr(not(feature = "luau"), allow(unused))]
+impl Vector {
+    pub(crate) const SIZE: usize = if cfg!(feature = "luau-vector4") { 4 } else { 3 };
+
+    /// Creates a new vector.
+    #[cfg(not(feature = "luau-vector4"))]
+    pub const fn new(x: f32, y: f32, z: f32) -> Self {
+        Self([x, y, z])
+    }
+
+    /// Creates a new vector.
+    #[cfg(feature = "luau-vector4")]
+    pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
+        Self([x, y, z, w])
+    }
+
+    /// Creates a new vector with all components set to `0.0`.
+    #[doc(hidden)]
+    pub const fn zero() -> Self {
+        Self([0.0; Self::SIZE])
+    }
+
+    /// Returns 1st component of the vector.
+    pub const fn x(&self) -> f32 {
+        self.0[0]
+    }
+
+    /// Returns 2nd component of the vector.
+    pub const fn y(&self) -> f32 {
+        self.0[1]
+    }
+
+    /// Returns 3rd component of the vector.
+    pub const fn z(&self) -> f32 {
+        self.0[2]
+    }
+
+    /// Returns 4th component of the vector.
+    #[cfg(any(feature = "luau-vector4", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau-vector4")))]
+    pub const fn w(&self) -> f32 {
+        self.0[3]
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl Serialize for Vector {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        let mut ts = serializer.serialize_tuple_struct("Vector", Self::SIZE)?;
+        ts.serialize_field(&self.x())?;
+        ts.serialize_field(&self.y())?;
+        ts.serialize_field(&self.z())?;
+        #[cfg(feature = "luau-vector4")]
+        ts.serialize_field(&self.w())?;
+        ts.end()
+    }
+}
+
+impl PartialEq<[f32; Self::SIZE]> for Vector {
+    #[inline]
+    fn eq(&self, other: &[f32; Self::SIZE]) -> bool {
+        self.0 == *other
+    }
+}
+
+#[cfg(feature = "luau")]
+impl crate::types::LuaType for Vector {
+    const TYPE_ID: std::os::raw::c_int = ffi::LUA_TVECTOR;
+}

tarpaulin.toml

@@ -1,8 +1,23 @@
-[lua54_coverage]
-features = "lua54,vendored,async,serialize,macros,unstable"
+[lua54]
+features = "lua54,vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
 
-[lua51_coverage]
-features = "lua51,vendored,async,serialize,macros,unstable"
+[lua54_non_send]
+features = "lua54,vendored,async,serialize,macros,anyhow,userdata-wrappers"
 
-[luau_coverage]
-features = "luau,async,serialize,macros,unstable"
+[lua54_with_memory_limit]
+features = "lua54,vendored,async,send,serialize,macros,anyhow,userdata-wrappers"
+rustflags = "--cfg force_memory_limit"
+
+[lua51]
+features = "lua51,vendored,async,send,serialize,macros"
+
+[lua51_with_memory_limit]
+features = "lua51,vendored,async,send,serialize,macros"
+rustflags = "--cfg force_memory_limit"
+
+[luau]
+features = "luau,async,send,serialize,macros"
+
+[luau_with_memory_limit]
+features = "luau,async,send,serialize,macros"
+rustflags = "--cfg force_memory_limit"

tests/async.rs

@@ -1,13 +1,15 @@
 #![cfg(feature = "async")]
 
-use std::sync::{Arc, Mutex};
+use std::string::String as StdString;
+use std::sync::Arc;
 use std::time::Duration;
 
 use futures_util::stream::TryStreamExt;
+use tokio::sync::Mutex;
 
 use mlua::{
-    AnyUserDataExt, Error, Function, Lua, LuaOptions, MultiValue, Result, StdLib, Table, TableExt,
-    UserData, UserDataMethods, Value,
+    Error, Function, Lua, LuaOptions, MultiValue, ObjectLike, Result, StdLib, Table, UserData,
+    UserDataMethods, Value,
 };
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -25,8 +27,7 @@ async fn sleep_ms(_ms: u64) {
 async fn test_async_function() -> Result<()> {
     let lua = Lua::new();
 
-    let f = lua
-        .create_async_function(|_lua, (a, b, c): (i64, i64, i64)| async move { Ok((a + b) * c) })?;
+    let f = lua.create_async_function(|_lua, (a, b, c): (i64, i64, i64)| async move { Ok((a + b) * c) })?;
     lua.globals().set("f", f)?;
 
     let res: i64 = lua.load("f(1, 2, 3)").eval_async().await?;
@@ -39,12 +40,51 @@ async fn test_async_function() -> Result<()> {
 async fn test_async_function_wrap() -> Result<()> {
     let lua = Lua::new();
 
-    let f = Function::wrap_async(|_, s: String| async move { Ok(s) });
+    let f = Function::wrap_async(|s: StdString| async move {
+        tokio::task::yield_now().await;
+        Ok(s)
+    });
     lua.globals().set("f", f)?;
-
     let res: String = lua.load(r#"f("hello")"#).eval_async().await?;
     assert_eq!(res, "hello");
 
+    // Return error
+    let ferr = Function::wrap_async(|| async move { Err::<(), _>(Error::runtime("some async error")) });
+    lua.globals().set("ferr", ferr)?;
+    lua.load(
+        r#"
+        local ok, err = pcall(ferr)
+        assert(not ok and tostring(err):find("some async error"))
+    "#,
+    )
+    .exec_async()
+    .await
+    .unwrap();
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_async_function_wrap_raw() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = Function::wrap_raw_async(|s: StdString| async move {
+        tokio::task::yield_now().await;
+        s
+    });
+    lua.globals().set("f", f)?;
+    let res: String = lua.load(r#"f("hello")"#).eval_async().await?;
+    assert_eq!(res, "hello");
+
+    // Return error
+    let ferr = Function::wrap_raw_async(|| async move {
+        tokio::task::yield_now().await;
+        Err::<(), _>("some error")
+    });
+    lua.globals().set("ferr", ferr)?;
+    let (_, err): (Value, String) = lua.load(r#"ferr()"#).eval_async().await?;
+    assert_eq!(err, "some error");
+
     Ok(())
 }
 
@@ -73,18 +113,16 @@ async fn test_async_call() -> Result<()> {
         Ok(format!("hello, {}!", name))
     })?;
 
-    match hello.call::<_, ()>("alex") {
+    match hello.call::<()>("alex") {
         Err(Error::RuntimeError(_)) => {}
-        _ => panic!(
-            "non-async executing async function must fail on the yield stage with RuntimeError"
-        ),
+        err => panic!("expected `RuntimeError`, got {err:?}"),
     };
 
-    assert_eq!(hello.call_async::<_, String>("alex").await?, "hello, alex!");
+    assert_eq!(hello.call_async::<String>("alex").await?, "hello, alex!");
 
     // Executing non-async functions using async call is allowed
     let sum = lua.create_function(|_lua, (a, b): (i64, i64)| return Ok(a + b))?;
-    assert_eq!(sum.call_async::<_, i64>((5, 1)).await?, 6);
+    assert_eq!(sum.call_async::<i64>((5, 1)).await?, 6);
 
     Ok(())
 }
@@ -98,7 +136,7 @@ async fn test_async_call_many_returns() -> Result<()> {
         Ok(("a", "b", "c", 1))
     })?;
 
-    let vals = hello.call_async::<_, MultiValue>(()).await?;
+    let vals = hello.call_async::<MultiValue>(()).await?;
     assert_eq!(vals.len(), 4);
     assert_eq!(vals[0].to_string()?, "a");
     assert_eq!(vals[1].to_string()?, "b");
@@ -161,7 +199,7 @@ async fn test_async_handle_yield() -> Result<()> {
     "#,
         )
         .eval::<Function>()?;
-    assert_eq!(min.call_async::<_, i64>((-1, 1)).await?, -1);
+    assert_eq!(min.call_async::<i64>((-1, 1)).await?, -1);
 
     Ok(())
 }
@@ -230,15 +268,15 @@ async fn test_async_lua54_to_be_closed() -> Result<()> {
     let f = lua.load(code).into_function()?;
 
     // Test close using call_async
-    let _ = f.call_async::<_, ()>(()).await;
-    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+    let _ = f.call_async::<()>(()).await;
+    assert_eq!(globals.get::<usize>("close_count")?, 1);
 
     // Don't close by default when awaiting async threads
     let co = lua.create_thread(f.clone())?;
-    let _ = co.clone().into_async::<_, ()>(()).await;
-    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+    let _ = co.clone().into_async::<()>(()).await;
+    assert_eq!(globals.get::<usize>("close_count")?, 1);
     let _ = co.reset(f);
-    assert_eq!(globals.get::<_, usize>("close_count")?, 2);
+    assert_eq!(globals.get::<usize>("close_count")?, 2);
 
     Ok(())
 }
@@ -262,7 +300,7 @@ async fn test_async_thread_stream() -> Result<()> {
         .eval()?,
     )?;
 
-    let mut stream = thread.into_async::<_, i64>(1);
+    let mut stream = thread.into_async::<i64>(1);
     let mut sum = 0;
     while let Some(n) = stream.try_next().await? {
         sum += n;
@@ -310,14 +348,14 @@ fn test_async_thread_capture() -> Result<()> {
 
     let thread = lua.create_thread(f)?;
     // After first resume, `v: Value` is captured in the coroutine
-    thread.resume::<_, ()>("abc").unwrap();
+    thread.resume::<()>("abc").unwrap();
     drop(thread);
 
     Ok(())
 }
 
 #[tokio::test]
-async fn test_async_table() -> Result<()> {
+async fn test_async_table_object_like() -> Result<()> {
     let options = LuaOptions::new().thread_pool_size(4);
     let lua = Lua::new_with(StdLib::ALL_SAFE, options)?;
 
@@ -326,7 +364,7 @@ async fn test_async_table() -> Result<()> {
 
     let get_value = lua.create_async_function(|_, table: Table| async move {
         sleep_ms(10).await;
-        table.get::<_, i64>("val")
+        table.get::<i64>("val")
     })?;
     table.set("get_value", get_value)?;
 
@@ -336,25 +374,27 @@ async fn test_async_table() -> Result<()> {
     })?;
     table.set("set_value", set_value)?;
 
-    let sleep = lua.create_async_function(|_, n| async move {
-        sleep_ms(n).await;
-        Ok(format!("elapsed:{}ms", n))
-    })?;
-    table.set("sleep", sleep)?;
+    assert_eq!(table.call_async_method::<i64>("get_value", ()).await?, 10);
+    table.call_async_method::<()>("set_value", 15).await?;
+    assert_eq!(table.call_async_method::<i64>("get_value", ()).await?, 15);
 
-    assert_eq!(
-        table.call_async_method::<_, i64>("get_value", ()).await?,
-        10
-    );
-    table.call_async_method("set_value", 15).await?;
-    assert_eq!(
-        table.call_async_method::<_, i64>("get_value", ()).await?,
-        15
-    );
-    assert_eq!(
-        table.call_async_function::<_, String>("sleep", 7).await?,
-        "elapsed:7ms"
-    );
+    let metatable = lua.create_table()?;
+    metatable.set(
+        "__call",
+        lua.create_async_function(|_, table: Table| async move {
+            sleep_ms(10).await;
+            table.get::<i64>("val")
+        })?,
+    )?;
+    table.set_metatable(Some(metatable));
+    assert_eq!(table.call_async::<i64>(()).await.unwrap(), 15);
+
+    match table.call_async_method::<()>("non_existent", ()).await {
+        Err(Error::RuntimeError(err)) => {
+            assert!(err.contains("attempt to call a nil value (function 'non_existent')"))
+        }
+        r => panic!("expected RuntimeError, got {r:?}"),
+    }
 
     Ok(())
 }
@@ -374,9 +414,9 @@ async fn test_async_thread_pool() -> Result<()> {
         Ok(format!("elapsed:{}ms", n))
     })?;
 
-    assert!(error_f.call_async::<_, ()>(()).await.is_err());
+    assert!(error_f.call_async::<()>(()).await.is_err());
     // Next call should use cached thread
-    assert_eq!(sleep.call_async::<_, String>(3).await?, "elapsed:3ms");
+    assert_eq!(sleep.call_async::<String>(3).await?, "elapsed:3ms");
 
     Ok(())
 }
@@ -386,13 +426,13 @@ async fn test_async_userdata() -> Result<()> {
     struct MyUserData(u64);
 
     impl UserData for MyUserData {
-        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+        fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
             methods.add_async_method("get_value", |_, data, ()| async move {
                 sleep_ms(10).await;
                 Ok(data.0)
             });
 
-            methods.add_async_method_mut("set_value", |_, data, n| async move {
+            methods.add_async_method_mut("set_value", |_, mut data, n| async move {
                 sleep_ms(10).await;
                 data.0 = n;
                 Ok(())
@@ -411,22 +451,19 @@ async fn test_async_userdata() -> Result<()> {
             });
 
             #[cfg(not(any(feature = "lua51", feature = "luau")))]
-            methods.add_async_meta_method(
-                mlua::MetaMethod::Index,
-                |_, data, key: String| async move {
-                    sleep_ms(10).await;
-                    match key.as_str() {
-                        "ms" => Ok(Some(data.0 as f64)),
-                        "s" => Ok(Some((data.0 as f64) / 1000.0)),
-                        _ => Ok(None),
-                    }
-                },
-            );
+            methods.add_async_meta_method(mlua::MetaMethod::Index, |_, data, key: String| async move {
+                sleep_ms(10).await;
+                match key.as_str() {
+                    "ms" => Ok(Some(data.0 as f64)),
+                    "s" => Ok(Some((data.0 as f64) / 1000.0)),
+                    _ => Ok(None),
+                }
+            });
 
             #[cfg(not(any(feature = "lua51", feature = "luau")))]
             methods.add_async_meta_method_mut(
                 mlua::MetaMethod::NewIndex,
-                |_, data, (key, value): (String, f64)| async move {
+                |_, mut data, (key, value): (String, f64)| async move {
                     sleep_ms(10).await;
                     match key.as_str() {
                         "ms" => data.0 = value as u64,
@@ -472,13 +509,14 @@ async fn test_async_userdata() -> Result<()> {
     .exec_async()
     .await?;
 
-    userdata.call_async_method("set_value", 24).await?;
+    // ObjectLike methods
+    userdata.call_async_method::<()>("set_value", 24).await?;
     let n: u64 = userdata.call_async_method("get_value", ()).await?;
     assert_eq!(n, 24);
-    userdata.call_async_function("sleep", 15).await?;
+    userdata.call_async_function::<()>("sleep", 15).await?;
 
     #[cfg(not(any(feature = "lua51", feature = "luau")))]
-    assert_eq!(userdata.call_async::<_, String>(()).await?, "elapsed:24ms");
+    assert_eq!(userdata.call_async::<String>(()).await?, "elapsed:24ms");
 
     Ok(())
 }
@@ -488,7 +526,7 @@ async fn test_async_thread_error() -> Result<()> {
     struct MyUserData;
 
     impl UserData for MyUserData {
-        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+        fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
             methods.add_meta_method("__tostring", |_, _this, ()| Ok("myuserdata error"))
         }
     }
@@ -497,7 +535,7 @@ async fn test_async_thread_error() -> Result<()> {
     let result = lua
         .load("function x(...) error(...) end x(...)")
         .set_name("chunk")
-        .call_async::<_, ()>(MyUserData)
+        .call_async::<()>(MyUserData)
         .await;
     assert!(
         matches!(result, Err(Error::RuntimeError(cause)) if cause.contains("myuserdata error")),
@@ -507,41 +545,24 @@ async fn test_async_thread_error() -> Result<()> {
     Ok(())
 }
 
-#[cfg(all(feature = "unstable", not(feature = "send")))]
-#[tokio::test]
-async fn test_owned_async_call() -> Result<()> {
-    let lua = Lua::new();
-
-    let hello = lua
-        .create_async_function(|_, name: String| async move {
-            sleep_ms(10).await;
-            Ok(format!("hello, {}!", name))
-        })?
-        .into_owned();
-    drop(lua);
-
-    assert_eq!(hello.call_async::<_, String>("alex").await?, "hello, alex!");
-
-    Ok(())
-}
-
 #[tokio::test]
 async fn test_async_terminate() -> Result<()> {
-    let lua = Lua::new();
-
     let mutex = Arc::new(Mutex::new(0u32));
-    let mutex2 = mutex.clone();
-    let func = lua.create_async_function(move |_, ()| {
-        let mutex = mutex2.clone();
-        async move {
-            let _guard = mutex.lock();
-            sleep_ms(100).await;
-            Ok(())
-        }
-    })?;
+    {
+        let lua = Lua::new();
+        let mutex2 = mutex.clone();
+        let func = lua.create_async_function(move |lua, ()| {
+            let mutex = mutex2.clone();
+            async move {
+                let _guard = mutex.lock().await;
+                sleep_ms(100).await;
+                drop(lua); // Move Lua to the future to test drop
+                Ok(())
+            }
+        })?;
 
-    let _ = tokio::time::timeout(Duration::from_millis(30), func.call_async::<_, ()>(())).await;
-    lua.gc_collect()?;
+        let _ = tokio::time::timeout(Duration::from_millis(30), func.call_async::<()>(())).await;
+    }
     assert!(mutex.try_lock().is_ok());
 
     Ok(())

tests/buffer.rs

@@ -0,0 +1,57 @@
+#![cfg(feature = "luau")]
+
+use mlua::{Lua, Result, Value};
+
+#[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_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 buf1 = buf1.as_buffer().unwrap();
+    let func = lua.create_function(|_, buf: Value| return buf.to_string())?;
+    assert!(func.call::<String>(buf1)?.starts_with("buffer:"));
+
+    // Check buffer methods
+    assert_eq!(buf1.len(), 5);
+    assert_eq!(buf1.to_vec(), b"hello");
+    assert_eq!(buf1.read_bytes::<3>(1), [b'e', b'l', b'l']);
+    buf1.write_bytes(1, b"i");
+    assert_eq!(buf1.to_vec(), b"hillo");
+
+    let buf3 = lua.create_buffer(b"")?;
+    assert!(buf3.is_empty());
+    assert!(!Value::Buffer(buf3).to_pointer().is_null());
+
+    Ok(())
+}
+
+#[test]
+#[should_panic(expected = "range end index 14 out of range for slice of length 13")]
+fn test_buffer_out_of_bounds_read() {
+    let lua = Lua::new();
+    let buf = lua.create_buffer(b"hello, world!").unwrap();
+    _ = buf.read_bytes::<1>(13);
+}
+
+#[test]
+#[should_panic(expected = "range end index 16 out of range for slice of length 13")]
+fn test_buffer_out_of_bounds_write() {
+    let lua = Lua::new();
+    let buf = lua.create_buffer(b"hello, world!").unwrap();
+    buf.write_bytes(14, b"!!");
+}

tests/byte_string.rs

@@ -22,38 +22,38 @@ fn test_byte_string_round_trip() -> Result<()> {
 
     let globals = lua.globals();
 
-    let isi = globals.get::<_, BString>("invalid_sequence_identifier")?;
+    let isi = globals.get::<BString>("invalid_sequence_identifier")?;
     assert_eq!(isi, [0xa0, 0xa1].as_ref());
 
-    let i2os2 = globals.get::<_, BString>("invalid_2_octet_sequence_2nd")?;
+    let i2os2 = globals.get::<BString>("invalid_2_octet_sequence_2nd")?;
     assert_eq!(i2os2, [0xc3, 0x28].as_ref());
 
-    let i3os2 = globals.get::<_, BString>("invalid_3_octet_sequence_2nd")?;
+    let i3os2 = globals.get::<BString>("invalid_3_octet_sequence_2nd")?;
     assert_eq!(i3os2, [0xe2, 0x28, 0xa1].as_ref());
 
-    let i3os3 = globals.get::<_, BString>("invalid_3_octet_sequence_3rd")?;
+    let i3os3 = globals.get::<BString>("invalid_3_octet_sequence_3rd")?;
     assert_eq!(i3os3, [0xe2, 0x82, 0x28].as_ref());
 
-    let i4os2 = globals.get::<_, BString>("invalid_4_octet_sequence_2nd")?;
+    let i4os2 = globals.get::<BString>("invalid_4_octet_sequence_2nd")?;
     assert_eq!(i4os2, [0xf0, 0x28, 0x8c, 0xbc].as_ref());
 
-    let i4os3 = globals.get::<_, BString>("invalid_4_octet_sequence_3rd")?;
+    let i4os3 = globals.get::<BString>("invalid_4_octet_sequence_3rd")?;
     assert_eq!(i4os3, [0xf0, 0x90, 0x28, 0xbc].as_ref());
 
-    let i4os4 = globals.get::<_, BString>("invalid_4_octet_sequence_4th")?;
+    let i4os4 = globals.get::<BString>("invalid_4_octet_sequence_4th")?;
     assert_eq!(i4os4, [0xf0, 0x28, 0x8c, 0x28].as_ref());
 
-    let aas = globals.get::<_, BString>("an_actual_string")?;
+    let aas = globals.get::<BString>("an_actual_string")?;
     assert_eq!(aas, b"Hello, world!".as_ref());
 
-    globals.set::<_, &BStr>("bstr_invalid_sequence_identifier", isi.as_ref())?;
-    globals.set::<_, &BStr>("bstr_invalid_2_octet_sequence_2nd", i2os2.as_ref())?;
-    globals.set::<_, &BStr>("bstr_invalid_3_octet_sequence_2nd", i3os2.as_ref())?;
-    globals.set::<_, &BStr>("bstr_invalid_3_octet_sequence_3rd", i3os3.as_ref())?;
-    globals.set::<_, &BStr>("bstr_invalid_4_octet_sequence_2nd", i4os2.as_ref())?;
-    globals.set::<_, &BStr>("bstr_invalid_4_octet_sequence_3rd", i4os3.as_ref())?;
-    globals.set::<_, &BStr>("bstr_invalid_4_octet_sequence_4th", i4os4.as_ref())?;
-    globals.set::<_, &BStr>("bstr_an_actual_string", aas.as_ref())?;
+    globals.set("bstr_invalid_sequence_identifier", isi.as_ref() as &BStr)?;
+    globals.set("bstr_invalid_2_octet_sequence_2nd", i2os2.as_ref() as &BStr)?;
+    globals.set("bstr_invalid_3_octet_sequence_2nd", i3os2.as_ref() as &BStr)?;
+    globals.set("bstr_invalid_3_octet_sequence_3rd", i3os3.as_ref() as &BStr)?;
+    globals.set("bstr_invalid_4_octet_sequence_2nd", i4os2.as_ref() as &BStr)?;
+    globals.set("bstr_invalid_4_octet_sequence_3rd", i4os3.as_ref() as &BStr)?;
+    globals.set("bstr_invalid_4_octet_sequence_4th", i4os4.as_ref() as &BStr)?;
+    globals.set("bstr_an_actual_string", aas.as_ref() as &BStr)?;
 
     lua.load(
         r#"
@@ -69,14 +69,14 @@ fn test_byte_string_round_trip() -> Result<()> {
     )
     .exec()?;
 
-    globals.set::<_, BString>("bstring_invalid_sequence_identifier", isi)?;
-    globals.set::<_, BString>("bstring_invalid_2_octet_sequence_2nd", i2os2)?;
-    globals.set::<_, BString>("bstring_invalid_3_octet_sequence_2nd", i3os2)?;
-    globals.set::<_, BString>("bstring_invalid_3_octet_sequence_3rd", i3os3)?;
-    globals.set::<_, BString>("bstring_invalid_4_octet_sequence_2nd", i4os2)?;
-    globals.set::<_, BString>("bstring_invalid_4_octet_sequence_3rd", i4os3)?;
-    globals.set::<_, BString>("bstring_invalid_4_octet_sequence_4th", i4os4)?;
-    globals.set::<_, BString>("bstring_an_actual_string", aas)?;
+    globals.set("bstring_invalid_sequence_identifier", isi)?;
+    globals.set("bstring_invalid_2_octet_sequence_2nd", i2os2)?;
+    globals.set("bstring_invalid_3_octet_sequence_2nd", i3os2)?;
+    globals.set("bstring_invalid_3_octet_sequence_3rd", i3os3)?;
+    globals.set("bstring_invalid_4_octet_sequence_2nd", i4os2)?;
+    globals.set("bstring_invalid_4_octet_sequence_3rd", i4os3)?;
+    globals.set("bstring_invalid_4_octet_sequence_4th", i4os4)?;
+    globals.set("bstring_an_actual_string", aas)?;
 
     lua.load(
         r#"

tests/chunk.rs

@@ -1,7 +1,24 @@
-use std::fs;
-use std::io;
+use std::{fs, io};
 
-use mlua::{Lua, Result};
+use mlua::{Chunk, ChunkMode, Lua, Result};
+
+#[test]
+fn test_chunk_methods() -> Result<()> {
+    let lua = Lua::new();
+
+    #[cfg(unix)]
+    assert!(lua.load("return 123").name().starts_with("@tests/chunk.rs"));
+    let chunk2 = lua.load("return 123").set_name("@new_name");
+    assert_eq!(chunk2.name(), "@new_name");
+
+    let env = lua.create_table_from([("a", 987)])?;
+    let chunk3 = lua.load("return a").set_environment(env.clone());
+    assert_eq!(chunk3.environment().unwrap(), &env);
+    assert_eq!(chunk3.mode(), ChunkMode::Text);
+    assert_eq!(chunk3.call::<i32>(())?, 987);
+
+    Ok(())
+}
 
 #[test]
 fn test_chunk_path() -> Result<()> {
@@ -20,7 +37,7 @@ fn test_chunk_path() -> Result<()> {
         return 321
     "#,
     )?;
-    let i: i32 = lua.load(&*temp_dir.path().join("module.lua")).eval()?;
+    let i: i32 = lua.load(temp_dir.path().join("module.lua")).eval()?;
     assert_eq!(i, 321);
 
     match lua.load(&*temp_dir.path().join("module2.lua")).exec() {
@@ -28,6 +45,30 @@ fn test_chunk_path() -> Result<()> {
         res => panic!("expected io::Error, got {:?}", res),
     };
 
+    // &Path
+    assert_eq!(
+        (lua.load(&*temp_dir.path().join("module.lua").as_path())).eval::<i32>()?,
+        321
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_chunk_impls() -> Result<()> {
+    let lua = Lua::new();
+
+    // StdString
+    assert_eq!(lua.load(String::from("1")).eval::<i32>()?, 1);
+    assert_eq!(lua.load(&String::from("2")).eval::<i32>()?, 2);
+
+    // &[u8]
+    assert_eq!(lua.load(&b"3"[..]).eval::<i32>()?, 3);
+
+    // Vec<u8>
+    assert_eq!(lua.load(b"4".to_vec()).eval::<i32>()?, 4);
+    assert_eq!(lua.load(&b"5".to_vec()).eval::<i32>()?, 5);
+
     Ok(())
 }
 
@@ -43,7 +84,7 @@ fn test_chunk_macro() -> Result<()> {
     data.raw_set("num", 1)?;
 
     let ud = mlua::AnyUserData::wrap("hello");
-    let f = mlua::Function::wrap(|_lua, ()| Ok(()));
+    let f = mlua::Function::wrap(|| Ok(()));
 
     lua.globals().set("g", 123)?;
 
@@ -65,7 +106,53 @@ fn test_chunk_macro() -> Result<()> {
     })
     .exec()?;
 
-    assert_eq!(lua.globals().get::<_, i32>("s")?, 321);
+    assert_eq!(lua.globals().get::<i32>("s")?, 321);
+
+    Ok(())
+}
+
+#[cfg(feature = "luau")]
+#[test]
+fn test_compiler() -> Result<()> {
+    use std::vec;
+
+    let compiler = mlua::Compiler::new()
+        .set_optimization_level(2)
+        .set_debug_level(2)
+        .set_type_info_level(1)
+        .set_coverage_level(2)
+        .set_vector_lib("vector")
+        .set_vector_ctor("new")
+        .set_vector_type("vector")
+        .set_mutable_globals(vec!["mutable_global".into()])
+        .set_userdata_types(vec!["MyUserdata".into()]);
+
+    assert!(compiler.compile("return vector.new(1, 2, 3)").is_ok());
+
+    // Error
+    match compiler.compile("%") {
+        Err(mlua::Error::SyntaxError { ref message, .. }) => {
+            assert!(message.contains("Expected identifier when parsing expression, got '%'"),);
+        }
+        res => panic!("expected result: {res:?}"),
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_chunk_wrap() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = Chunk::wrap("return 123");
+    lua.globals().set("f", f)?;
+    lua.load("assert(f() == 123)").exec().unwrap();
+
+    lua.globals().set("f2", Chunk::wrap("c()"))?;
+    assert!(
+        (lua.load("f2()").exec().err().unwrap().to_string()).contains(file!()),
+        "wrong chunk location"
+    );
 
     Ok(())
 }