Update README

This reverts commit 5394faca16.

.github/workflows/coverage.yml

@@ -10,14 +10,14 @@ jobs:
       options: --security-opt seccomp=unconfined
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
-      - name: Generate code coverage
+      - name: Generate coverage report
         run: |
           cargo tarpaulin --verbose --features lua54,vendored,async,send,serialize,macros --out xml --exclude-files benches --exclude-files build --exclude-files mlua_derive --exclude-files src/ffi --exclude-files tests
 
-      - name: Upload to codecov.io
-        uses: codecov/codecov-action@v1
+      - name: Upload report to codecov.io
+        uses: codecov/codecov-action@v3
         with:
           token: ${{secrets.CODECOV_TOKEN}}
           fail_ci_if_error: false

.github/workflows/main.yml

@@ -7,98 +7,94 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-latest, windows-latest]
+        os: [ubuntu-22.04, macos-latest, windows-latest]
         rust: [stable]
         lua: [lua54, lua53, lua52, lua51, luajit, luau]
         include:
-        - os: ubuntu-20.04
-          target: x86_64-unknown-linux-gnu
-        - os: macos-latest
-          target: x86_64-apple-darwin
-        - os: windows-latest
-          target: x86_64-pc-windows-msvc
+          - os: ubuntu-22.04
+            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@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        target: ${{ matrix.target }}
-        override: true
-    - uses: Swatinem/rust-cache@v1
-    - name: Build ${{ matrix.lua }} vendored
-      run: |
-        cargo build --features "${{ matrix.lua }},vendored"
-        cargo build --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
-      shell: bash
-    - name: Build ${{ matrix.lua }} pkg-config
-      if: ${{ matrix.os == 'ubuntu-20.04' && matrix.lua != 'lua54' }}
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y --no-install-recommends liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
-        cargo build --features "${{ matrix.lua }}"
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - 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"
+        shell: bash
+      - name: Build ${{ matrix.lua }} pkg-config
+        if: ${{ matrix.os == 'ubuntu-22.04' }}
+        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
+          cargo build --features "${{ matrix.lua }}"
 
   build_aarch64_cross_macos:
     name: Cross-compile to aarch64-apple-darwin
-    runs-on: macos-11.0
+    runs-on: macos-latest
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        target: aarch64-apple-darwin
-        override: true
-    - name: Cross-compile
-      run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
+      - uses: actions/checkout@v3
+      - 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"
 
   build_aarch64_cross_ubuntu:
     name: Cross-compile to aarch64-unknown-linux-gnu
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        target: aarch64-unknown-linux-gnu
-        override: true
-    - name: Install ARM compiler toolchain
-      run: |
-        sudo apt-get update
-        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"
-      shell: bash
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: aarch64-unknown-linux-gnu
+      - name: Install ARM compiler toolchain
+        run: |
+          sudo apt-get update
+          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"
+        shell: bash
 
   build_armv7_cross_ubuntu:
     name: Cross-compile to armv7-unknown-linux-gnueabihf
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51]
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        target: armv7-unknown-linux-gnueabihf
-        override: true
-    - name: Install ARM compiler toolchain
-      run: |
-        sudo apt-get update
-        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"
-      shell: bash
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: armv7-unknown-linux-gnueabihf
+      - name: Install ARM compiler toolchain
+        run: |
+          sudo apt-get update
+          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"
+        shell: bash
 
   test:
     name: Test
@@ -106,35 +102,34 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-latest, windows-latest]
+        os: [ubuntu-22.04, macos-latest, windows-latest]
         rust: [stable, nightly]
         lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau]
         include:
-        - os: ubuntu-20.04
-          target: x86_64-unknown-linux-gnu
-        - os: macos-latest
-          target: x86_64-apple-darwin
-        - os: windows-latest
-          target: x86_64-pc-windows-msvc
+          - os: ubuntu-22.04
+            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@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        target: ${{ matrix.target }}
-        override: true
-    - uses: Swatinem/rust-cache@v1
-    - name: Run ${{ matrix.lua }} tests
-      run: |
-        cargo test --features "${{ matrix.lua }},vendored"
-        cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
-      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" -- --ignored
-      shell: bash
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v1
+      - name: Run ${{ matrix.lua }} tests
+        run: |
+          cargo test --features "${{ matrix.lua }},vendored"
+          cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+        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
+        shell: bash
 
   test_with_sanitizer:
     name: Test with address sanitizer
@@ -142,25 +137,24 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-20.04]
+        os: [ubuntu-22.04]
         rust: [nightly]
         lua: [lua54, lua53, lua52, lua51, luajit, luau]
         include:
-        - os: ubuntu-20.04
-          target: x86_64-unknown-linux-gnu
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        target: ${{ matrix.target }}
-        override: true
-    - uses: Swatinem/rust-cache@v1
-    - name: Run ${{ matrix.lua }} tests with address sanitizer
-      run: |
-        RUSTFLAGS="-Z sanitizer=address" \
-          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
-      shell: bash
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v1
+      - name: Run ${{ matrix.lua }} tests with address sanitizer
+        run: |
+          RUSTFLAGS="-Z sanitizer=address" \
+            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
+        shell: bash
 
   test_modules:
     name: Test modules
@@ -168,27 +162,26 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-latest]
+        os: [ubuntu-22.04, macos-latest]
         rust: [stable]
         lua: [lua54, lua53, lua52, lua51, luajit]
         include:
-        - os: ubuntu-20.04
-          target: x86_64-unknown-linux-gnu
-        - os: macos-latest
-          target: x86_64-apple-darwin
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        target: ${{ matrix.target }}
-        override: true
-    - uses: Swatinem/rust-cache@v1
-    - name: Run ${{ matrix.lua }} module tests
-      run: |
-        (cd examples/module && cargo build --release --features "${{ matrix.lua }},vendored")
-        (cd tests/module && cargo test --release --features "${{ matrix.lua }},vendored")
-      shell: bash
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v1
+      - name: Run ${{ matrix.lua }} module tests
+        run: |
+          (cd tests/module && cargo build --release --features "${{ matrix.lua }}")
+          (cd tests/module/loader && cargo test --release --features "${{ matrix.lua }},vendored")
+        shell: bash
 
   test_modules_windows:
     name: Test modules on Windows
@@ -201,42 +194,40 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-    - uses: msys2/setup-msys2@v2
-    - uses: actions/checkout@v2
-    - 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
-    - name: Run ${{ matrix.lua }} module tests
-      run: |
-        (cd examples/module && cargo build --release --features "${{ matrix.lua }}")
-        (cd tests/module && cargo test --release --features "${{ matrix.lua }}")
+      - uses: msys2/setup-msys2@v2
+      - uses: actions/checkout@v3
+      - 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
+      - name: Run ${{ matrix.lua }} module tests
+        run: |
+          (cd tests/module && cargo build --release --features "${{ matrix.lua }}")
+          (cd tests/module/loader && cargo test --release --features "${{ matrix.lua }}")
 
   rustfmt:
     name: Rustfmt
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        components: rustfmt
-        override: true
-    - run: cargo fmt -- --check
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          components: rustfmt
+      - run: cargo fmt -- --check
 
   clippy:
     name: Clippy check
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit, luau]
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
         with:
-            toolchain: nightly
-            components: clippy
-            override: true
+          toolchain: nightly
+          components: clippy
       - uses: actions-rs/clippy-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
+          args: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"

CHANGELOG.md

@@ -1,3 +1,126 @@
+## v0.9.0-beta.1
+
+New features:
+- Owned Lua types (unstable feature flag)
+- New functions `Function::wrap`/`Function::wrap_mut`/`Function::wrap_async`
+- `Lua::register_userdata_type()` to register a custom userdata types (without requiring `UserData` trait)
+- `Lua::create_any_userdata()`
+- Added `create_userdata_ref`/`create_userdata_ref_mut` for scopes
+- Added `AnyUserDataExt` trait with auxiliary functions for `AnyUserData`
+- Added `UserDataRef` and `UserDataRefMut` type wrapped that implement `FromLua`
+- Improved error handling:
+  * Improved error reporting when calling Rust functions from Lua.
+  * Added `Error::BadArgument` to help identify bad argument position or name
+  * Added `ErrorContext` extension trait to attach additional context to `Error`
+
+Breaking changes:
+- Refactored `AsChunk` trait
+- `ToLua`/`ToLuaMulti` renamed to `IntoLua`/`IntoLuaMulti`
+- Renamed `to_lua_err` to `into_lua_err`
+- Removed `FromLua` impl for `T: UserData+Clone`
+- Removed `Lua::async_scope`
+- Added `&Lua` arg to Luau interrupt callback
+
+Other:
+- Better Debug for String
+- Allow deserializing values from serializable UserData using `Lua::from_value()` method
+- Added `Table::clear()` method
+- Added `Error::downcast_ref()` method
+- Support setting memory limit for Lua 5.1/JIT/Luau
+- Support setting module name in `#[lua_module(name = "...")]` macro
+- Minor fixes and improvements
+
+## v0.8.8
+
+- Fix potential deadlock when trying to reuse dropped registry keys.
+- Optimize userdata methods call when __index and fields_getters are nil
+
+## v0.8.7
+
+- Minimum Luau updated to 0.555 (`LUAI_MAXCSTACK` limit increased to 100000)
+- `_VERSION` in Luau now includes version number
+- Fixed lifetime of `DebugNames` in `Debug::names()` and `DebugSource` in `Debug::source()`
+- Fixed subtraction overflow when calculating index for `MultiValue::get()`
+
+## v0.8.6
+
+- Fixed bug when recycled Registry slot can be set to Nil
+
+## v0.8.5
+
+- Fixed potential unsoundness when using `Layout::from_size_align_unchecked` and Rust 1.65+
+- Performance optimizations around string and table creation in standalone mode
+- Added fast track path to Table `get`/`set`/`len` methods without metatable
+- Added new methods `push`/`pop`/`raw_push`/`raw_pop` to Table
+- Fix getting caller information from `Lua::load`
+- Better checks and tests when trying to modify a Luau readonly table
+
+## v0.8.4
+
+- Minimal Luau updated to 0.548
+
+## v0.8.3
+
+- Close to-be-closed variables for Lua 5.4 when using call_async functions (#192)
+- Fixed Lua assertion when inspecting another thread stack. (#195)
+- Use more reliable way to create LuaJIT VM (which can fail if use Rust allocator on non-x86 platforms)
+
+## v0.8.2
+
+- Performance optimizations in handling UserData
+- Minimal Luau updated to 0.536
+- Fixed bug in `Function::bind` when passing empty binds and no arguments (#189)
+
+## v0.8.1
+
+- Added `Lua::create_proxy` for accessing to UserData static fields and functions without instance
+- Added `Table::to_pointer()` and `String::to_pointer()` functions
+- Bugfixes and improvements (#176 #179)
+
+## v0.8.0
+Changes since 0.7.4
+- Roblox Luau support
+- Removed C glue
+- Added async support to `__index` and `__newindex` metamethods
+- Added `Function::info()` to get information about functions (#149).
+- Added `parking_lot` dependency under feature flag (for `UserData`)
+- `Hash` implementation for Lua String
+- Added `Value::to_pointer()` function
+- Performance improvements
+
+Breaking changes:
+- Refactored `AsChunk` trait (added implementation for `Path` and `PathBuf`).
+
+## v0.8.0-beta.5
+
+- Lua sources no longer needed to build modules
+- Added `__iter` metamethod for Luau
+- Added `Value::to_pointer()` function
+- Added `Function::coverage` for Luau to obtain coverage report
+- Bugfixes and improvements (#153 #161 #168)
+
+## v0.8.0-beta.4
+
+- Removed `&Lua` from `Lua::set_interrupt` as it's not safe (introduced in v0.8.0-beta.3)
+- Enabled `Lua::gc_inc` for Luau
+- Luau `debug` module marked as safe (enabled by default)
+- Implemented `Hash` for Lua String
+- Support mode options in `collectgarbage` for Luau
+- Added ability to set global Luau compiler (used for loading all chunks).
+- Refactored `AsChunk` trait (breaking changes).
+  `AsChunk` now implemented for `Path` and `PathBuf` to load lua files from fs.
+- Added `parking_lot` dependency and feature flag (for `UserData`)
+- Added `Function::info()` to get information about functions (#149).
+- Bugfixes and improvements (#104 #142)
+
+## v0.8.0-beta.3
+
+- Luau vector constructor
+- Luau sandboxing support
+- Luau interrupts (yieldable)
+- More Luau compiler options (mutable globals)
+- Other performance improvements
+
 ## v0.8.0-beta.2
 
 - Luau vector datatype support

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "mlua"
-version = "0.8.0-beta.2" # remember to update html_root_url and mlua_derive
+version = "0.9.0-beta.1" # remember to update html_root_url and mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
-edition = "2018"
+edition = "2021"
 repository = "https://github.com/khvzak/mlua"
 documentation = "https://docs.rs/mlua"
 readme = "README.md"
-keywords = ["lua", "luajit", "async", "futures", "scripting"]
+keywords = ["lua", "luajit", "luau", "async", "scripting"]
 categories = ["api-bindings", "asynchronous"]
 license = "MIT"
 links = "lua"
@@ -17,14 +17,12 @@ with async/await features and support of writing native Lua modules in Rust.
 """
 
 [package.metadata.docs.rs]
-features = ["lua54", "vendored", "async", "send", "serialize", "macros"]
+features = ["lua54", "vendored", "async", "send", "serialize", "macros", "parking_lot", "unstable"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [workspace]
 members = [
     "mlua_derive",
-    "examples/module",
-    "tests/module",
 ]
 
 [features]
@@ -39,12 +37,13 @@ vendored = ["lua-src", "luajit-src"]
 module = ["mlua_derive"]
 async = ["futures-core", "futures-task", "futures-util"]
 send = []
-serialize = ["serde", "erased-serde"]
+serialize = ["serde", "erased-serde", "serde-value"]
 macros = ["mlua_derive/macros"]
+unstable = []
 
 [dependencies]
-mlua_derive = { version = "=0.6.0", optional = true, path = "mlua_derive" }
-bstr = { version = "0.2", features = ["std"], default_features = false }
+mlua_derive = { version = "=0.9.0-beta.1", optional = true, path = "mlua_derive" }
+bstr = { version = "1.0", features = ["std"], default_features = false }
 once_cell = { version = "1.0" }
 num-traits = { version = "0.2.14" }
 rustc-hash = "1.0"
@@ -53,26 +52,30 @@ futures-task = { version = "0.3.5", optional = true }
 futures-util = { version = "0.3.5", optional = true }
 serde = { version = "1.0", optional = true }
 erased-serde = { version = "0.3", optional = true }
+serde-value = { version = "0.7", optional = true }
+parking_lot = { version = "0.12", optional = true }
 
 [build-dependencies]
 cc = { version = "1.0" }
 pkg-config = { version = "0.3.17" }
-lua-src = { version = ">= 540.0.0, < 550.0.0", optional = true }
-luajit-src = { version = ">= 210.3.1, < 220.0.0", optional = true }
-luau0-src = { version = "0.2.1", optional = true }
+lua-src = { version = ">= 544.0.0, < 550.0.0", optional = true }
+luajit-src = { version = ">= 210.4.0, < 220.0.0", optional = true }
+luau0-src = { version = "0.5.0", optional = true }
 
 [dev-dependencies]
-rustyline = "9.0"
-criterion = { version = "0.3.4", features = ["html_reports", "async_tokio"] }
+rustyline = "11.0"
+criterion = { version = "0.4", features = ["html_reports", "async_tokio"] }
 trybuild = "1.0"
 futures = "0.3.5"
 hyper = { version = "0.14", features = ["client", "server"] }
 reqwest = { version = "0.11", features = ["json"] }
 tokio = { version = "1.0", features = ["full"] }
 futures-timer = "3.0"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 maplit = "1.0"
 tempfile = "3"
+static_assertions = "1.0"
 
 [[bench]]
 name = "benchmark"

FAQ.md

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

README.md

@@ -9,9 +9,17 @@
 [docs.rs]: https://docs.rs/mlua
 [Coverage Status]: https://codecov.io/gh/khvzak/mlua/branch/master/graph/badge.svg?token=99339FS1CG
 [codecov.io]: https://codecov.io/gh/khvzak/mlua
-[MSRV]: https://img.shields.io/badge/rust-1.53+-brightgreen.svg?&logo=rust
+[MSRV]: https://img.shields.io/badge/rust-1.63+-brightgreen.svg?&logo=rust
 
-[Guided Tour](examples/guided_tour.rs)
+[Guided Tour] | [Benchmarks] | [FAQ]
+
+[Guided Tour]: examples/guided_tour.rs
+[Benchmarks]: https://github.com/khvzak/script-bench-rs
+[FAQ]: FAQ.md
+
+> **Note**
+>
+> Please see the [v0.8](https://github.com/khvzak/mlua/tree/v0.8) branch for the stable versions of `mlua` released to crates.io.
 
 `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.
@@ -43,6 +51,8 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 * `send`: make `mlua::Lua` transferable across thread boundaries (adds [`Send`] requirement to `mlua::Function` and `mlua::UserData`)
 * `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.
 
 [5.4]: https://www.lua.org/manual/5.4/manual.html
 [5.3]: https://www.lua.org/manual/5.3/manual.html
@@ -56,6 +66,7 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 [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
 
@@ -104,7 +115,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.8.0-beta.2", features = ["lua54", "vendored"] }
+mlua = { version = "0.8", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -139,7 +150,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.8.0-beta.2", features = ["lua54", "vendored", "module"] }
+mlua = { version = "0.8", features = ["lua54", "vendored", "module"] }
 ```
 
 `lib.rs` :
@@ -254,6 +265,14 @@ If you encounter them, a bug report would be very welcome:
 
   + If you detect that, after catching a panic or during a Drop triggered from a panic, a `Lua` or handle method is triggering other bugs or there is a Lua stack space leak, this is a bug. `mlua` instances are supposed to remain fully usable in the face of user generated panics. This guarantee does not extend to panics marked with "mlua internal error" simply because that is already indicative of a separate bug.
 
+## Sandboxing
+
+Please check the [Luau Sandboxing] page if you are interested in running untrusted Lua scripts in controlled environment.
+
+`mlua` provides `Lua::sandbox` method for enabling sandbox mode (Luau only).
+
+[Luau Sandboxing]: https://luau-lang.org/sandbox
+
 ## License
 
 This project is licensed under the [MIT license](LICENSE)

benches/benchmark.rs

@@ -120,7 +120,7 @@ fn call_sum_callback(c: &mut Criterion) {
 }
 
 fn call_async_sum_callback(c: &mut Criterion) {
-    let options = LuaOptions::new().thread_cache_size(1024);
+    let options = LuaOptions::new().thread_pool_size(1024);
     let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
     let callback = lua
         .create_async_function(|_, (a, b, c): (i64, i64, i64)| async move {
@@ -272,7 +272,7 @@ fn call_async_userdata_method(c: &mut Criterion) {
         }
     }
 
-    let options = LuaOptions::new().thread_cache_size(1024);
+    let options = LuaOptions::new().thread_pool_size(1024);
     let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
     lua.globals().set("userdata", UserData(10)).unwrap();
 

build/find_dummy.rs

@@ -1,5 +1,5 @@
 use std::path::PathBuf;
 
 pub fn probe_lua() -> Option<PathBuf> {
-    unreachable!()
+    None
 }

build/find_normal.rs

@@ -1,3 +1,5 @@
+#![allow(dead_code)]
+
 use std::env;
 use std::ops::Bound;
 use std::path::PathBuf;
@@ -6,7 +8,7 @@ fn get_env_var(name: &str) -> String {
     match env::var(name) {
         Ok(val) => val,
         Err(env::VarError::NotPresent) => String::new(),
-        Err(err) => panic!("cannot get {}: {}", name, err),
+        Err(err) => panic!("cannot get {name}: {err}"),
     }
 }
 
@@ -35,8 +37,8 @@ pub fn probe_lua() -> Option<PathBuf> {
             if get_env_var("LUA_LINK") == "static" {
                 link_lib = "static=";
             };
-            println!("cargo:rustc-link-search=native={}", lib_dir);
-            println!("cargo:rustc-link-lib={}{}", link_lib, lua_lib);
+            println!("cargo:rustc-link-search=native={lib_dir}");
+            println!("cargo:rustc-link-lib={link_lib}{lua_lib}");
         }
         return Some(PathBuf::from(include_dir));
     }
@@ -70,7 +72,7 @@ pub fn probe_lua() -> Option<PathBuf> {
                 .probe(alt_probe);
         }
 
-        lua.unwrap_or_else(|_| panic!("cannot find Lua {} using `pkg-config`", ver))
+        lua.unwrap_or_else(|_| panic!("cannot find Lua {ver} using `pkg-config`"))
             .include_paths
             .get(0)
             .cloned()
@@ -79,7 +81,7 @@ pub fn probe_lua() -> Option<PathBuf> {
     #[cfg(feature = "luajit")]
     {
         let lua = pkg_config::Config::new()
-            .range_version((Bound::Included("2.0.5"), Bound::Unbounded))
+            .range_version((Bound::Included("2.0.4"), Bound::Unbounded))
             .cargo_metadata(need_lua_lib)
             .probe("luajit");
 

build/find_vendored.rs

@@ -1,3 +1,5 @@
+#![allow(dead_code)]
+
 use std::path::PathBuf;
 
 pub fn probe_lua() -> Option<PathBuf> {
@@ -20,7 +22,6 @@ pub fn probe_lua() -> Option<PathBuf> {
     #[cfg(feature = "luau")]
     let artifacts = luau0_src::Build::new().build();
 
-    #[cfg(not(feature = "module"))]
     artifacts.print_cargo_metadata();
 
     Some(artifacts.include_dir().to_owned())

build/main.rs

@@ -105,6 +105,10 @@ fn main() {
             + "Please, use `pkg-config` or custom mode to link to a Lua dll."
     );
 
+    #[cfg(all(feature = "luau", feature = "module"))]
+    compile_error!("Luau does not support module mode");
+
+    #[cfg(any(not(feature = "module"), target_os = "windows"))]
     find::probe_lua();
 
     println!("cargo:rerun-if-changed=build");

examples/async_http_client.rs

@@ -12,7 +12,7 @@ impl UserData for BodyReader {
         methods.add_async_function("read", |lua, reader: AnyUserData| async move {
             let mut reader = reader.borrow_mut::<Self>()?;
             if let Some(bytes) = reader.0.data().await {
-                let bytes = bytes.to_lua_err()?;
+                let bytes = bytes.into_lua_err()?;
                 return Some(lua.create_string(&bytes)).transpose();
             }
             Ok(None)
@@ -26,8 +26,8 @@ async fn main() -> Result<()> {
 
     let fetch_url = lua.create_async_function(|lua, uri: String| async move {
         let client = HyperClient::new();
-        let uri = uri.parse().to_lua_err()?;
-        let resp = client.get(uri).await.to_lua_err()?;
+        let uri = uri.parse().into_lua_err()?;
+        let resp = client.get(uri).await.into_lua_err()?;
 
         let lua_resp = lua.create_table()?;
         lua_resp.set("status", resp.status().as_u16())?;
@@ -37,7 +37,7 @@ async fn main() -> Result<()> {
             headers
                 .entry(key.as_str())
                 .or_insert(Vec::new())
-                .push(value.to_str().to_lua_err()?);
+                .push(value.to_str().into_lua_err()?);
         }
 
         lua_resp.set("headers", headers)?;

examples/async_http_reqwest.rs

@@ -10,8 +10,8 @@ async fn main() -> Result<()> {
         let resp = reqwest::get(&uri)
             .await
             .and_then(|resp| resp.error_for_status())
-            .to_lua_err()?;
-        let json = resp.json::<serde_json::Value>().await.to_lua_err()?;
+            .into_lua_err()?;
+        let json = resp.json::<serde_json::Value>().await.into_lua_err()?;
         lua.to_value(&json)
     })?;
 

examples/guided_tour.rs

@@ -1,7 +1,9 @@
 use std::f32;
 use std::iter::FromIterator;
 
-use mlua::{chunk, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, 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
@@ -30,7 +32,7 @@ fn main() -> Result<()> {
             global = 'foo'..'bar'
         "#,
     )
-    .set_name("example code")?
+    .set_name("example code")
     .exec()?;
     assert_eq!(globals.get::<_, String>("global")?, "foobar");
 
@@ -151,6 +153,16 @@ fn main() -> Result<()> {
     #[derive(Copy, Clone)]
     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> {
+            match value {
+                Value::UserData(ud) => Ok(*ud.borrow::<Self>()?),
+                _ => unreachable!(),
+            }
+        }
+    }
+
     impl UserData for Vec2 {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
             methods.add_method("magnitude", |_, vec, ()| {

examples/module/Cargo.toml

@@ -2,18 +2,19 @@
 name = "rust_module"
 version = "0.0.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-edition = "2018"
+edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
 
+[workspace]
+
 [features]
 lua54 = ["mlua/lua54"]
 lua53 = ["mlua/lua53"]
 lua52 = ["mlua/lua52"]
 lua51 = ["mlua/lua51"]
 luajit = ["mlua/luajit"]
-vendored = ["mlua/vendored"]
 
 [dependencies]
 mlua = { path = "../..", features = ["module"] }

examples/module/src/lib.rs

@@ -8,32 +8,10 @@ fn used_memory(lua: &Lua, _: ()) -> LuaResult<usize> {
     Ok(lua.used_memory())
 }
 
-fn check_userdata(_: &Lua, ud: MyUserData) -> LuaResult<i32> {
-    Ok(ud.0)
-}
-
 #[mlua::lua_module]
 fn rust_module(lua: &Lua) -> LuaResult<LuaTable> {
     let exports = lua.create_table()?;
     exports.set("sum", lua.create_function(sum)?)?;
     exports.set("used_memory", lua.create_function(used_memory)?)?;
-    exports.set("check_userdata", lua.create_function(check_userdata)?)?;
     Ok(exports)
 }
-
-#[derive(Clone, Copy)]
-struct MyUserData(i32);
-
-impl LuaUserData for MyUserData {}
-
-#[mlua::lua_module]
-fn rust_module_second(lua: &Lua) -> LuaResult<LuaTable> {
-    let exports = lua.create_table()?;
-    exports.set("userdata", lua.create_userdata(MyUserData(123))?)?;
-    Ok(exports)
-}
-
-#[mlua::lua_module]
-fn rust_module_error(_: &Lua) -> LuaResult<LuaTable> {
-    Err("custom module error".to_lua_err())
-}

examples/repl.rs

@@ -5,7 +5,7 @@ use rustyline::Editor;
 
 fn main() {
     let lua = Lua::new();
-    let mut editor = Editor::<()>::new();
+    let mut editor = Editor::<(), _>::new().expect("Failed to make rustyline editor");
 
     loop {
         let mut prompt = "> ";
@@ -19,7 +19,7 @@ fn main() {
 
             match lua.load(&line).eval::<MultiValue>() {
                 Ok(values) => {
-                    editor.add_history_entry(line);
+                    editor.add_history_entry(line).unwrap();
                     println!(
                         "{}",
                         values

mlua_derive/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "mlua_derive"
-version = "0.6.0"
+version = "0.9.0-beta.1"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-edition = "2018"
+edition = "2021"
 description = "Procedural macros for the mlua crate."
 repository = "https://github.com/khvzak/mlua"
 keywords = ["lua", "mlua"]
@@ -18,7 +18,7 @@ macros = ["proc-macro-error", "itertools", "regex", "once_cell"]
 quote = "1.0"
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 proc-macro-error = { version = "1.0", optional = true }
-syn = { version = "1.0", features = ["full"] }
+syn = { version = "2.0", features = ["full"] }
 itertools = { version = "0.10", optional = true }
 regex = { version = "1.4", optional = true }
-once_cell = { version = "1.5", optional = true }
+once_cell = { version = "1.0", optional = true }

mlua_derive/src/lib.rs

@@ -1,7 +1,8 @@
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::quote;
-use syn::{parse_macro_input, AttributeArgs, Error, ItemFn};
+use syn::meta::ParseNestedMeta;
+use syn::{parse_macro_input, ItemFn, LitStr, Result};
 
 #[cfg(feature = "macros")]
 use {
@@ -9,19 +10,41 @@ use {
     proc_macro_error::proc_macro_error,
 };
 
+#[derive(Default)]
+struct ModuleAttributes {
+    name: Option<Ident>,
+}
+
+impl ModuleAttributes {
+    fn parse(&mut self, meta: ParseNestedMeta) -> Result<()> {
+        if meta.path.is_ident("name") {
+            match meta.value() {
+                Ok(value) => {
+                    self.name = Some(value.parse::<LitStr>()?.parse()?);
+                }
+                Err(_) => {
+                    return Err(meta.error("`name` attribute must have a value"));
+                }
+            }
+        } else {
+            return Err(meta.error("unsupported module attribute"));
+        }
+        Ok(())
+    }
+}
+
 #[proc_macro_attribute]
 pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(attr as AttributeArgs);
-    let func = parse_macro_input!(item as ItemFn);
-
-    if !args.is_empty() {
-        let err = Error::new(Span::call_site(), "the macro does not support arguments")
-            .to_compile_error();
-        return err.into();
+    let mut args = ModuleAttributes::default();
+    if !attr.is_empty() {
+        let args_parser = syn::meta::parser(|meta| args.parse(meta));
+        parse_macro_input!(attr with args_parser);
     }
 
+    let func = parse_macro_input!(item as ItemFn);
     let func_name = func.sig.ident.clone();
-    let ext_entrypoint_name = Ident::new(&format!("luaopen_{}", func_name), Span::call_site());
+    let module_name = args.name.unwrap_or_else(|| func_name.clone());
+    let ext_entrypoint_name = Ident::new(&format!("luaopen_{module_name}"), Span::call_site());
 
     let wrapped = quote! {
         ::mlua::require_module_feature!();
@@ -62,37 +85,38 @@ pub fn chunk(input: TokenStream) -> TokenStream {
 
     let wrapped_code = quote! {{
         use ::mlua::{AsChunk, ChunkMode, Lua, Result, Value};
-        use ::std::marker::PhantomData;
+        use ::std::borrow::Cow;
+        use ::std::io::Result as IoResult;
         use ::std::sync::Mutex;
 
-        fn annotate<'a, F: FnOnce(&'a Lua) -> Result<Value<'a>>>(f: F) -> F { f }
+        struct InnerChunk<F: for <'a> FnOnce(&'a Lua) -> Result<Value<'a>>>(Mutex<Option<F>>);
 
-        struct InnerChunk<'a, F: FnOnce(&'a Lua) -> Result<Value<'a>>>(Mutex<Option<F>>, PhantomData<&'a ()>);
-
-        impl<'lua, F> AsChunk<'lua> for InnerChunk<'lua, F>
+        impl<F> AsChunk<'static> for InnerChunk<F>
         where
-            F: FnOnce(&'lua Lua) -> Result<Value<'lua>>,
+            F: for <'a> FnOnce(&'a Lua) -> Result<Value<'a>>,
         {
-            fn source(&self) -> &[u8] {
-                (#source).as_bytes()
-            }
-
-            fn env(&self, lua: &'lua Lua) -> Result<Option<Value<'lua>>> {
+            fn env<'lua>(&self, lua: &'lua Lua) -> Result<Value<'lua>> {
                 if #caps_len > 0 {
                     if let Ok(mut make_env) = self.0.lock() {
                         if let Some(make_env) = make_env.take() {
-                            return make_env(lua).map(Some);
+                            return make_env(lua);
                         }
                     }
                 }
-                Ok(None)
+                Ok(Value::Nil)
             }
 
             fn mode(&self) -> Option<ChunkMode> {
                 Some(ChunkMode::Text)
             }
+
+            fn source(self) -> IoResult<Cow<'static, [u8]>> {
+                Ok(Cow::Borrowed((#source).as_bytes()))
+            }
         }
 
+        fn annotate<F: for<'a> FnOnce(&'a Lua) -> Result<Value<'a>>>(f: F) -> F { f }
+
         let make_env = annotate(move |lua: &Lua| -> Result<Value> {
             let globals = lua.globals();
             let env = lua.create_table()?;
@@ -107,7 +131,7 @@ pub fn chunk(input: TokenStream) -> TokenStream {
             Ok(Value::Table(env))
         });
 
-        &InnerChunk(Mutex::new(Some(make_env)), PhantomData)
+        InnerChunk(Mutex::new(Some(make_env)))
     }};
 
     wrapped_code.into()

mlua_derive/src/token.rs

@@ -59,7 +59,7 @@ fn parse_pos(span: &Span) -> Option<(usize, usize)> {
 
     static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"bytes\(([0-9]+)\.\.([0-9]+)\)").unwrap());
 
-    match RE.captures(&format!("{:?}", span)) {
+    match RE.captures(&format!("{span:?}")) {
         Some(caps) => match (caps.get(1), caps.get(2)) {
             (Some(start), Some(end)) => Some((
                 match start.as_str().parse() {

src/chunk.rs

@@ -1,11 +1,15 @@
 use std::borrow::Cow;
+use std::collections::HashMap;
 use std::ffi::CString;
+use std::io::Result as IoResult;
+use std::path::{Path, PathBuf};
+use std::string::String as StdString;
 
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::function::Function;
 use crate::lua::Lua;
-use crate::value::{FromLuaMulti, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
@@ -14,31 +18,82 @@ use {futures_core::future::LocalBoxFuture, futures_util::future};
 ///
 /// [loadable by Lua]: https://www.lua.org/manual/5.4/manual.html#3.3.2
 /// [`Chunk`]: crate::Chunk
-pub trait AsChunk<'lua> {
-    /// Returns chunk data (can be text or binary)
-    fn source(&self) -> &[u8];
-
+pub trait AsChunk<'a> {
     /// Returns optional chunk name
-    fn name(&self) -> Option<CString> {
+    fn name(&self) -> Option<StdString> {
         None
     }
 
     /// Returns optional chunk [environment]
     ///
     /// [environment]: https://www.lua.org/manual/5.4/manual.html#2.2
-    fn env(&self, _lua: &'lua Lua) -> Result<Option<Value<'lua>>> {
-        Ok(None)
+    fn env<'lua>(&self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        let _lua = lua; // suppress warning
+        Ok(Value::Nil)
     }
 
     /// Returns optional chunk mode (text or binary)
     fn mode(&self) -> Option<ChunkMode> {
         None
     }
+
+    /// Returns chunk data (can be text or binary)
+    fn source(self) -> IoResult<Cow<'a, [u8]>>;
 }
 
-impl<'lua, T: AsRef<[u8]> + ?Sized> AsChunk<'lua> for T {
-    fn source(&self) -> &[u8] {
-        self.as_ref()
+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 {
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        Ok(Cow::Owned(self.into_bytes()))
+    }
+}
+
+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] {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self))
+    }
+}
+
+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> {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self.as_ref()))
+    }
+}
+
+impl AsChunk<'static> for &Path {
+    fn name(&self) -> Option<StdString> {
+        Some(format!("@{}", self.display()))
+    }
+
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        std::fs::read(self).map(Cow::Owned)
+    }
+}
+
+impl AsChunk<'static> for PathBuf {
+    fn name(&self) -> Option<StdString> {
+        Some(format!("@{}", self.display()))
+    }
+
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        std::fs::read(self).map(Cow::Owned)
     }
 }
 
@@ -48,10 +103,10 @@ impl<'lua, T: AsRef<[u8]> + ?Sized> AsChunk<'lua> for T {
 #[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(crate) source: Cow<'a, [u8]>,
-    pub(crate) name: Option<CString>,
-    pub(crate) env: Result<Option<Value<'lua>>>,
+    pub(crate) name: StdString,
+    pub(crate) env: Result<Value<'lua>>,
     pub(crate) mode: Option<ChunkMode>,
+    pub(crate) source: IoResult<Cow<'a, [u8]>>,
     #[cfg(feature = "luau")]
     pub(crate) compiler: Option<Compiler>,
 }
@@ -66,11 +121,14 @@ pub enum ChunkMode {
 /// Luau compiler
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub struct Compiler {
     optimization_level: u8,
     debug_level: u8,
     coverage_level: u8,
+    vector_lib: Option<String>,
+    vector_ctor: Option<String>,
+    mutable_globals: Vec<String>,
 }
 
 #[cfg(any(feature = "luau", doc))]
@@ -81,6 +139,9 @@ impl Default for Compiler {
             optimization_level: 1,
             debug_level: 1,
             coverage_level: 0,
+            vector_lib: None,
+            vector_ctor: None,
+            mutable_globals: Vec::new(),
         }
     }
 }
@@ -95,9 +156,9 @@ impl Compiler {
     /// Sets Luau compiler optimization level.
     ///
     /// Possible values:
-    /// 0 - no optimization
-    /// 1 - baseline optimization level that doesn't prevent debuggability (default)
-    /// 2 - includes optimizations that harm debuggability such as inlining
+    /// * 0 - no optimization
+    /// * 1 - baseline optimization level that doesn't prevent debuggability (default)
+    /// * 2 - includes optimizations that harm debuggability such as inlining
     pub fn set_optimization_level(mut self, level: u8) -> Self {
         self.optimization_level = level;
         self
@@ -106,9 +167,9 @@ impl Compiler {
     /// Sets Luau compiler debug level.
     ///
     /// Possible values:
-    /// 0 - no debugging support
-    /// 1 - line info & function names only; sufficient for backtraces (default)
-    /// 2 - full debug info with local & upvalue names; necessary for debugger
+    /// * 0 - no debugging support
+    /// * 1 - line info & function names only; sufficient for backtraces (default)
+    /// * 2 - full debug info with local & upvalue names; necessary for debugger
     pub fn set_debug_level(mut self, level: u8) -> Self {
         self.debug_level = level;
         self
@@ -117,27 +178,70 @@ impl Compiler {
     /// Sets Luau compiler code coverage level.
     ///
     /// Possible values:
-    /// 0 - no code coverage support (default)
-    /// 1 - statement coverage
-    /// 2 - statement and expression coverage (verbose)
+    /// * 0 - no code coverage support (default)
+    /// * 1 - statement coverage
+    /// * 2 - statement and expression coverage (verbose)
     pub fn set_coverage_level(mut self, level: u8) -> Self {
         self.coverage_level = level;
         self
     }
 
+    #[doc(hidden)]
+    pub fn set_vector_lib(mut self, lib: Option<String>) -> Self {
+        self.vector_lib = lib;
+        self
+    }
+
+    #[doc(hidden)]
+    pub fn set_vector_ctor(mut self, ctor: Option<String>) -> Self {
+        self.vector_ctor = ctor;
+        self
+    }
+
+    /// Sets a list of globals that are mutable.
+    ///
+    /// It disables the import optimization for fields accessed through these.
+    pub fn set_mutable_globals(mut self, globals: Vec<String>) -> Self {
+        self.mutable_globals = globals;
+        self
+    }
+
     /// Compiles the `source` into bytecode.
     pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
         use std::os::raw::c_int;
         use std::ptr;
 
+        let vector_lib = self.vector_lib.clone();
+        let vector_lib = vector_lib.and_then(|lib| CString::new(lib).ok());
+        let vector_lib = vector_lib.as_ref();
+        let vector_ctor = self.vector_ctor.clone();
+        let vector_ctor = vector_ctor.and_then(|ctor| CString::new(ctor).ok());
+        let vector_ctor = vector_ctor.as_ref();
+
+        let mutable_globals = self
+            .mutable_globals
+            .iter()
+            .map(|name| CString::new(name.clone()).ok())
+            .collect::<Option<Vec<_>>>()
+            .unwrap_or_default();
+        let mut mutable_globals = mutable_globals
+            .iter()
+            .map(|s| s.as_ptr())
+            .collect::<Vec<_>>();
+        let mut mutable_globals_ptr = ptr::null_mut();
+        if !mutable_globals.is_empty() {
+            mutable_globals.push(ptr::null());
+            mutable_globals_ptr = mutable_globals.as_mut_ptr();
+        }
+
         unsafe {
             let options = ffi::lua_CompileOptions {
                 optimizationLevel: self.optimization_level as c_int,
                 debugLevel: self.debug_level as c_int,
                 coverageLevel: self.coverage_level as c_int,
-                vectorLib: ptr::null(),
-                vectorCtor: ptr::null(),
-                mutableGlobals: ptr::null_mut(),
+                vectorLib: vector_lib.map_or(ptr::null(), |s| s.as_ptr()),
+                vectorCtor: vector_ctor.map_or(ptr::null(), |s| s.as_ptr()),
+                mutableGlobals: mutable_globals_ptr,
             };
             ffi::luau_compile(source.as_ref(), options)
         }
@@ -146,15 +250,9 @@ impl Compiler {
 
 impl<'lua, 'a> Chunk<'lua, 'a> {
     /// Sets the name of this chunk, which results in more informative error traces.
-    pub fn set_name<S: AsRef<[u8]> + ?Sized>(mut self, name: &S) -> Result<Chunk<'lua, 'a>> {
-        let name =
-            CString::new(name.as_ref().to_vec()).map_err(|e| Error::ToLuaConversionError {
-                from: "&str",
-                to: "string",
-                message: Some(e.to_string()),
-            })?;
-        self.name = Some(name);
-        Ok(self)
+    pub fn set_name(mut self, name: impl Into<String>) -> Self {
+        self.name = name.into();
+        self
     }
 
     /// Sets the first upvalue (`_ENV`) of the loaded chunk to the given value.
@@ -168,77 +266,29 @@ 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: ToLua<'lua>>(mut self, env: V) -> Result<Chunk<'lua, 'a>> {
-        // Prefer to propagate errors here and wrap to `Ok`
-        self.env = Ok(Some(env.to_lua(self.lua)?));
-        Ok(self)
+    pub fn set_environment<V: IntoLua<'lua>>(mut self, env: V) -> Self {
+        self.env = env.into_lua(self.lua);
+        self
     }
 
     /// 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.
     /// Running maliciously crafted bytecode can crash the interpreter.
-    pub fn set_mode(mut self, mode: ChunkMode) -> Chunk<'lua, 'a> {
+    pub fn set_mode(mut self, mode: ChunkMode) -> Self {
         self.mode = Some(mode);
         self
     }
 
-    /// Sets Luau compiler optimization level.
+    /// Sets or overwrites a Luau compiler used for this chunk.
     ///
-    /// See [`Compiler::set_optimization_level`] for details.
+    /// See [`Compiler`] for details and possible options.
     ///
-    /// Requires `feature = "luau`
+    /// Requires `feature = "luau"`
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn set_optimization_level(mut self, level: u8) -> Self {
-        self.compiler
-            .get_or_insert_with(Default::default)
-            .set_optimization_level(level);
-        self
-    }
-
-    /// Sets Luau compiler debug level.
-    ///
-    /// See [`Compiler::set_debug_level`] for details.
-    ///
-    /// Requires `feature = "luau`
-    #[cfg(any(feature = "luau", doc))]
-    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn set_debug_level(mut self, level: u8) -> Self {
-        self.compiler
-            .get_or_insert_with(Default::default)
-            .set_debug_level(level);
-        self
-    }
-
-    /// Sets Luau compiler code coverage level.
-    ///
-    /// See [`Compiler::set_coverage_level`] for details.
-    ///
-    /// Requires `feature = "luau`
-    #[cfg(any(feature = "luau", doc))]
-    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn set_coverage_level(mut self, level: u8) -> Self {
-        self.compiler
-            .get_or_insert_with(Default::default)
-            .set_coverage_level(level);
-        self
-    }
-
-    /// Compiles the chunk and changes mode to binary.
-    ///
-    /// It does nothing if the chunk is already binary.
-    #[cfg(feature = "luau")]
-    #[doc(hidden)]
-    pub fn compile(mut self) -> Self {
-        if self.detect_mode() == ChunkMode::Text {
-            let data = self
-                .compiler
-                .unwrap_or_default()
-                .compile(self.source.as_ref());
-            self.mode = Some(ChunkMode::Binary);
-            self.source = Cow::Owned(data);
-        }
+    pub fn set_compiler(mut self, compiler: Compiler) -> Self {
+        self.compiler = Some(compiler);
         self
     }
 
@@ -259,10 +309,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// [`exec`]: #method.exec
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn exec_async<'fut>(self) -> LocalBoxFuture<'fut, Result<()>>
-    where
-        'lua: 'fut,
-    {
+    pub fn exec_async(self) -> LocalBoxFuture<'lua, Result<()>> {
         self.call_async(())
     }
 
@@ -311,7 +358,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: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(self, args: A) -> Result<R> {
+    pub fn call<A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(self, args: A) -> Result<R> {
         self.into_function()?.call(args)
     }
 
@@ -327,7 +374,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     pub fn call_async<'fut, A, R>(self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         match self.into_function() {
@@ -339,60 +386,128 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// Load this chunk into a regular `Function`.
     ///
     /// This simply compiles the chunk without actually executing it.
-    pub fn into_function(self) -> Result<Function<'lua>> {
-        #[cfg(not(feature = "luau"))]
-        let self_ = self;
+    #[cfg_attr(not(feature = "luau"), allow(unused_mut))]
+    pub fn into_function(mut self) -> Result<Function<'lua>> {
         #[cfg(feature = "luau")]
-        let self_ = match self.compiler {
-            // We don't need to compile source if no compiler options set
-            Some(_) => self.compile(),
-            _ => self,
-        };
+        if self.compiler.is_some() {
+            // We don't need to compile source if no compiler set
+            self.compile();
+        }
 
-        self_.lua.load_chunk(
-            self_.source.as_ref(),
-            self_.name.as_ref(),
-            self_.env()?,
-            self_.mode,
-        )
+        let name = Self::convert_name(self.name)?;
+        self.lua
+            .load_chunk(Some(&name), self.env?, self.mode, self.source?.as_ref())
     }
 
-    fn env(&self) -> Result<Option<Value<'lua>>> {
-        self.env.clone()
+    /// Compiles the chunk and changes mode to binary.
+    ///
+    /// It does nothing if the chunk is already binary.
+    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);
+                    self.source = Ok(Cow::Owned(data));
+                    self.mode = Some(ChunkMode::Binary);
+                }
+                #[cfg(not(feature = "luau"))]
+                if let Ok(func) = self.lua.load_chunk(None, Value::Nil, None, source.as_ref()) {
+                    let data = func.dump(false);
+                    self.source = Ok(Cow::Owned(data));
+                    self.mode = Some(ChunkMode::Binary);
+                }
+            }
+        }
     }
 
-    fn expression_source(&self) -> Vec<u8> {
-        let mut buf = Vec::with_capacity(b"return ".len() + self.source.len());
-        buf.extend(b"return ");
-        buf.extend(self.source.as_ref());
-        buf
+    /// Fetches compiled bytecode of this chunk from the cache.
+    ///
+    /// If not found, compiles the source code and stores it on the cache.
+    pub(crate) fn try_cache(mut self) -> Self {
+        struct ChunksCache(HashMap<Vec<u8>, Vec<u8>>);
+
+        // Try to fetch compiled chunk from cache
+        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>() {
+                    if let Some(data) = cache.0.get(source.as_ref()) {
+                        self.source = Ok(Cow::Owned(data.clone()));
+                        self.mode = Some(ChunkMode::Binary);
+                        return self;
+                    }
+                }
+                text_source = Some(source.as_ref().to_vec());
+            }
+        }
+
+        // Compile and cache the chunk
+        if let Some(text_source) = text_source {
+            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>() {
+                        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());
+                        self.lua.set_app_data(cache);
+                    }
+                }
+            }
+        }
+
+        self
     }
 
     fn to_expression(&self) -> Result<Function<'lua>> {
         // We assume that mode is Text
-        let source = self.expression_source();
+        let source = self.source.as_ref();
+        let source = source.map_err(|err| Error::RuntimeError(err.to_string()))?;
+        let source = Self::expression_source(source);
         // We don't need to compile source if no compiler options set
         #[cfg(feature = "luau")]
-        let source = self.compiler.map(|c| c.compile(&source)).unwrap_or(source);
+        let source = self
+            .compiler
+            .as_ref()
+            .map(|c| c.compile(&source))
+            .unwrap_or(source);
 
+        let name = Self::convert_name(self.name.clone())?;
         self.lua
-            .load_chunk(&source, self.name.as_ref(), self.env()?, None)
+            .load_chunk(Some(&name), self.env.clone()?, None, &source)
     }
 
     fn detect_mode(&self) -> ChunkMode {
-        match self.mode {
-            Some(mode) => mode,
-            None => {
+        match (self.mode, &self.source) {
+            (Some(mode), _) => mode,
+            (None, Ok(source)) => {
                 #[cfg(not(feature = "luau"))]
-                if self.source.starts_with(ffi::LUA_SIGNATURE) {
+                if source.starts_with(ffi::LUA_SIGNATURE) {
                     return ChunkMode::Binary;
                 }
                 #[cfg(feature = "luau")]
-                if self.source[0] < b'\n' {
+                if *source.first().unwrap_or(&u8::MAX) < b'\n' {
                     return ChunkMode::Binary;
                 }
                 ChunkMode::Text
             }
+            (None, Err(_)) => ChunkMode::Text, // any value is fine
         }
     }
+
+    fn convert_name(name: String) -> Result<CString> {
+        CString::new(name).map_err(|err| Error::RuntimeError(format!("invalid name: {err}")))
+    }
+
+    fn expression_source(source: &[u8]) -> Vec<u8> {
+        let mut buf = Vec::with_capacity(b"return ".len() + source.len());
+        buf.extend(b"return ");
+        buf.extend(source);
+        buf
+    }
 }

src/conversion.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::convert::TryInto;
@@ -17,12 +15,22 @@ use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
 use crate::types::{LightUserData, MaybeSend};
-use crate::userdata::{AnyUserData, UserData};
-use crate::value::{FromLua, Nil, ToLua, Value};
+use crate::userdata::{AnyUserData, UserData, UserDataRef, UserDataRefMut};
+use crate::value::{FromLua, IntoLua, Nil, Value};
 
-impl<'lua> ToLua<'lua> for Value<'lua> {
+#[cfg(feature = "unstable")]
+use crate::{
+    function::{OwnedFunction, WrappedFunction},
+    table::OwnedTable,
+    userdata::OwnedAnyUserData,
+};
+
+#[cfg(all(feature = "async", feature = "unstable"))]
+use crate::function::WrappedAsyncFunction;
+
+impl<'lua> IntoLua<'lua> for Value<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(self)
     }
 }
@@ -34,9 +42,9 @@ impl<'lua> FromLua<'lua> for Value<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for String<'lua> {
+impl<'lua> IntoLua<'lua> for String<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(self))
     }
 }
@@ -54,9 +62,9 @@ impl<'lua> FromLua<'lua> for String<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for Table<'lua> {
+impl<'lua> IntoLua<'lua> for Table<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(self))
     }
 }
@@ -75,9 +83,25 @@ impl<'lua> FromLua<'lua> for Table<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for Function<'lua> {
+#[cfg(feature = "unstable")]
+impl<'lua> IntoLua<'lua> for OwnedTable {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Table(Table(lua.adopt_owned_ref(self.0))))
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl<'lua> FromLua<'lua> for OwnedTable {
+    #[inline]
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<OwnedTable> {
+        Table::from_lua(value, lua).map(|s| s.into_owned())
+    }
+}
+
+impl<'lua> IntoLua<'lua> for Function<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Function(self))
     }
 }
@@ -96,9 +120,41 @@ impl<'lua> FromLua<'lua> for Function<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for Thread<'lua> {
+#[cfg(feature = "unstable")]
+impl<'lua> IntoLua<'lua> for OwnedFunction {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Function(Function(lua.adopt_owned_ref(self.0))))
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl<'lua> FromLua<'lua> for OwnedFunction {
+    #[inline]
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<OwnedFunction> {
+        Function::from_lua(value, lua).map(|s| s.into_owned())
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl<'lua> IntoLua<'lua> for WrappedFunction<'lua> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.create_callback(self.0).map(Value::Function)
+    }
+}
+
+#[cfg(all(feature = "async", feature = "unstable"))]
+impl<'lua> IntoLua<'lua> for WrappedAsyncFunction<'lua> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.create_async_callback(self.0).map(Value::Function)
+    }
+}
+
+impl<'lua> IntoLua<'lua> for Thread<'lua> {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Thread(self))
     }
 }
@@ -117,9 +173,9 @@ impl<'lua> FromLua<'lua> for Thread<'lua> {
     }
 }
 
-impl<'lua> ToLua<'lua> for AnyUserData<'lua> {
+impl<'lua> IntoLua<'lua> for AnyUserData<'lua> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::UserData(self))
     }
 }
@@ -138,30 +194,46 @@ impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
     }
 }
 
-impl<'lua, T: 'static + MaybeSend + UserData> ToLua<'lua> for T {
+#[cfg(feature = "unstable")]
+impl<'lua> IntoLua<'lua> for OwnedAnyUserData {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::UserData(AnyUserData(lua.adopt_owned_ref(self.0))))
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl<'lua> FromLua<'lua> for OwnedAnyUserData {
+    #[inline]
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<OwnedAnyUserData> {
+        AnyUserData::from_lua(value, lua).map(|s| s.into_owned())
+    }
+}
+
+impl<'lua, T: 'static + MaybeSend + UserData> IntoLua<'lua> for T {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::UserData(lua.create_userdata(self)?))
     }
 }
 
-impl<'lua, T: 'static + UserData + Clone> FromLua<'lua> for T {
+impl<'lua, T: 'static> FromLua<'lua> for UserDataRef<'lua, T> {
     #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<T> {
-        match value {
-            Value::UserData(ud) => Ok(ud.borrow::<T>()?.clone()),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "userdata",
-                message: None,
-            }),
-        }
+    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+        Self::from_value(value)
     }
 }
 
-impl<'lua> ToLua<'lua> for Error {
+impl<'lua, T: 'static> FromLua<'lua> for UserDataRefMut<'lua, T> {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+        Self::from_value(value)
+    }
+}
+
+impl<'lua> IntoLua<'lua> for Error {
+    #[inline]
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Error(self))
     }
 }
@@ -180,9 +252,9 @@ impl<'lua> FromLua<'lua> for Error {
     }
 }
 
-impl<'lua> ToLua<'lua> for bool {
+impl<'lua> IntoLua<'lua> for bool {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Boolean(self))
     }
 }
@@ -198,9 +270,9 @@ impl<'lua> FromLua<'lua> for bool {
     }
 }
 
-impl<'lua> ToLua<'lua> for LightUserData {
+impl<'lua> IntoLua<'lua> for LightUserData {
     #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::LightUserData(self))
     }
 }
@@ -219,9 +291,9 @@ impl<'lua> FromLua<'lua> for LightUserData {
     }
 }
 
-impl<'lua> ToLua<'lua> for StdString {
+impl<'lua> IntoLua<'lua> for StdString {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&self)?))
     }
 }
@@ -242,26 +314,29 @@ impl<'lua> FromLua<'lua> for StdString {
     }
 }
 
-impl<'lua> ToLua<'lua> for &str {
+impl<'lua> IntoLua<'lua> for &str {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self)?))
     }
 }
 
-impl<'lua> ToLua<'lua> for Cow<'_, str> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua> IntoLua<'lua> for Cow<'_, str> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.as_bytes())?))
     }
 }
 
-impl<'lua> ToLua<'lua> for Box<str> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua> IntoLua<'lua> for Box<str> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&*self)?))
     }
 }
 
 impl<'lua> FromLua<'lua> for Box<str> {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         let ty = value.type_name();
         Ok(lua
@@ -277,13 +352,15 @@ impl<'lua> FromLua<'lua> for Box<str> {
     }
 }
 
-impl<'lua> ToLua<'lua> for CString {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua> IntoLua<'lua> for CString {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.as_bytes())?))
     }
 }
 
 impl<'lua> FromLua<'lua> for CString {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         let ty = value.type_name();
         let string = lua
@@ -305,25 +382,29 @@ impl<'lua> FromLua<'lua> for CString {
     }
 }
 
-impl<'lua> ToLua<'lua> for &CStr {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua> IntoLua<'lua> for &CStr {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.to_bytes())?))
     }
 }
 
-impl<'lua> ToLua<'lua> for Cow<'_, CStr> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua> IntoLua<'lua> for Cow<'_, CStr> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(self.to_bytes())?))
     }
 }
 
-impl<'lua> ToLua<'lua> for BString {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua> IntoLua<'lua> for BString {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::String(lua.create_string(&self)?))
     }
 }
 
 impl<'lua> FromLua<'lua> for BString {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         let ty = value.type_name();
         Ok(BString::from(
@@ -339,16 +420,18 @@ impl<'lua> FromLua<'lua> for BString {
     }
 }
 
-impl<'lua> ToLua<'lua> for &BStr {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::String(lua.create_string(&self)?))
+impl<'lua> IntoLua<'lua> for &BStr {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::String(lua.create_string(self)?))
     }
 }
 
 macro_rules! lua_convert_int {
     ($x:ty) => {
-        impl<'lua> ToLua<'lua> for $x {
-            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        impl<'lua> IntoLua<'lua> for $x {
+            #[inline]
+            fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
                 cast(self)
                     .map(Value::Integer)
                     .or_else(|| cast(self).map(Value::Number))
@@ -362,22 +445,27 @@ macro_rules! lua_convert_int {
         }
 
         impl<'lua> FromLua<'lua> for $x {
+            #[inline]
             fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
                 let ty = value.type_name();
-                (if let Value::Integer(i) = value {
-                    cast(i)
-                } else if let Some(i) = lua.coerce_integer(value.clone())? {
-                    cast(i)
-                } else {
-                    cast(lua.coerce_number(value)?.ok_or_else(|| {
-                        Error::FromLuaConversionError {
-                            from: ty,
-                            to: stringify!($x),
-                            message: Some(
-                                "expected number or string coercible to number".to_string(),
-                            ),
+                (match value {
+                    Value::Integer(i) => cast(i),
+                    Value::Number(n) => cast(n),
+                    _ => {
+                        if let Some(i) = lua.coerce_integer(value.clone())? {
+                            cast(i)
+                        } else {
+                            cast(lua.coerce_number(value)?.ok_or_else(|| {
+                                Error::FromLuaConversionError {
+                                    from: ty,
+                                    to: stringify!($x),
+                                    message: Some(
+                                        "expected number or string coercible to number".to_string(),
+                                    ),
+                                }
+                            })?)
                         }
-                    })?)
+                    }
                 })
                 .ok_or_else(|| Error::FromLuaConversionError {
                     from: ty,
@@ -404,8 +492,9 @@ lua_convert_int!(usize);
 
 macro_rules! lua_convert_float {
     ($x:ty) => {
-        impl<'lua> ToLua<'lua> for $x {
-            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+        impl<'lua> IntoLua<'lua> for $x {
+            #[inline]
+            fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
                 cast(self)
                     .ok_or_else(|| Error::ToLuaConversionError {
                         from: stringify!($x),
@@ -417,6 +506,7 @@ macro_rules! lua_convert_float {
         }
 
         impl<'lua> FromLua<'lua> for $x {
+            #[inline]
             fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
                 let ty = value.type_name();
                 lua.coerce_number(value)?
@@ -440,22 +530,24 @@ macro_rules! lua_convert_float {
 lua_convert_float!(f32);
 lua_convert_float!(f64);
 
-impl<'lua, T> ToLua<'lua> for &[T]
+impl<'lua, T> IntoLua<'lua> for &[T]
 where
-    T: Clone + ToLua<'lua>,
+    T: Clone + IntoLua<'lua>,
 {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(
             lua.create_sequence_from(self.iter().cloned())?,
         ))
     }
 }
 
-impl<'lua, T, const N: usize> ToLua<'lua> for [T; N]
+impl<'lua, T, const N: usize> IntoLua<'lua> for [T; N]
 where
-    T: ToLua<'lua>,
+    T: IntoLua<'lua>,
 {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self)?))
     }
 }
@@ -464,6 +556,7 @@ impl<'lua, T, const N: usize> FromLua<'lua> for [T; N]
 where
     T: FromLua<'lua>,
 {
+    #[inline]
     fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
         match value {
             #[cfg(feature = "luau")]
@@ -495,25 +588,29 @@ where
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua, T: IntoLua<'lua>> IntoLua<'lua> for Box<[T]> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self.into_vec())?))
     }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Box<[T]> {
+    #[inline]
     fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
         Ok(Vec::<T>::from_lua(value, lua)?.into_boxed_slice())
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Vec<T> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua, T: IntoLua<'lua>> IntoLua<'lua> for Vec<T> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_sequence_from(self)?))
     }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
         match value {
             #[cfg(feature = "luau")]
@@ -532,10 +629,11 @@ impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
     }
 }
 
-impl<'lua, K: Eq + Hash + ToLua<'lua>, V: ToLua<'lua>, S: BuildHasher> ToLua<'lua>
+impl<'lua, K: Eq + Hash + IntoLua<'lua>, V: IntoLua<'lua>, S: BuildHasher> IntoLua<'lua>
     for HashMap<K, V, S>
 {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(self)?))
     }
 }
@@ -543,6 +641,7 @@ impl<'lua, K: Eq + Hash + ToLua<'lua>, V: ToLua<'lua>, S: BuildHasher> ToLua<'lu
 impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
     for HashMap<K, V, S>
 {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         if let Value::Table(table) = value {
             table.pairs().collect()
@@ -556,13 +655,15 @@ impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>, S: BuildHasher + Defa
     }
 }
 
-impl<'lua, K: Ord + ToLua<'lua>, V: ToLua<'lua>> ToLua<'lua> for BTreeMap<K, V> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua, K: Ord + IntoLua<'lua>, V: IntoLua<'lua>> IntoLua<'lua> for BTreeMap<K, V> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(self)?))
     }
 }
 
 impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<K, V> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         if let Value::Table(table) = value {
             table.pairs().collect()
@@ -576,8 +677,9 @@ impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<
     }
 }
 
-impl<'lua, T: Eq + Hash + ToLua<'lua>, S: BuildHasher> ToLua<'lua> for HashSet<T, S> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua, T: Eq + Hash + IntoLua<'lua>, S: BuildHasher> IntoLua<'lua> for HashSet<T, S> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(
             self.into_iter().map(|val| (val, true)),
         )?))
@@ -585,6 +687,7 @@ impl<'lua, T: Eq + Hash + ToLua<'lua>, S: BuildHasher> ToLua<'lua> for HashSet<T
 }
 
 impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua> for HashSet<T, S> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         match value {
             Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
@@ -601,8 +704,9 @@ impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
     }
 }
 
-impl<'lua, T: Ord + ToLua<'lua>> ToLua<'lua> for BTreeSet<T> {
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+impl<'lua, T: Ord + IntoLua<'lua>> IntoLua<'lua> for BTreeSet<T> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         Ok(Value::Table(lua.create_table_from(
             self.into_iter().map(|val| (val, true)),
         )?))
@@ -610,6 +714,7 @@ impl<'lua, T: Ord + ToLua<'lua>> ToLua<'lua> for BTreeSet<T> {
 }
 
 impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
+    #[inline]
     fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
         match value {
             Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
@@ -626,11 +731,11 @@ impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
+impl<'lua, T: IntoLua<'lua>> IntoLua<'lua> for Option<T> {
     #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
         match self {
-            Some(val) => val.to_lua(lua),
+            Some(val) => val.into_lua(lua),
             None => Ok(Nil),
         }
     }

src/error.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as IoError;
@@ -9,6 +7,8 @@ use std::str::Utf8Error;
 use std::string::String as StdString;
 use std::sync::Arc;
 
+use crate::private::Sealed;
+
 /// Error type returned by `mlua` methods.
 #[derive(Debug, Clone)]
 #[non_exhaustive]
@@ -71,6 +71,20 @@ pub enum Error {
     StackError,
     /// Too many arguments to `Function::bind`
     BindError,
+    /// Bad argument received from Lua (usually when calling a function).
+    ///
+    /// This error can help to identify the argument that caused the error
+    /// (which is stored in the corresponding field).
+    BadArgument {
+        /// Function that was called.
+        to: Option<StdString>,
+        /// Argument position (usually starts from 1).
+        pos: usize,
+        /// Argument name.
+        name: Option<StdString>,
+        /// Underlying error returned when converting argument to a Lua value.
+        cause: Arc<Error>,
+    },
     /// A Rust value could not be converted to a Lua value.
     ToLuaConversionError {
         /// Name of the Rust type that could not be converted.
@@ -142,8 +156,11 @@ pub enum Error {
     ///
     /// [`MetaMethod`]: crate::MetaMethod
     MetaMethodTypeError {
+        /// Name of the metamethod.
         method: StdString,
+        /// Passed value type.
         type_name: &'static str,
+        /// A string containing more detailed error information.
         message: Option<StdString>,
     },
     /// A [`RegistryKey`] produced from a different Lua state was used.
@@ -178,6 +195,13 @@ pub enum Error {
     /// 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>),
+    /// An error with additional context.
+    WithContext {
+        /// A string containing additional context.
+        context: StdString,
+        /// Underlying error.
+        cause: Arc<Error>,
+    },
 }
 
 /// A specialized `Result` type used by `mlua`'s API.
@@ -187,17 +211,17 @@ pub type Result<T> = StdResult<T, Error>;
 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::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {message}"),
+            Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {msg}"),
             Error::MemoryError(ref msg) => {
-                write!(fmt, "memory error: {}", msg)
+                write!(fmt, "memory error: {msg}")
             }
             #[cfg(any(feature = "lua53", feature = "lua52"))]
             Error::GarbageCollectorError(ref msg) => {
-                write!(fmt, "garbage collector error: {}", msg)
+                write!(fmt, "garbage collector error: {msg}")
             }
             Error::SafetyError(ref msg) => {
-                write!(fmt, "safety error: {}", msg)
+                write!(fmt, "safety error: {msg}")
             },
             Error::MemoryLimitNotAvailable => {
                 write!(fmt, "setting memory limit is not available")
@@ -218,18 +242,29 @@ impl fmt::Display for Error {
                 fmt,
                 "too many arguments to Function::bind"
             ),
+            Error::BadArgument { ref to, pos, ref name, ref cause } => {
+                if let Some(name) = name {
+                    write!(fmt, "bad argument `{name}`")?;
+                } else {
+                    write!(fmt, "bad argument #{pos}")?;
+                }
+                if let Some(to) = to {
+                    write!(fmt, " to `{to}`")?;
+                }
+                write!(fmt, ": {cause}")
+            },
             Error::ToLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting {} to Lua {}", from, to)?;
+                write!(fmt, "error converting {from} to Lua {to}")?;
                 match *message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                 }
             }
             Error::FromLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting Lua {} to {}", from, to)?;
+                write!(fmt, "error converting Lua {from} to {to}")?;
                 match *message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                 }
             }
             Error::CoroutineInactive => write!(fmt, "cannot resume inactive coroutine"),
@@ -237,25 +272,25 @@ impl fmt::Display for Error {
             Error::UserDataDestructed => write!(fmt, "userdata has been destructed"),
             Error::UserDataBorrowError => write!(fmt, "userdata already mutably borrowed"),
             Error::UserDataBorrowMutError => write!(fmt, "userdata already borrowed"),
-            Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {} is restricted", method),
+            Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {method} is restricted"),
             Error::MetaMethodTypeError { ref method, type_name, ref message } => {
-                write!(fmt, "metamethod {} has unsupported type {}", method, type_name)?;
+                write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
                 match *message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                 }
             }
             Error::MismatchedRegistryKey => {
                 write!(fmt, "RegistryKey used from different Lua state")
             }
             Error::CallbackError { ref cause, ref traceback } => {
-                writeln!(fmt, "callback error")?;
                 // 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 {
                     cause = cause2;
                     full_traceback = Some(traceback2);
                 }
+                writeln!(fmt, "{cause}")?;
                 if let Some(full_traceback) = full_traceback {
                     let traceback = traceback.trim_start_matches("stack traceback:");
                     let traceback = traceback.trim_start().trim_end();
@@ -269,20 +304,24 @@ impl fmt::Display for Error {
                 } else {
                     writeln!(fmt, "{}", traceback.trim_end())?;
                 }
-                write!(fmt, "caused by: {}", cause)
+                Ok(())
             }
             Error::PreviouslyResumedPanic => {
                 write!(fmt, "previously resumed panic returned again")
             }
             #[cfg(feature = "serialize")]
             Error::SerializeError(ref err) => {
-                write!(fmt, "serialize error: {}", err)
+                write!(fmt, "serialize error: {err}")
             },
             #[cfg(feature = "serialize")]
             Error::DeserializeError(ref err) => {
-                write!(fmt, "deserialize error: {}", err)
+                write!(fmt, "deserialize error: {err}")
             },
-            Error::ExternalError(ref err) => write!(fmt, "{}", err),
+            Error::ExternalError(ref err) => write!(fmt, "{err}"),
+            Error::WithContext { ref context, ref cause } => {
+                writeln!(fmt, "{context}")?;
+                write!(fmt, "{cause}")
+            }
         }
     }
 }
@@ -302,47 +341,122 @@ impl StdError for Error {
 }
 
 impl Error {
-    pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Error {
+    /// Wraps an external error object.
+    pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Self {
         Error::ExternalError(err.into().into())
     }
+
+    /// Attempts to downcast the external error object to a concrete type by reference.
+    pub fn downcast_ref<T>(&self) -> Option<&T>
+    where
+        T: StdError + 'static,
+    {
+        match self {
+            Error::ExternalError(err) => err.downcast_ref(),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn bad_self_argument(to: &str, cause: Error) -> Self {
+        Error::BadArgument {
+            to: Some(to.to_string()),
+            pos: 1,
+            name: Some("self".to_string()),
+            cause: Arc::new(cause),
+        }
+    }
+
+    pub(crate) fn from_lua_conversion<'a>(
+        from: &'static str,
+        to: &'static str,
+        message: impl Into<Option<&'a str>>,
+    ) -> Self {
+        Error::FromLuaConversionError {
+            from,
+            to,
+            message: message.into().map(|s| s.into()),
+        }
+    }
 }
 
 pub trait ExternalError {
-    fn to_lua_err(self) -> Error;
+    fn into_lua_err(self) -> Error;
 }
 
 impl<E: Into<Box<dyn StdError + Send + Sync>>> ExternalError for E {
-    fn to_lua_err(self) -> Error {
+    fn into_lua_err(self) -> Error {
         Error::external(self)
     }
 }
 
 pub trait ExternalResult<T> {
-    fn to_lua_err(self) -> Result<T>;
+    fn into_lua_err(self) -> Result<T>;
 }
 
 impl<T, E> ExternalResult<T> for StdResult<T, E>
 where
     E: ExternalError,
 {
-    fn to_lua_err(self) -> Result<T> {
-        self.map_err(|e| e.to_lua_err())
+    fn into_lua_err(self) -> Result<T> {
+        self.map_err(|e| e.into_lua_err())
     }
 }
 
-impl std::convert::From<AddrParseError> for Error {
+/// Provides the `context` method for [`Error`] and `Result<T, Error>`.
+pub trait ErrorContext: Sealed {
+    /// Wraps the error value with additional context.
+    fn context<C: fmt::Display>(self, context: C) -> Self;
+
+    /// Wrap the error value with additional context that is evaluated lazily
+    /// only once an error does occur.
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self;
+}
+
+impl ErrorContext for Error {
+    fn context<C: fmt::Display>(self, context: C) -> Self {
+        Error::WithContext {
+            context: context.to_string(),
+            cause: Arc::new(self),
+        }
+    }
+
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
+        Error::WithContext {
+            context: f(&self).to_string(),
+            cause: Arc::new(self),
+        }
+    }
+}
+
+impl<T> ErrorContext for StdResult<T, Error> {
+    fn context<C: fmt::Display>(self, context: C) -> Self {
+        self.map_err(|err| Error::WithContext {
+            context: context.to_string(),
+            cause: Arc::new(err),
+        })
+    }
+
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
+        self.map_err(|err| Error::WithContext {
+            context: f(&err).to_string(),
+            cause: Arc::new(err),
+        })
+    }
+}
+
+impl From<AddrParseError> for Error {
     fn from(err: AddrParseError) -> Self {
         Error::external(err)
     }
 }
 
-impl std::convert::From<IoError> for Error {
+impl From<IoError> for Error {
     fn from(err: IoError) -> Self {
         Error::external(err)
     }
 }
 
-impl std::convert::From<Utf8Error> for Error {
+impl From<Utf8Error> for Error {
     fn from(err: Utf8Error) -> Self {
         Error::external(err)
     }

src/ffi/lua51/compat.rs

@@ -155,6 +155,13 @@ pub unsafe fn lua_absindex(L: *mut lua_State, mut idx: c_int) -> c_int {
 
 pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
     idx = lua_absindex(L, idx);
+    if n > 0 {
+        // Faster version
+        for _ in 0..n {
+            lua_insert(L, idx);
+        }
+        return;
+    }
     let n_elems = lua_gettop(L) - idx + 1;
     if n < 0 {
         n += n_elems;
@@ -561,11 +568,10 @@ pub unsafe fn luaL_requiref(
             lua_getfield(L, -1, modname);
         }
     }
-    if cfg!(feature = "lua51") && glb != 0 {
+    if glb != 0 {
         lua_pushvalue(L, -1);
         lua_setglobal(L, modname);
-    }
-    if cfg!(feature = "luajit") && glb == 0 {
+    } else {
         lua_pushnil(L);
         lua_setglobal(L, modname);
     }

src/ffi/lua51/lua.rs

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

src/ffi/lua52/compat.rs

@@ -27,6 +27,13 @@ unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
 
 pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
     idx = lua_absindex(L, idx);
+    if n > 0 {
+        // Faster version
+        for _ in 0..n {
+            lua_insert(L, idx);
+        }
+        return;
+    }
     let n_elems = lua_gettop(L) - idx + 1;
     if n < 0 {
         n += n_elems;

src/ffi/lua52/lua.rs

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

src/ffi/lua53/lua.rs

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

src/ffi/lua54/lua.rs

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

src/ffi/luau/compat.rs

@@ -90,6 +90,13 @@ unsafe fn compat53_pushfuncname(L: *mut lua_State, level: c_int, ar: *mut lua_De
 
 pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
     idx = lua_absindex(L, idx);
+    if n > 0 {
+        // Faster version
+        for _ in 0..n {
+            lua_insert(L, idx);
+        }
+        return;
+    }
     let n_elems = lua_gettop(L) - idx + 1;
     if n < 0 {
         n += n_elems;
@@ -334,7 +341,7 @@ pub unsafe fn luaL_loadbufferx(
         fn free(p: *mut c_void);
     }
 
-    let chunk_is_text = (*data as u8) >= b'\n';
+    let chunk_is_text = size == 0 || (*data as u8) >= b'\n';
     if !mode.is_null() {
         let modeb = CStr::from_ptr(mode).to_bytes();
         if !chunk_is_text && !modeb.contains(&b'b') {
@@ -416,7 +423,7 @@ pub unsafe fn luaL_traceback(
             level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
         } else {
             lua_getinfo(L1, level, cstr!("sln"), &mut ar);
-            lua_pushfstring(L, cstr!("\n\t%s:"), ar.short_src.as_ptr());
+            lua_pushfstring(L, cstr!("\n\t%s:"), ar.short_src);
             if ar.currentline > 0 {
                 lua_pushfstring(L, cstr!("%d:"), ar.currentline);
             }
@@ -506,6 +513,9 @@ pub unsafe fn luaL_requiref(
     if glb != 0 {
         lua_pushvalue(L, -1);
         lua_setglobal(L, modname);
+    } else {
+        lua_pushnil(L);
+        lua_setglobal(L, modname);
     }
     lua_replace(L, -2);
 }

src/ffi/luau/lauxlib.rs

@@ -72,6 +72,11 @@ extern "C" {
     // TODO: luaL_findtable
 
     pub fn luaL_typename(L: *mut lua_State, idx: c_int) -> *const c_char;
+
+    // sandbox libraries and globals
+    #[link_name = "luaL_sandbox"]
+    pub fn luaL_sandbox_(L: *mut lua_State);
+    pub fn luaL_sandboxthread(L: *mut lua_State);
 }
 
 //
@@ -123,6 +128,29 @@ pub unsafe fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int) {
     lua::lua_unref(L, r#ref)
 }
 
+pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
+    use super::lua::*;
+
+    // set all libraries to read-only
+    lua_pushnil(L);
+    while lua_next(L, LUA_GLOBALSINDEX) != 0 {
+        if lua_istable(L, -1) != 0 {
+            lua_setreadonly(L, -1, enabled);
+        }
+        lua_pop(L, 1);
+    }
+
+    // set all builtin metatables to read-only
+    lua_pushliteral(L, "");
+    lua_getmetatable(L, -1);
+    lua_setreadonly(L, -1, enabled);
+    lua_pop(L, 2);
+
+    // set globals to readonly and activate safeenv since the env is immutable
+    lua_setreadonly(L, LUA_GLOBALSINDEX, enabled);
+    lua_setsafeenv(L, LUA_GLOBALSINDEX, enabled);
+}
+
 //
 // TODO: Generic Buffer Manipulation
 //

src/ffi/luau/lua.rs

@@ -7,12 +7,15 @@ use std::ptr;
 // Option for multiple returns in 'lua_pcall' and 'lua_call'
 pub const LUA_MULTRET: c_int = -1;
 
+// Max number of Lua stack slots
+const LUAI_MAXCSTACK: c_int = 100000;
+
 //
 // Pseudo-indices
 //
-pub const LUA_REGISTRYINDEX: c_int = -10000;
-pub const LUA_ENVIRONINDEX: c_int = -10001;
-pub const LUA_GLOBALSINDEX: c_int = -10002;
+pub const LUA_REGISTRYINDEX: c_int = -LUAI_MAXCSTACK - 2000;
+pub const LUA_ENVIRONINDEX: c_int = -LUAI_MAXCSTACK - 2001;
+pub const LUA_GLOBALSINDEX: c_int = -LUAI_MAXCSTACK - 2002;
 
 pub const fn lua_upvalueindex(i: c_int) -> c_int {
     LUA_GLOBALSINDEX - i
@@ -133,6 +136,7 @@ extern "C" {
     pub fn lua_namecallatom(L: *mut lua_State, atom: *mut c_int) -> *const c_char;
     pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
     pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_touserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
     pub fn lua_userdatatag(L: *mut lua_State, idx: c_int) -> c_int;
@@ -256,11 +260,18 @@ extern "C" {
 extern "C" {
     pub fn lua_error(L: *mut lua_State) -> !;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawiter(L: *mut lua_State, idx: c_int, iter: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     // TODO: lua_encodepointer
     pub fn lua_clock() -> c_double;
-    pub fn lua_setuserdatadtor(L: *mut lua_State, tag: c_int, dtor: Option<lua_Udestructor>);
+    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<unsafe extern "C" fn(*mut lua_State, *mut c_void)>,
+    );
     pub fn lua_clonefunction(L: *mut lua_State, idx: c_int);
+    pub fn lua_cleartable(L: *mut lua_State, idx: c_int);
 }
 
 //
@@ -432,7 +443,12 @@ extern "C" {
     pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
 
     pub fn lua_singlestep(L: *mut lua_State, enabled: c_int);
-    pub fn lua_breakpoint(L: *mut lua_State, funcindex: c_int, line: c_int, enabled: c_int);
+    pub fn lua_breakpoint(
+        L: *mut lua_State,
+        funcindex: c_int,
+        line: c_int,
+        enabled: c_int,
+    ) -> c_int;
 
     pub fn lua_getcoverage(
         L: *mut lua_State,
@@ -449,13 +465,14 @@ pub struct lua_Debug {
     pub name: *const c_char,
     pub what: *const c_char,
     pub source: *const c_char,
+    pub short_src: *const c_char,
     pub linedefined: c_int,
     pub currentline: c_int,
     pub nupvals: u8,
     pub nparams: u8,
     pub isvararg: c_char,
-    pub short_src: [c_char; LUA_IDSIZE],
     pub userdata: *mut c_void,
+    pub ssbuf: [c_char; LUA_IDSIZE],
 }
 
 //

src/ffi/luau/lualib.rs

@@ -26,8 +26,4 @@ extern "C" {
 
     // open all builtin libraries
     pub fn luaL_openlibs(L: *mut lua_State);
-
-    // sandbox libraries and globals
-    pub fn luaL_sandbox(L: *mut lua_State);
-    pub fn luaL_sandboxthread(L: *mut lua_State);
 }

src/ffi/mod.rs

@@ -73,15 +73,18 @@ pub const SYS_MIN_ALIGN: usize = 4;
 // by C modules in unsafe mode
 #[cfg(not(feature = "luau"))]
 pub(crate) fn keep_lua_symbols() {
-    let mut symbols: Vec<*const extern "C" fn()> = Vec::new();
-    symbols.push(lua_atpanic as _);
-    symbols.push(lua_isuserdata as _);
-    symbols.push(lua_tocfunction as _);
-    symbols.push(luaL_loadstring as _);
-    symbols.push(luaL_openlibs as _);
-    if cfg!(any(feature = "lua54", feature = "lua53", feature = "lua52")) {
-        symbols.push(lua_getglobal as _);
-        symbols.push(lua_setglobal as _);
+    let mut _symbols: Vec<*const extern "C" fn()> = vec![
+        lua_atpanic as _,
+        lua_isuserdata as _,
+        lua_tocfunction as _,
+        luaL_loadstring as _,
+        luaL_openlibs as _,
+    ];
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    {
+        _symbols.push(lua_getglobal as _);
+        _symbols.push(lua_setglobal as _);
+        _symbols.push(luaL_setfuncs as _);
     }
 }
 

src/function.rs

@@ -1,19 +1,72 @@
-use std::os::raw::c_int;
+use std::mem;
+use std::os::raw::{c_int, c_void};
 use std::ptr;
+use std::slice;
 
 use crate::error::{Error, Result};
 use crate::ffi;
+use crate::memory::MemoryState;
 use crate::types::LuaRef;
-use crate::util::{assert_stack, check_stack, error_traceback, pop_error, StackGuard};
-use crate::value::{FromLuaMulti, ToLuaMulti};
+use crate::util::{
+    assert_stack, check_stack, error_traceback, pop_error, ptr_to_cstr_bytes, StackGuard,
+};
+use crate::value::{FromLuaMulti, IntoLuaMulti};
+
+#[cfg(feature = "unstable")]
+use {
+    crate::lua::Lua,
+    crate::types::{Callback, MaybeSend},
+    crate::value::IntoLua,
+    std::cell::RefCell,
+};
 
 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
 
+#[cfg(all(feature = "async", feature = "unstable"))]
+use {crate::types::AsyncCallback, futures_core::Future, futures_util::TryFutureExt};
+
 /// Handle to an internal Lua function.
 #[derive(Clone, Debug)]
 pub struct Function<'lua>(pub(crate) LuaRef<'lua>);
 
+/// Owned handle to an internal Lua function.
+#[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.
+    pub const fn to_ref(&self) -> Function {
+        Function(self.0.to_ref())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct FunctionInfo {
+    pub name: Option<Vec<u8>>,
+    pub name_what: Option<Vec<u8>>,
+    pub what: Option<Vec<u8>>,
+    pub source: Option<Vec<u8>>,
+    pub short_src: Option<Vec<u8>>,
+    pub line_defined: i32,
+    #[cfg(not(feature = "luau"))]
+    pub last_line_defined: i32,
+}
+
+/// Luau function coverage snapshot.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CoverageInfo {
+    pub function: Option<std::string::String>,
+    pub line_defined: i32,
+    pub depth: i32,
+    pub hits: Vec<i32>,
+}
+
 impl<'lua> Function<'lua> {
     /// Calls the function, passing `args` as function arguments.
     ///
@@ -55,39 +108,40 @@ impl<'lua> Function<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
+    pub fn call<A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
         let lua = self.0.lua;
+        let state = lua.state();
 
-        let mut args = args.to_lua_multi(lua)?;
+        let mut args = args.into_lua_multi(lua)?;
         let nargs = args.len() as c_int;
 
         let results = unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, nargs + 3)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, nargs + 3)?;
 
-            ffi::lua_pushcfunction(lua.state, error_traceback);
-            let stack_start = ffi::lua_gettop(lua.state);
+            MemoryState::relax_limit_with(state, || ffi::lua_pushcfunction(state, error_traceback));
+            let stack_start = ffi::lua_gettop(state);
             lua.push_ref(&self.0);
             for arg in args.drain_all() {
                 lua.push_value(arg)?;
             }
-            let ret = ffi::lua_pcall(lua.state, nargs, ffi::LUA_MULTRET, stack_start);
+            let ret = ffi::lua_pcall(state, nargs, ffi::LUA_MULTRET, stack_start);
             if ret != ffi::LUA_OK {
-                return Err(pop_error(lua.state, ret));
+                return Err(pop_error(state, ret));
             }
-            let nresults = ffi::lua_gettop(lua.state) - stack_start;
+            let nresults = ffi::lua_gettop(state) - stack_start;
             let mut results = args; // Reuse MultiValue container
-            assert_stack(lua.state, 2);
+            assert_stack(state, 2);
             for _ in 0..nresults {
                 results.push_front(lua.pop_value());
             }
-            ffi::lua_pop(lua.state, 1);
+            ffi::lua_pop(state, 1);
             results
         };
         R::from_lua_multi(results, lua)
     }
 
-    /// Returns a Feature that, when polled, calls `self`, passing `args` as function arguments,
+    /// Returns a future that, when polled, calls `self`, passing `args` as function arguments,
     /// and drives the execution.
     ///
     /// Internally it wraps the function to an [`AsyncThread`].
@@ -121,11 +175,11 @@ impl<'lua> Function<'lua> {
     pub fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         let lua = self.0.lua;
-        match lua.create_recycled_thread(self.clone()) {
+        match lua.create_recycled_thread(self) {
             Ok(t) => {
                 let mut t = t.into_async(args);
                 t.set_recyclable(true);
@@ -162,50 +216,100 @@ impl<'lua> Function<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
-        unsafe extern "C" fn bind_call_impl(state: *mut ffi::lua_State) -> c_int {
+    pub fn bind<A: IntoLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
+        unsafe extern "C" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
             let nargs = ffi::lua_gettop(state);
-            let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(2)) as c_int;
-            ffi::luaL_checkstack(state, nbinds + 2, ptr::null());
-
-            ffi::lua_settop(state, nargs + nbinds + 1);
-            ffi::lua_rotate(state, -(nargs + nbinds + 1), nbinds + 1);
-
-            ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
-            ffi::lua_replace(state, 1);
+            let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(1)) as c_int;
+            ffi::luaL_checkstack(state, nbinds, ptr::null());
 
             for i in 0..nbinds {
-                ffi::lua_pushvalue(state, ffi::lua_upvalueindex(i + 3));
-                ffi::lua_replace(state, i + 2);
+                ffi::lua_pushvalue(state, ffi::lua_upvalueindex(i + 2));
+            }
+            if nargs > 0 {
+                ffi::lua_rotate(state, 1, nbinds);
             }
 
-            ffi::lua_call(state, nargs + nbinds, ffi::LUA_MULTRET);
-            ffi::lua_gettop(state)
+            nargs + nbinds
         }
 
         let lua = self.0.lua;
+        let state = lua.state();
 
-        let args = args.to_lua_multi(lua)?;
+        let args = args.into_lua_multi(lua)?;
         let nargs = args.len() as c_int;
 
-        if nargs + 2 > ffi::LUA_MAX_UPVALUES {
+        if nargs == 0 {
+            return Ok(self.clone());
+        }
+
+        if nargs + 1 > ffi::LUA_MAX_UPVALUES {
             return Err(Error::BindError);
         }
 
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, nargs + 5)?;
+        let args_wrapper = unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, nargs + 3)?;
 
-            lua.push_ref(&self.0);
-            ffi::lua_pushinteger(lua.state, nargs as ffi::lua_Integer);
+            ffi::lua_pushinteger(state, nargs as ffi::lua_Integer);
             for arg in args {
                 lua.push_value(arg)?;
             }
-            protect_lua!(lua.state, nargs + 2, 1, fn(state) {
-                ffi::lua_pushcclosure(state, bind_call_impl, ffi::lua_gettop(state));
+            protect_lua!(state, nargs + 1, 1, fn(state) {
+                ffi::lua_pushcclosure(state, args_wrapper_impl, ffi::lua_gettop(state));
             })?;
 
-            Ok(Function(lua.pop_ref()))
+            Function(lua.pop_ref())
+        };
+
+        lua.load(
+            r#"
+            local func, args_wrapper = ...
+            return function(...)
+                return func(args_wrapper(...))
+            end
+            "#,
+        )
+        .try_cache()
+        .set_name("_mlua_bind")
+        .call((self.clone(), args_wrapper))
+    }
+
+    /// Returns information about the function.
+    ///
+    /// Corresponds to the `>Sn` what mask for [`lua_getinfo`] when applied to the function.
+    ///
+    /// [`lua_getinfo`]: https://www.lua.org/manual/5.4/manual.html#lua_getinfo
+    pub fn info(&self) -> FunctionInfo {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            let mut ar: ffi::lua_Debug = mem::zeroed();
+            lua.push_ref(&self.0);
+            #[cfg(not(feature = "luau"))]
+            let res = ffi::lua_getinfo(state, cstr!(">Sn"), &mut ar);
+            #[cfg(feature = "luau")]
+            let res = ffi::lua_getinfo(state, -1, cstr!("sn"), &mut ar);
+            mlua_assert!(res != 0, "lua_getinfo failed with `>Sn`");
+
+            FunctionInfo {
+                name: ptr_to_cstr_bytes(ar.name).map(|s| s.to_vec()),
+                #[cfg(not(feature = "luau"))]
+                name_what: ptr_to_cstr_bytes(ar.namewhat).map(|s| s.to_vec()),
+                #[cfg(feature = "luau")]
+                name_what: None,
+                what: ptr_to_cstr_bytes(ar.what).map(|s| s.to_vec()),
+                source: ptr_to_cstr_bytes(ar.source).map(|s| s.to_vec()),
+                #[cfg(not(feature = "luau"))]
+                short_src: ptr_to_cstr_bytes(ar.short_src.as_ptr()).map(|s| s.to_vec()),
+                #[cfg(feature = "luau")]
+                short_src: ptr_to_cstr_bytes(ar.short_src).map(|s| s.to_vec()),
+                line_defined: ar.linedefined,
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: ar.lastlinedefined,
+            }
         }
     }
 
@@ -213,12 +317,13 @@ 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.
+    ///
+    /// [Compiler]: crate::chunk::Compiler
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn dump(&self, strip: bool) -> Vec<u8> {
-        use std::os::raw::c_void;
-        use std::slice;
-
         unsafe extern "C" fn writer(
             _state: *mut ffi::lua_State,
             buf: *const c_void,
@@ -232,20 +337,81 @@ impl<'lua> Function<'lua> {
         }
 
         let lua = self.0.lua;
+        let state = lua.state();
         let mut data: Vec<u8> = Vec::new();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
 
             lua.push_ref(&self.0);
             let data_ptr = &mut data as *mut Vec<u8> as *mut c_void;
-            let strip = if strip { 1 } else { 0 };
-            ffi::lua_dump(lua.state, writer, data_ptr, strip);
-            ffi::lua_pop(lua.state, 1);
+            ffi::lua_dump(state, writer, data_ptr, strip as i32);
+            ffi::lua_pop(state, 1);
         }
 
         data
     }
+
+    /// 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.
+    ///
+    /// Recording of coverage information is controlled by [`Compiler::set_coverage_level`] option.
+    ///
+    /// Requires `feature = "luau"`
+    ///
+    /// [`Compiler::set_coverage_level`]: crate::chunk::Compiler::set_coverage_level
+    #[cfg(any(feature = "luau", docsrs))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn coverage<F>(&self, mut func: F)
+    where
+        F: FnMut(CoverageInfo),
+    {
+        use std::ffi::CStr;
+        use std::os::raw::c_char;
+
+        unsafe extern "C" fn callback<F: FnMut(CoverageInfo)>(
+            data: *mut c_void,
+            function: *const c_char,
+            line_defined: c_int,
+            depth: c_int,
+            hits: *const c_int,
+            size: usize,
+        ) {
+            let function = if !function.is_null() {
+                Some(CStr::from_ptr(function).to_string_lossy().to_string())
+            } else {
+                None
+            };
+            let rust_callback = &mut *(data as *mut F);
+            rust_callback(CoverageInfo {
+                function,
+                line_defined,
+                depth,
+                hits: slice::from_raw_parts(hits, size).to_vec(),
+            });
+        }
+
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            lua.push_ref(&self.0);
+            let func_ptr = &mut func as *mut F as *mut c_void;
+            ffi::lua_getcoverage(state, -1, func_ptr, callback::<F>);
+        }
+    }
+
+    /// Convert this handle to owned version.
+    #[cfg(feature = "unstable")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
+    #[inline]
+    pub fn into_owned(self) -> OwnedFunction {
+        OwnedFunction(self.0.into_owned())
+    }
 }
 
 impl<'lua> PartialEq for Function<'lua> {
@@ -253,3 +419,71 @@ impl<'lua> PartialEq for Function<'lua> {
         self.0 == other.0
     }
 }
+
+#[cfg(feature = "unstable")]
+pub(crate) struct WrappedFunction<'lua>(pub(crate) Callback<'lua, 'static>);
+
+#[cfg(all(feature = "async", feature = "unstable"))]
+pub(crate) struct WrappedAsyncFunction<'lua>(pub(crate) AsyncCallback<'lua, 'static>);
+
+#[cfg(feature = "unstable")]
+#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
+impl<'lua> Function<'lua> {
+    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`] trait.
+    #[inline]
+    pub fn wrap<F, A, R>(func: F) -> impl IntoLua<'lua>
+    where
+        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
+    {
+        WrappedFunction(Box::new(move |lua, args| {
+            func(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
+    #[inline]
+    pub fn wrap_mut<F, A, R>(func: F) -> impl IntoLua<'lua>
+    where
+        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
+    {
+        let func = RefCell::new(func);
+        WrappedFunction(Box::new(move |lua, args| {
+            let mut func = func
+                .try_borrow_mut()
+                .map_err(|_| Error::RecursiveMutCallback)?;
+            func(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }))
+    }
+
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn wrap_async<F, A, FR, R>(func: F) -> impl IntoLua<'lua>
+    where
+        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        FR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
+    {
+        WrappedAsyncFunction(Box::new(move |lua, args| {
+            let args = match A::from_lua_multi(args, lua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::err(e)),
+            };
+            Box::pin(func(lua, args).and_then(move |ret| future::ready(ret.into_lua_multi(lua))))
+        }))
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(Function: Send);
+
+    #[cfg(feature = "unstable")]
+    static_assertions::assert_not_impl_any!(OwnedFunction: Send);
+}

src/hook.rs

@@ -1,11 +1,11 @@
 use std::cell::UnsafeCell;
-use std::ffi::CStr;
 #[cfg(not(feature = "luau"))]
 use std::ops::{BitOr, BitOrAssign};
-use std::os::raw::{c_char, c_int};
+use std::os::raw::c_int;
 
 use crate::ffi::{self, lua_Debug};
 use crate::lua::Lua;
+use crate::util::ptr_to_cstr_bytes;
 
 /// Contains information about currently executing Lua code.
 ///
@@ -63,23 +63,23 @@ impl<'lua> Debug<'lua> {
     }
 
     /// Corresponds to the `n` what mask.
-    pub fn names(&self) -> DebugNames<'lua> {
+    pub fn names(&self) -> DebugNames {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("n"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("n"), self.ar.get()) != 0,
                 "lua_getinfo failed with `n`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, self.level, cstr!("n"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("n"), self.ar.get()) != 0,
                 "lua_getinfo failed with `n`"
             );
 
             DebugNames {
-                name: ptr_to_str((*self.ar.get()).name),
+                name: ptr_to_cstr_bytes((*self.ar.get()).name),
                 #[cfg(not(feature = "luau"))]
-                name_what: ptr_to_str((*self.ar.get()).namewhat),
+                name_what: ptr_to_cstr_bytes((*self.ar.get()).namewhat),
                 #[cfg(feature = "luau")]
                 name_what: None,
             }
@@ -87,26 +87,29 @@ impl<'lua> Debug<'lua> {
     }
 
     /// Corresponds to the `S` what mask.
-    pub fn source(&self) -> DebugSource<'lua> {
+    pub fn source(&self) -> DebugSource {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("S"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("S"), self.ar.get()) != 0,
                 "lua_getinfo failed with `S`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, self.level, cstr!("s"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("s"), self.ar.get()) != 0,
                 "lua_getinfo failed with `s`"
             );
 
             DebugSource {
-                source: ptr_to_str((*self.ar.get()).source),
-                short_src: ptr_to_str((*self.ar.get()).short_src.as_ptr()),
-                line_defined: (*self.ar.get()).linedefined as i32,
+                source: ptr_to_cstr_bytes((*self.ar.get()).source),
                 #[cfg(not(feature = "luau"))]
-                last_line_defined: (*self.ar.get()).lastlinedefined as i32,
-                what: ptr_to_str((*self.ar.get()).what),
+                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src.as_ptr()),
+                #[cfg(feature = "luau")]
+                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src),
+                line_defined: (*self.ar.get()).linedefined,
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: (*self.ar.get()).lastlinedefined,
+                what: ptr_to_cstr_bytes((*self.ar.get()).what),
             }
         }
     }
@@ -116,16 +119,16 @@ impl<'lua> Debug<'lua> {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("l"), self.ar.get()) != 0,
                 "lua_getinfo failed with `l`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, self.level, cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("l"), self.ar.get()) != 0,
                 "lua_getinfo failed with `l`"
             );
 
-            (*self.ar.get()).currentline as i32
+            (*self.ar.get()).currentline
         }
     }
 
@@ -136,7 +139,7 @@ impl<'lua> Debug<'lua> {
     pub fn is_tail_call(&self) -> bool {
         unsafe {
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("t"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("t"), self.ar.get()) != 0,
                 "lua_getinfo failed with `t`"
             );
             (*self.ar.get()).currentline != 0
@@ -148,20 +151,20 @@ impl<'lua> Debug<'lua> {
         unsafe {
             #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("u"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("u"), self.ar.get()) != 0,
                 "lua_getinfo failed with `u`"
             );
             #[cfg(feature = "luau")]
             mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, self.level, cstr!("a"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("a"), self.ar.get()) != 0,
                 "lua_getinfo failed with `a`"
             );
 
             #[cfg(not(feature = "luau"))]
             let stack = DebugStack {
-                num_ups: (*self.ar.get()).nups as i32,
+                num_ups: (*self.ar.get()).nups as _,
                 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar.get()).nparams as i32,
+                num_params: (*self.ar.get()).nparams as _,
                 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
                 is_vararg: (*self.ar.get()).isvararg != 0,
             };
@@ -349,11 +352,3 @@ impl BitOrAssign for HookTriggers {
         *self = *self | rhs;
     }
 }
-
-unsafe fn ptr_to_str<'a>(input: *const c_char) -> Option<&'a [u8]> {
-    if input.is_null() {
-        None
-    } else {
-        Some(CStr::from_ptr(input).to_bytes())
-    }
-}

src/lib.rs

@@ -10,10 +10,10 @@
 //!
 //! # Converting data
 //!
-//! The [`ToLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice
+//! The [`IntoLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice
 //! versa. They are implemented for many data structures found in Rust's standard library.
 //!
-//! For more general conversions, the [`ToLuaMulti`] and [`FromLuaMulti`] traits allow converting
+//! For more general conversions, the [`IntoLuaMulti`] and [`FromLuaMulti`] traits allow converting
 //! between Rust types and *any number* of Lua values.
 //!
 //! Most code in `mlua` is generic over implementors of those traits, so in most places the normal
@@ -54,9 +54,9 @@
 //! [executing]: crate::Chunk::exec
 //! [evaluating]: crate::Chunk::eval
 //! [globals]: crate::Lua::globals
-//! [`ToLua`]: crate::ToLua
+//! [`IntoLua`]: crate::IntoLua
 //! [`FromLua`]: crate::FromLua
-//! [`ToLuaMulti`]: crate::ToLuaMulti
+//! [`IntoLuaMulti`]: crate::IntoLuaMulti
 //! [`FromLuaMulti`]: crate::FromLuaMulti
 //! [`Function`]: crate::Function
 //! [`UserData`]: crate::UserData
@@ -72,7 +72,7 @@
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
 // mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.8.0-beta.2")]
+#![doc(html_root_url = "https://docs.rs/mlua/0.9.0-beta.1")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]
@@ -88,6 +88,9 @@ mod ffi;
 mod function;
 mod hook;
 mod lua;
+#[cfg(feature = "luau")]
+mod luau;
+mod memory;
 mod multi;
 mod scope;
 mod stdlib;
@@ -96,6 +99,7 @@ mod table;
 mod thread;
 mod types;
 mod userdata;
+mod userdata_ext;
 mod userdata_impl;
 mod util;
 mod value;
@@ -105,8 +109,8 @@ pub mod prelude;
 pub use crate::{ffi::lua_CFunction, ffi::lua_State};
 
 pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
-pub use crate::error::{Error, ExternalError, ExternalResult, Result};
-pub use crate::function::Function;
+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;
@@ -118,15 +122,18 @@ pub use crate::thread::{Thread, ThreadStatus};
 pub use crate::types::{Integer, LightUserData, Number, RegistryKey};
 pub use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
+    UserDataRef, UserDataRefMut,
 };
-pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
+pub use crate::userdata_ext::AnyUserDataExt;
+pub use crate::userdata_impl::UserDataRegistrar;
+pub use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, 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;
+pub use crate::{chunk::Compiler, function::CoverageInfo, types::VmState};
 
 #[cfg(feature = "async")]
 pub use crate::thread::AsyncThread;
@@ -146,12 +153,16 @@ pub mod serde;
 #[macro_use]
 extern crate mlua_derive;
 
+// Unstable features
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+pub use crate::{function::OwnedFunction, table::OwnedTable, userdata::OwnedAnyUserData};
+
 /// Create a type that implements [`AsChunk`] and can capture Rust variables.
 ///
 /// This macro allows to write Lua code directly in Rust code.
 ///
 /// Rust variables can be referenced from Lua using `$` prefix, as shown in the example below.
-/// User's Rust types needs to implement [`UserData`] or [`ToLua`] traits.
+/// User's Rust types needs to implement [`UserData`] or [`IntoLua`] traits.
 ///
 /// Captured variables are **moved** into the chunk.
 ///
@@ -197,7 +208,7 @@ extern crate mlua_derive;
 ///
 /// [`AsChunk`]: crate::AsChunk
 /// [`UserData`]: crate::UserData
-/// [`ToLua`]: crate::ToLua
+/// [`IntoLua`]: crate::IntoLua
 #[cfg(any(feature = "macros"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
@@ -219,6 +230,29 @@ pub use mlua_derive::chunk;
 ///
 /// Internally in the code above the compiler defines C function `luaopen_my_module`.
 ///
+/// You can also pass options to the attribute:
+///
+/// name - name of the module, defaults to the name of the function
+///
+/// ```ignore
+/// #[mlua::lua_module(name = "alt_module")]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     ...
+/// }
+/// ```
+///
 #[cfg(any(feature = "module", docsrs))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;
+
+pub(crate) mod private {
+    use super::*;
+
+    pub trait Sealed {}
+
+    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<'_> {}
+}

src/luau.rs

@@ -0,0 +1,132 @@
+use std::ffi::CStr;
+use std::os::raw::{c_float, c_int};
+use std::string::String as StdString;
+
+use crate::chunk::ChunkMode;
+use crate::error::{Error, Result};
+use crate::ffi;
+use crate::lua::Lua;
+use crate::table::Table;
+use crate::util::{check_stack, StackGuard};
+use crate::value::Value;
+
+// Since Luau has some missing standard function, we re-implement them here
+
+impl Lua {
+    pub(crate) unsafe fn prepare_luau_state(&self) -> Result<()> {
+        let globals = self.globals();
+
+        globals.raw_set(
+            "collectgarbage",
+            self.create_c_function(lua_collectgarbage)?,
+        )?;
+        globals.raw_set("require", self.create_function(lua_require)?)?;
+        globals.raw_set("vector", self.create_c_function(lua_vector)?)?;
+
+        // Set `_VERSION` global to include version number
+        // The environment variable `LUAU_VERSION` set by the build script
+        if let Some(version) = option_env!("LUAU_VERSION") {
+            globals.raw_set("_VERSION", format!("Luau {version}"))?;
+        }
+
+        Ok(())
+    }
+}
+
+unsafe extern "C" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
+    let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
+    let option = CStr::from_ptr(option);
+    let arg = ffi::luaL_optinteger(state, 2, 0);
+    match option.to_str() {
+        Ok("collect") => {
+            ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
+            0
+        }
+        Ok("stop") => {
+            ffi::lua_gc(state, ffi::LUA_GCSTOP, 0);
+            0
+        }
+        Ok("restart") => {
+            ffi::lua_gc(state, ffi::LUA_GCRESTART, 0);
+            0
+        }
+        Ok("count") => {
+            let kbytes = ffi::lua_gc(state, ffi::LUA_GCCOUNT, 0) as ffi::lua_Number;
+            let kbytes_rem = ffi::lua_gc(state, ffi::LUA_GCCOUNTB, 0) as ffi::lua_Number;
+            ffi::lua_pushnumber(state, kbytes + kbytes_rem / 1024.0);
+            1
+        }
+        Ok("step") => {
+            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg);
+            ffi::lua_pushboolean(state, res);
+            1
+        }
+        Ok("isrunning") => {
+            let res = ffi::lua_gc(state, ffi::LUA_GCISRUNNING, 0);
+            ffi::lua_pushboolean(state, res);
+            1
+        }
+        _ => ffi::luaL_error(state, cstr!("collectgarbage called with invalid option")),
+    }
+}
+
+fn lua_require(lua: &Lua, name: Option<StdString>) -> Result<Value> {
+    let name = name.ok_or_else(|| Error::RuntimeError("invalid module name".into()))?;
+
+    // Find module in the cache
+    let state = lua.state();
+    let loaded = unsafe {
+        let _sg = StackGuard::new(state);
+        check_stack(state, 2)?;
+        protect_lua!(state, 0, 1, fn(state) {
+            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED"));
+        })?;
+        Table(lua.pop_ref())
+    };
+    if let Some(v) = loaded.raw_get(name.clone())? {
+        return Ok(v);
+    }
+
+    // Load file from filesystem
+    let mut search_path = std::env::var("LUAU_PATH").unwrap_or_default();
+    if search_path.is_empty() {
+        search_path = "?.luau;?.lua".into();
+    }
+
+    let (mut source, mut source_name) = (None, String::new());
+    for path in search_path.split(';') {
+        let file_path = path.replacen('?', &name, 1);
+        if let Ok(buf) = std::fs::read(&file_path) {
+            source = Some(buf);
+            source_name = file_path;
+            break;
+        }
+    }
+    let source = source.ok_or_else(|| Error::RuntimeError(format!("cannot find '{name}'")))?;
+
+    let value = lua
+        .load(&source)
+        .set_name(&format!("={source_name}"))
+        .set_mode(ChunkMode::Text)
+        .call::<_, Value>(())?;
+
+    // Save in the cache
+    loaded.raw_set(
+        name,
+        match value.clone() {
+            Value::Nil => Value::Boolean(true),
+            v => v,
+        },
+    )?;
+
+    Ok(value)
+}
+
+// Luau vector datatype constructor
+unsafe extern "C" 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;
+    ffi::lua_pushvector(state, x, y, z);
+    1
+}

src/memory.rs

@@ -0,0 +1,153 @@
+use std::alloc::{self, Layout};
+use std::os::raw::c_void;
+use std::ptr;
+
+use crate::ffi;
+#[cfg(feature = "luau")]
+use crate::lua::ExtraData;
+
+pub(crate) static ALLOCATOR: ffi::lua_Alloc = allocator;
+
+#[derive(Default)]
+pub(crate) struct MemoryState {
+    used_memory: isize,
+    memory_limit: isize,
+    // Can be set to temporary ignore the memory limit.
+    // This is used when calling `lua_pushcfunction` for lua5.1/jit/luau.
+    ignore_limit: bool,
+    // Indicates that the memory limit was reached on the last allocation.
+    #[cfg(feature = "luau")]
+    limit_reached: bool,
+}
+
+impl MemoryState {
+    #[inline]
+    pub(crate) fn used_memory(&self) -> usize {
+        self.used_memory as usize
+    }
+
+    #[inline]
+    pub(crate) fn memory_limit(&self) -> usize {
+        self.memory_limit as usize
+    }
+
+    #[inline]
+    pub(crate) fn set_memory_limit(&mut self, limit: usize) -> usize {
+        let prev_limit = self.memory_limit;
+        self.memory_limit = limit as isize;
+        prev_limit as usize
+    }
+
+    // This function is used primarily for calling `lua_pushcfunction` in lua5.1/jit
+    // to bypass the memory limit (if set).
+    #[cfg(any(feature = "lua51", feature = "luajit"))]
+    #[inline]
+    pub(crate) unsafe fn relax_limit_with(state: *mut ffi::lua_State, f: impl FnOnce()) {
+        let mut mem_state: *mut c_void = ptr::null_mut();
+        if ffi::lua_getallocf(state, &mut mem_state) == ALLOCATOR {
+            (*(mem_state as *mut MemoryState)).ignore_limit = true;
+            f();
+            (*(mem_state as *mut MemoryState)).ignore_limit = false;
+        } else {
+            f();
+        }
+    }
+
+    // Same as the above but for Luau
+    // It does not have `lua_getallocf` function, so instead we use `lua_callbacks`
+    #[cfg(feature = "luau")]
+    #[inline]
+    pub(crate) unsafe fn relax_limit_with(state: *mut ffi::lua_State, f: impl FnOnce()) {
+        let extra = (*ffi::lua_callbacks(state)).userdata as *mut ExtraData;
+        if extra.is_null() {
+            return f();
+        }
+        let mem_state = (*extra).mem_state();
+        (*mem_state.as_ptr()).ignore_limit = true;
+        f();
+        (*mem_state.as_ptr()).ignore_limit = false;
+    }
+
+    // Does nothing apart from calling `f()`, we don't need to bypass any limits
+    #[cfg(any(feature = "lua52", feature = "lua53", feature = "lua54"))]
+    #[inline]
+    pub(crate) unsafe fn relax_limit_with(_state: *mut ffi::lua_State, f: impl FnOnce()) {
+        f();
+    }
+
+    // Returns `true` if the memory limit was reached on the last memory operation
+    #[cfg(feature = "luau")]
+    pub(crate) unsafe fn limit_reached(state: *mut ffi::lua_State) -> bool {
+        let extra = (*ffi::lua_callbacks(state)).userdata as *mut ExtraData;
+        if extra.is_null() {
+            return false;
+        }
+        (*(*extra).mem_state().as_ptr()).limit_reached
+    }
+}
+
+unsafe extern "C" fn allocator(
+    extra: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void {
+    let mem_state = &mut *(extra as *mut MemoryState);
+    #[cfg(feature = "luau")]
+    {
+        // Reset the flag
+        mem_state.limit_reached = false;
+    }
+
+    if nsize == 0 {
+        // Free memory
+        if !ptr.is_null() {
+            let layout = Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
+            alloc::dealloc(ptr as *mut u8, layout);
+            mem_state.used_memory -= osize as isize;
+        }
+        return ptr::null_mut();
+    }
+
+    // Do not allocate more than isize::MAX
+    if nsize > isize::MAX as usize {
+        return ptr::null_mut();
+    }
+
+    // Are we fit to the memory limits?
+    let mut mem_diff = nsize as isize;
+    if !ptr.is_null() {
+        mem_diff -= osize as isize;
+    }
+    let mem_limit = mem_state.memory_limit;
+    let new_used_memory = mem_state.used_memory + mem_diff;
+    if mem_limit > 0 && new_used_memory > mem_limit && !mem_state.ignore_limit {
+        #[cfg(feature = "luau")]
+        {
+            mem_state.limit_reached = true;
+        }
+        return ptr::null_mut();
+    }
+    mem_state.used_memory += mem_diff;
+
+    if ptr.is_null() {
+        // Allocate new memory
+        let new_layout = match Layout::from_size_align(nsize, ffi::SYS_MIN_ALIGN) {
+            Ok(layout) => layout,
+            Err(_) => return ptr::null_mut(),
+        };
+        let new_ptr = alloc::alloc(new_layout) as *mut c_void;
+        if new_ptr.is_null() {
+            alloc::handle_alloc_error(new_layout);
+        }
+        return new_ptr;
+    }
+
+    // Reallocate memory
+    let old_layout = Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
+    let new_ptr = alloc::realloc(ptr as *mut u8, old_layout, nsize) as *mut c_void;
+    if new_ptr.is_null() {
+        alloc::handle_alloc_error(old_layout);
+    }
+    new_ptr
+}

src/multi.rs

@@ -1,22 +1,21 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::iter::FromIterator;
 use std::ops::{Deref, DerefMut};
 use std::result::Result as StdResult;
 
 use crate::error::Result;
 use crate::lua::Lua;
-use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil};
 
 /// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
 /// on success, or in the case of an error, returning `nil` and an error message.
-impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E> {
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut result = MultiValue::new_or_cached(lua);
+impl<'lua, T: IntoLua<'lua>, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<T, E> {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        let mut result = MultiValue::new_or_pooled(lua);
         match self {
-            Ok(v) => result.push_front(v.to_lua(lua)?),
+            Ok(v) => result.push_front(v.into_lua(lua)?),
             Err(e) => {
-                result.push_front(e.to_lua(lua)?);
+                result.push_front(e.into_lua(lua)?);
                 result.push_front(Nil);
             }
         }
@@ -24,29 +23,45 @@ impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E>
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut v = MultiValue::new_or_cached(lua);
-        v.push_front(self.to_lua(lua)?);
+impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for T {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        let mut v = MultiValue::new_or_pooled(lua);
+        v.push_front(self.into_lua(lua)?);
         Ok(v)
     }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
+    #[inline]
     fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
         let res = T::from_lua(values.pop_front().unwrap_or(Nil), lua);
-        lua.cache_multivalue(values);
+        MultiValue::return_to_pool(values, lua);
+        res
+    }
+
+    #[inline]
+    fn from_lua_multi_args(
+        mut values: MultiValue<'lua>,
+        i: usize,
+        to: Option<&str>,
+        lua: &'lua Lua,
+    ) -> Result<Self> {
+        let res = T::from_lua_arg(values.pop_front().unwrap_or(Nil), i, to, lua);
+        MultiValue::return_to_pool(values, lua);
         res
     }
 }
 
-impl<'lua> ToLuaMulti<'lua> for MultiValue<'lua> {
-    fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
+impl<'lua> IntoLuaMulti<'lua> for MultiValue<'lua> {
+    #[inline]
+    fn into_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
         Ok(self)
     }
 }
 
 impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
+    #[inline]
     fn from_lua_multi(values: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
         Ok(values)
     }
@@ -83,7 +98,7 @@ pub struct Variadic<T>(Vec<T>);
 
 impl<T> Variadic<T> {
     /// Creates an empty `Variadic` wrapper containing no values.
-    pub fn new() -> Variadic<T> {
+    pub const fn new() -> Variadic<T> {
         Variadic(Vec::new())
     }
 }
@@ -123,54 +138,59 @@ impl<T> DerefMut for Variadic<T> {
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut values = MultiValue::new_or_cached(lua);
-        values.refill(self.0.into_iter().map(|e| e.to_lua(lua)))?;
+impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for Variadic<T> {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        let mut values = MultiValue::new_or_pooled(lua);
+        values.refill(self.0.into_iter().map(|e| e.into_lua(lua)))?;
         Ok(values)
     }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
+    #[inline]
     fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
         let res = values
             .drain_all()
             .map(|e| T::from_lua(e, lua))
             .collect::<Result<Vec<T>>>()
             .map(Variadic);
-        lua.cache_multivalue(values);
+        MultiValue::return_to_pool(values, lua);
         res
     }
 }
 
 macro_rules! impl_tuple {
     () => (
-        impl<'lua> ToLuaMulti<'lua> for () {
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-                Ok(MultiValue::new_or_cached(lua))
+        impl<'lua> IntoLuaMulti<'lua> for () {
+            #[inline]
+            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+                Ok(MultiValue::new_or_pooled(lua))
             }
         }
 
         impl<'lua> FromLuaMulti<'lua> for () {
+            #[inline]
             fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-                lua.cache_multivalue(values);
+                MultiValue::return_to_pool(values, lua);
                 Ok(())
             }
         }
     );
 
     ($last:ident $($name:ident)*) => (
-        impl<'lua, $($name,)* $last> ToLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: ToLua<'lua>,)*
-                  $last: ToLuaMulti<'lua>
+        impl<'lua, $($name,)* $last> IntoLuaMulti<'lua> for ($($name,)* $last,)
+            where $($name: IntoLua<'lua>,)*
+                  $last: IntoLuaMulti<'lua>
         {
             #[allow(unused_mut)]
             #[allow(non_snake_case)]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+            #[inline]
+            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
                 let ($($name,)* $last,) = self;
 
-                let mut results = $last.to_lua_multi(lua)?;
-                push_reverse!(results, $($name.to_lua(lua)?,)*);
+                let mut results = $last.into_lua_multi(lua)?;
+                push_reverse!(results, $($name.into_lua(lua)?,)*);
                 Ok(results)
             }
         }
@@ -181,10 +201,23 @@ macro_rules! impl_tuple {
         {
             #[allow(unused_mut)]
             #[allow(non_snake_case)]
+            #[inline]
             fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-                $(let $name = values.pop_front().unwrap_or(Nil);)*
+                $(let $name = FromLua::from_lua(values.pop_front().unwrap_or(Nil), lua)?;)*
                 let $last = FromLuaMulti::from_lua_multi(values, lua)?;
-                Ok(($(FromLua::from_lua($name, lua)?,)* $last,))
+                Ok(($($name,)* $last,))
+            }
+
+            #[allow(unused_mut)]
+            #[allow(non_snake_case)]
+            #[inline]
+            fn from_lua_multi_args(mut values: MultiValue<'lua>, mut i: usize, to: Option<&str>, lua: &'lua Lua) -> Result<Self> {
+                $(
+                    let $name = FromLua::from_lua_arg(values.pop_front().unwrap_or(Nil), i, to, lua)?;
+                    i += 1;
+                )*
+                let $last = FromLuaMulti::from_lua_multi_args(values, i, to, lua)?;
+                Ok(($($name,)* $last,))
             }
         }
     );

src/prelude.rs

@@ -2,19 +2,29 @@
 
 #[doc(no_inline)]
 pub use crate::{
-    AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Error as LuaError,
-    ExternalError as LuaExternalError, ExternalResult as LuaExternalResult, FromLua, FromLuaMulti,
-    Function as LuaFunction, GCMode as LuaGCMode, Integer as LuaInteger,
-    LightUserData as LuaLightUserData, Lua, LuaOptions, MetaMethod as LuaMetaMethod,
+    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, ToLua, ToLuaMulti,
-    UserData as LuaUserData, UserDataFields as LuaUserDataFields,
-    UserDataMetatable as LuaUserDataMetatable, UserDataMethods as LuaUserDataMethods,
+    Thread as LuaThread, ThreadStatus as LuaThreadStatus, UserData as LuaUserData,
+    UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
+    UserDataMethods as LuaUserDataMethods, UserDataRef as LuaUserDataRef,
+    UserDataRefMut as LuaUserDataRefMut, UserDataRegistrar as LuaUserDataRegistrar,
     Value as LuaValue,
 };
 
+#[cfg(not(feature = "luau"))]
+#[doc(no_inline)]
+pub use crate::HookTriggers as LuaHookTriggers;
+
+#[cfg(feature = "luau")]
+#[doc(no_inline)]
+pub use crate::{CoverageInfo as LuaCoverageInfo, VmState as LuaVmState};
+
 #[cfg(feature = "async")]
 #[doc(no_inline)]
 pub use crate::AsyncThread as LuaAsyncThread;
@@ -25,3 +35,10 @@ pub use crate::{
     DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt,
     SerializeOptions as LuaSerializeOptions,
 };
+
+#[cfg(all(feature = "unstable", not(feature = "send")))]
+#[doc(no_inline)]
+pub use crate::{
+    OwnedAnyUserData as LuaOwnedAnyUserData, OwnedFunction as LuaOwnedFunction,
+    OwnedTable as LuaOwnedTable,
+};

src/scope.rs

@@ -2,8 +2,7 @@ use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::marker::PhantomData;
 use std::mem;
-use std::os::raw::{c_int, c_void};
-use std::rc::Rc;
+use std::os::raw::c_int;
 
 #[cfg(feature = "serialize")]
 use serde::Serialize;
@@ -20,17 +19,13 @@ use crate::util::{
     assert_stack, check_stack, get_userdata, init_userdata_metatable, push_table, rawset_field,
     take_userdata, StackGuard,
 };
-use crate::value::{FromLua, FromLuaMulti, MultiValue, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Value};
 
 #[cfg(feature = "lua54")]
 use crate::userdata::USER_VALUE_MAXSLOT;
 
 #[cfg(feature = "async")]
-use {
-    crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue},
-    futures_core::future::Future,
-    futures_util::future::{self, TryFutureExt},
-};
+use futures_core::future::Future;
 
 /// Constructed by the [`Lua::scope`] method, allows temporarily creating Lua userdata and
 /// callbacks that are not required to be Send or 'static.
@@ -65,8 +60,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     pub fn create_function<'callback, A, R, F>(&'callback self, func: F) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'callback>,
-        R: ToLuaMulti<'callback>,
-        F: 'scope + Fn(&'callback Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'callback>,
+        F: Fn(&'callback Lua, A) -> Result<R> + 'scope,
     {
         // Safe, because 'scope must outlive 'callback (due to Self containing 'scope), however the
         // callback itself must be 'scope lifetime, so the function should not be able to capture
@@ -79,7 +74,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
         // scope, and owned inside the callback itself.
         unsafe {
             self.create_callback(Box::new(move |lua, args| {
-                func(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                func(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
             }))
         }
     }
@@ -98,8 +93,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     ) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'callback>,
-        R: ToLuaMulti<'callback>,
-        F: 'scope + FnMut(&'callback Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'callback>,
+        F: FnMut(&'callback Lua, A) -> Result<R> + 'scope,
     {
         let func = RefCell::new(func);
         self.create_function(move |lua, args| {
@@ -109,40 +104,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
         })
     }
 
-    /// Wraps a Rust async function or closure, creating a callable Lua function handle to it.
-    ///
-    /// This is a version of [`Lua::create_async_function`] that creates a callback which expires on
-    /// scope drop. See [`Lua::scope`] and [`Lua::async_scope`] for more details.
-    ///
-    /// Requires `feature = "async"`
-    ///
-    /// [`Lua::create_async_function`]: crate::Lua::create_async_function
-    /// [`Lua::scope`]: crate::Lua::scope
-    /// [`Lua::async_scope`]: crate::Lua::async_scope
-    #[cfg(feature = "async")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn create_async_function<'callback, A, R, F, FR>(
-        &'callback self,
-        func: F,
-    ) -> Result<Function<'lua>>
-    where
-        A: FromLuaMulti<'callback>,
-        R: ToLuaMulti<'callback>,
-        F: 'scope + Fn(&'callback Lua, A) -> FR,
-        FR: 'callback + Future<Output = Result<R>>,
-    {
-        unsafe {
-            self.create_async_callback(Box::new(move |lua, args| {
-                let args = match A::from_lua_multi(args, lua) {
-                    Ok(args) => args,
-                    Err(e) => return Box::pin(future::err(e)),
-                };
-                Box::pin(func(lua, args).and_then(move |ret| future::ready(ret.to_lua_multi(lua))))
-            }))
-        }
-    }
-
-    /// Create a Lua userdata object from a custom userdata type.
+    /// Creates a Lua userdata object from a custom userdata type.
     ///
     /// This is a version of [`Lua::create_userdata`] that creates a userdata which expires on
     /// scope drop, and does not require that the userdata type be Send (but still requires that the
@@ -153,12 +115,18 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     /// [`Lua::scope`]: crate::Lua::scope
     pub fn create_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
     where
-        T: 'static + UserData,
+        T: UserData + 'static,
     {
-        self.create_userdata_inner(UserDataCell::new(data))
+        // Safe even though T may not be Send, because the parent Lua cannot be sent to another
+        // thread while the Scope is alive (or the returned AnyUserData handle even).
+        unsafe {
+            let ud = self.lua.make_userdata(UserDataCell::new(data))?;
+            self.seal_userdata::<T>(&ud)?;
+            Ok(ud)
+        }
     }
 
-    /// Create a Lua userdata object from a custom serializable userdata type.
+    /// Creates a Lua userdata object from a custom serializable userdata type.
     ///
     /// This is a version of [`Lua::create_ser_userdata`] that creates a userdata which expires on
     /// scope drop, and does not require that the userdata type be Send (but still requires that the
@@ -173,60 +141,125 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
     pub fn create_ser_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
     where
-        T: 'static + UserData + Serialize,
+        T: UserData + Serialize + 'static,
     {
-        self.create_userdata_inner(UserDataCell::new_ser(data))
-    }
-
-    fn create_userdata_inner<T>(&self, data: UserDataCell<T>) -> Result<AnyUserData<'lua>>
-    where
-        T: 'static + UserData,
-    {
-        // Safe even though T may not be Send, because the parent Lua cannot be sent to another
-        // thread while the Scope is alive (or the returned AnyUserData handle even).
         unsafe {
-            let ud = self.lua.make_userdata(data)?;
-
-            #[cfg(any(feature = "lua51", feature = "luajit"))]
-            let newtable = self.lua.create_table()?;
-            let destructor: DestructorCallback = Box::new(move |ud| {
-                let state = ud.lua.state;
-                let _sg = StackGuard::new(state);
-                assert_stack(state, 2);
-
-                // Check that userdata is not destructed (via `take()` call)
-                if ud.lua.push_userdata_ref(&ud).is_err() {
-                    return vec![];
-                }
-
-                // Clear associated user values
-                #[cfg(feature = "lua54")]
-                for i in 1..=USER_VALUE_MAXSLOT {
-                    ffi::lua_pushnil(state);
-                    ffi::lua_setiuservalue(state, -2, i as c_int);
-                }
-                #[cfg(any(feature = "lua53", feature = "lua52", feature = "luau"))]
-                {
-                    ffi::lua_pushnil(state);
-                    ffi::lua_setuservalue(state, -2);
-                }
-                #[cfg(any(feature = "lua51", feature = "luajit"))]
-                {
-                    ud.lua.push_ref(&newtable.0);
-                    ffi::lua_setuservalue(state, -2);
-                }
-
-                vec![Box::new(take_userdata::<UserDataCell<T>>(state))]
-            });
-            self.destructors
-                .borrow_mut()
-                .push((ud.0.clone(), destructor));
-
+            let ud = self.lua.make_userdata(UserDataCell::new_ser(data))?;
+            self.seal_userdata::<T>(&ud)?;
             Ok(ud)
         }
     }
 
-    /// Create a Lua userdata object from a custom userdata type.
+    /// Creates a Lua userdata object from a reference to custom userdata type.
+    ///
+    /// This is a version of [`Lua::create_userdata`] that creates a userdata which expires on
+    /// scope drop, and does not require that the userdata type be Send. This method takes non-'static
+    /// reference to the data. See [`Lua::scope`] for more details.
+    ///
+    /// Userdata created with this method will not be able to be mutated from Lua.
+    pub fn create_userdata_ref<T>(&self, data: &'scope T) -> Result<AnyUserData<'lua>>
+    where
+        T: UserData + 'static,
+    {
+        unsafe {
+            let ud = self.lua.make_userdata(UserDataCell::new_ref(data))?;
+            self.seal_userdata::<T>(&ud)?;
+            Ok(ud)
+        }
+    }
+
+    /// Creates a Lua userdata object from a mutable reference to custom userdata type.
+    ///
+    /// This is a version of [`Lua::create_userdata`] that creates a userdata which expires on
+    /// scope drop, and does not require that the userdata type be Send. This method takes non-'static
+    /// mutable reference to the data. See [`Lua::scope`] for more details.
+    pub fn create_userdata_ref_mut<T>(&self, data: &'scope mut T) -> Result<AnyUserData<'lua>>
+    where
+        T: UserData + 'static,
+    {
+        unsafe {
+            let ud = self.lua.make_userdata(UserDataCell::new_ref_mut(data))?;
+            self.seal_userdata::<T>(&ud)?;
+            Ok(ud)
+        }
+    }
+
+    /// Creates a Lua userdata object from a reference to custom Rust type.
+    ///
+    /// This is a version of [`Lua::create_any_userdata`] that creates a userdata which expires on
+    /// scope drop, and does not require that the Rust type be Send. This method takes non-'static
+    /// reference to the data. See [`Lua::scope`] for more details.
+    ///
+    /// Userdata created with this method will not be able to be mutated from Lua.
+    pub fn create_any_userdata_ref<T>(&self, data: &'scope T) -> Result<AnyUserData<'lua>>
+    where
+        T: 'static,
+    {
+        unsafe {
+            let ud = self.lua.make_any_userdata(UserDataCell::new_ref(data))?;
+            self.seal_userdata::<T>(&ud)?;
+            Ok(ud)
+        }
+    }
+
+    /// Creates a Lua userdata object from a mutable reference to custom Rust type.
+    ///
+    /// This is a version of [`Lua::create_any_userdata`] that creates a userdata which expires on
+    /// scope drop, and does not require that the Rust type be Send. This method takes non-'static
+    /// mutable reference to the data. See [`Lua::scope`] for more details.
+    pub fn create_any_userdata_ref_mut<T>(&self, data: &'scope mut T) -> Result<AnyUserData<'lua>>
+    where
+        T: 'static,
+    {
+        let lua = self.lua;
+        unsafe {
+            let ud = lua.make_any_userdata(UserDataCell::new_ref_mut(data))?;
+            self.seal_userdata::<T>(&ud)?;
+            Ok(ud)
+        }
+    }
+
+    /// Shortens the lifetime of a userdata to the lifetime of the scope.
+    unsafe fn seal_userdata<T: 'static>(&self, ud: &AnyUserData<'lua>) -> Result<()> {
+        #[cfg(any(feature = "lua51", feature = "luajit"))]
+        let newtable = self.lua.create_table()?;
+        let destructor: DestructorCallback = Box::new(move |ud| {
+            let state = ud.lua.state();
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 2);
+
+            // Check that userdata is not destructed (via `take()` call)
+            if ud.lua.push_userdata_ref(&ud).is_err() {
+                return vec![];
+            }
+
+            // Clear associated user values
+            #[cfg(feature = "lua54")]
+            for i in 1..=USER_VALUE_MAXSLOT {
+                ffi::lua_pushnil(state);
+                ffi::lua_setiuservalue(state, -2, i as c_int);
+            }
+            #[cfg(any(feature = "lua53", feature = "lua52", feature = "luau"))]
+            {
+                ffi::lua_pushnil(state);
+                ffi::lua_setuservalue(state, -2);
+            }
+            #[cfg(any(feature = "lua51", feature = "luajit"))]
+            {
+                ud.lua.push_ref(&newtable.0);
+                ffi::lua_setuservalue(state, -2);
+            }
+
+            vec![Box::new(take_userdata::<UserDataCell<T>>(state))]
+        });
+        self.destructors
+            .borrow_mut()
+            .push((ud.0.clone(), destructor));
+
+        Ok(())
+    }
+
+    /// Creates a Lua userdata object from a custom userdata type.
     ///
     /// This is a version of [`Lua::create_userdata`] that creates a userdata which expires on
     /// scope drop, and does not require that the userdata type be Send or 'static. See
@@ -251,10 +284,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     /// [`UserDataMethods`]: crate::UserDataMethods
     pub fn create_nonstatic_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
     where
-        T: 'scope + UserData,
+        T: UserData + 'scope,
     {
-        let data = Rc::new(RefCell::new(data));
-
         // 'callback outliving 'scope is a lie to make the types work out, required due to the
         // inability to work with the more correct callback type that is universally quantified over
         // 'lua. This is safe though, because `UserData::add_methods` does not get to pick the 'lua
@@ -262,8 +293,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
         // parameters.
         fn wrap_method<'scope, 'lua, 'callback: 'scope, T: 'scope>(
             scope: &Scope<'lua, 'scope>,
-            data: Rc<RefCell<T>>,
-            ud_ptr: *const c_void,
+            ud_ptr: *const UserDataCell<T>,
             method: NonStaticMethod<'callback, T>,
         ) -> Result<Function<'lua>> {
             // On methods that actually receive the userdata, we fake a type check on the passed in
@@ -273,14 +303,15 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             // with a type mismatch, but here without this check would proceed as though you had
             // called the method on the original value (since we otherwise completely ignore the
             // first argument).
-            let check_ud_type = move |lua: &'callback Lua, value| {
+            let check_ud_type = move |lua: &Lua, value| -> Result<&UserDataCell<T>> {
                 if let Some(Value::UserData(ud)) = value {
+                    let state = lua.state();
                     unsafe {
-                        let _sg = StackGuard::new(lua.state);
-                        check_stack(lua.state, 2)?;
+                        let _sg = StackGuard::new(state);
+                        check_stack(state, 2)?;
                         lua.push_userdata_ref(&ud.0)?;
-                        if get_userdata(lua.state, -1) as *const _ == ud_ptr {
-                            return Ok(());
+                        if get_userdata(state, -1) as *const _ == ud_ptr {
+                            return Ok(&*ud_ptr);
                         }
                     }
                 };
@@ -290,8 +321,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             match method {
                 NonStaticMethod::Method(method) => {
                     let f = Box::new(move |lua, mut args: MultiValue<'callback>| {
-                        check_ud_type(lua, args.pop_front())?;
-                        let data = data.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
+                        let data = check_ud_type(lua, args.pop_front())?;
+                        let data = data.try_borrow()?;
                         method(lua, &*data, args)
                     });
                     unsafe { scope.create_callback(f) }
@@ -299,13 +330,11 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                 NonStaticMethod::MethodMut(method) => {
                     let method = RefCell::new(method);
                     let f = Box::new(move |lua, mut args: MultiValue<'callback>| {
-                        check_ud_type(lua, args.pop_front())?;
+                        let data = check_ud_type(lua, args.pop_front())?;
                         let mut method = method
                             .try_borrow_mut()
                             .map_err(|_| Error::RecursiveMutCallback)?;
-                        let mut data = data
-                            .try_borrow_mut()
-                            .map_err(|_| Error::UserDataBorrowMutError)?;
+                        let mut data = data.try_borrow_mut()?;
                         (*method)(lua, &mut *data, args)
                     });
                     unsafe { scope.create_callback(f) }
@@ -330,16 +359,16 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
         T::add_fields(&mut ud_fields);
         T::add_methods(&mut ud_methods);
 
+        let lua = self.lua;
+        let state = lua.state();
         unsafe {
-            let lua = self.lua;
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 13)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 13)?;
 
             #[cfg(not(feature = "luau"))]
             #[allow(clippy::let_and_return)]
-            let ud_ptr = protect_lua!(lua.state, 0, 1, |state| {
-                let ud =
-                    ffi::lua_newuserdata(state, mem::size_of::<UserDataCell<Rc<RefCell<T>>>>());
+            let ud_ptr = protect_lua!(state, 0, 1, |state| {
+                let ud = ffi::lua_newuserdata(state, mem::size_of::<UserDataCell<T>>());
 
                 // Set empty environment for Lua 5.1
                 #[cfg(any(feature = "lua51", feature = "luajit"))]
@@ -348,71 +377,64 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                     ffi::lua_setuservalue(state, -2);
                 }
 
-                ud
+                ud as *const UserDataCell<T>
             })?;
             #[cfg(feature = "luau")]
             let ud_ptr = {
-                crate::util::push_userdata::<UserDataCell<Rc<RefCell<T>>>>(
-                    lua.state,
-                    UserDataCell::new(data.clone()),
-                )?;
-                ffi::lua_touserdata(lua.state, -1)
+                crate::util::push_userdata(state, UserDataCell::new(data), true)?;
+                ffi::lua_touserdata(state, -1) as *const UserDataCell<T>
             };
 
             // Prepare metatable, add meta methods first and then meta fields
             let meta_methods_nrec = ud_methods.meta_methods.len() + ud_fields.meta_fields.len() + 1;
-            push_table(lua.state, 0, meta_methods_nrec as c_int)?;
+            push_table(state, 0, meta_methods_nrec as c_int, true)?;
 
             for (k, m) in ud_methods.meta_methods {
-                let data = data.clone();
-                lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
-                rawset_field(lua.state, -2, k.validate()?.name())?;
+                lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
+                rawset_field(state, -2, MetaMethod::validate(&k)?)?;
             }
             for (k, f) in ud_fields.meta_fields {
                 lua.push_value(f(mem::transmute(lua))?)?;
-                rawset_field(lua.state, -2, k.validate()?.name())?;
+                rawset_field(state, -2, MetaMethod::validate(&k)?)?;
             }
-            let metatable_index = ffi::lua_absindex(lua.state, -1);
+            let metatable_index = ffi::lua_absindex(state, -1);
 
             let mut field_getters_index = None;
             let field_getters_nrec = ud_fields.field_getters.len();
             if field_getters_nrec > 0 {
-                push_table(lua.state, 0, field_getters_nrec as c_int)?;
+                push_table(state, 0, field_getters_nrec as c_int, true)?;
                 for (k, m) in ud_fields.field_getters {
-                    let data = data.clone();
-                    lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
-                    rawset_field(lua.state, -2, &k)?;
+                    lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
+                    rawset_field(state, -2, &k)?;
                 }
-                field_getters_index = Some(ffi::lua_absindex(lua.state, -1));
+                field_getters_index = Some(ffi::lua_absindex(state, -1));
             }
 
             let mut field_setters_index = None;
             let field_setters_nrec = ud_fields.field_setters.len();
             if field_setters_nrec > 0 {
-                push_table(lua.state, 0, field_setters_nrec as c_int)?;
+                push_table(state, 0, field_setters_nrec as c_int, true)?;
                 for (k, m) in ud_fields.field_setters {
-                    let data = data.clone();
-                    lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
-                    rawset_field(lua.state, -2, &k)?;
+                    lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
+                    rawset_field(state, -2, &k)?;
                 }
-                field_setters_index = Some(ffi::lua_absindex(lua.state, -1));
+                field_setters_index = Some(ffi::lua_absindex(state, -1));
             }
 
             let mut methods_index = None;
             let methods_nrec = ud_methods.methods.len();
             if methods_nrec > 0 {
                 // Create table used for methods lookup
-                push_table(lua.state, 0, methods_nrec as c_int)?;
+                push_table(state, 0, methods_nrec as c_int, true)?;
                 for (k, m) in ud_methods.methods {
-                    let data = data.clone();
-                    lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
-                    rawset_field(lua.state, -2, &k)?;
+                    lua.push_value(Value::Function(wrap_method(self, ud_ptr, m)?))?;
+                    rawset_field(state, -2, &k)?;
                 }
-                methods_index = Some(ffi::lua_absindex(lua.state, -1));
+                methods_index = Some(ffi::lua_absindex(state, -1));
             }
 
-            init_userdata_metatable::<UserDataCell<Rc<RefCell<T>>>>(
-                lua.state,
+            init_userdata_metatable::<UserDataCell<T>>(
+                state,
                 metatable_index,
                 field_getters_index,
                 field_setters_index,
@@ -422,20 +444,20 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
             let count = field_getters_index.map(|_| 1).unwrap_or(0)
                 + field_setters_index.map(|_| 1).unwrap_or(0)
                 + methods_index.map(|_| 1).unwrap_or(0);
-            ffi::lua_pop(lua.state, count);
+            ffi::lua_pop(state, count);
 
-            let mt_ptr = ffi::lua_topointer(lua.state, -1);
+            let mt_ptr = ffi::lua_topointer(state, -1);
             // Write userdata just before attaching metatable with `__gc` metamethod
             #[cfg(not(feature = "luau"))]
             std::ptr::write(ud_ptr as _, UserDataCell::new(data));
-            ffi::lua_setmetatable(lua.state, -2);
+            ffi::lua_setmetatable(state, -2);
             let ud = AnyUserData(lua.pop_ref());
-            lua.register_userdata_metatable(mt_ptr, None);
+            lua.register_raw_userdata_metatable(mt_ptr, None);
 
             #[cfg(any(feature = "lua51", feature = "luajit"))]
             let newtable = lua.create_table()?;
             let destructor: DestructorCallback = Box::new(move |ud| {
-                let state = ud.lua.state;
+                let state = ud.lua.state();
                 let _sg = StackGuard::new(state);
                 assert_stack(state, 2);
 
@@ -448,7 +470,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                 ffi::lua_getmetatable(state, -1);
                 let mt_ptr = ffi::lua_topointer(state, -1);
                 ffi::lua_pop(state, 1);
-                ud.lua.deregister_userdata_metatable(mt_ptr);
+                ud.lua.deregister_raw_userdata_metatable(mt_ptr);
 
                 // Clear associated user values
                 #[cfg(feature = "lua54")]
@@ -473,8 +495,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                     mem::transmute(f)
                 }
 
-                let ud = Box::new(seal(take_userdata::<UserDataCell<Rc<RefCell<T>>>>(state)));
-                vec![ud]
+                let ud = take_userdata::<UserDataCell<T>>(state);
+                vec![Box::new(seal(ud))]
             });
             self.destructors
                 .borrow_mut()
@@ -497,7 +519,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
         let f = self.lua.create_callback(f)?;
 
         let destructor: DestructorCallback = Box::new(|f| {
-            let state = f.lua.state;
+            let state = f.lua.state();
             let _sg = StackGuard::new(state);
             assert_stack(state, 3);
 
@@ -518,64 +540,6 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
 
         Ok(f)
     }
-
-    #[cfg(feature = "async")]
-    unsafe fn create_async_callback<'callback>(
-        &self,
-        f: AsyncCallback<'callback, 'scope>,
-    ) -> Result<Function<'lua>> {
-        let f = mem::transmute::<AsyncCallback<'callback, 'scope>, AsyncCallback<'lua, 'static>>(f);
-        let f = self.lua.create_async_callback(f)?;
-
-        // We need to pre-allocate strings to avoid failures in destructor.
-        let get_poll_str = self.lua.create_string("get_poll")?;
-        let poll_str = self.lua.create_string("poll")?;
-        let destructor: DestructorCallback = Box::new(move |f| {
-            let state = f.lua.state;
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 5);
-
-            f.lua.push_ref(&f);
-
-            // We know the destructor has not run yet because we hold a reference to the callback.
-
-            // First, get the environment table
-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-            ffi::lua_getupvalue(state, -1, 1);
-            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
-            ffi::lua_getfenv(state, -1);
-
-            // Second, get the `get_poll()` closure using the corresponding key
-            f.lua.push_ref(&get_poll_str.0);
-            ffi::lua_rawget(state, -2);
-
-            // Destroy all upvalues
-            ffi::lua_getupvalue(state, -1, 1);
-            let upvalue1 = take_userdata::<AsyncCallbackUpvalue>(state);
-            ffi::lua_pushnil(state);
-            ffi::lua_setupvalue(state, -2, 1);
-
-            ffi::lua_pop(state, 1);
-            let mut data: Vec<Box<dyn Any>> = vec![Box::new(upvalue1)];
-
-            // Finally, get polled future and destroy it
-            f.lua.push_ref(&poll_str.0);
-            if ffi::lua_rawget(state, -2) == ffi::LUA_TFUNCTION {
-                ffi::lua_getupvalue(state, -1, 1);
-                let upvalue2 = take_userdata::<AsyncPollUpvalue>(state);
-                ffi::lua_pushnil(state);
-                ffi::lua_setupvalue(state, -2, 1);
-                data.push(Box::new(upvalue2));
-            }
-
-            data
-        });
-        self.destructors
-            .borrow_mut()
-            .push((f.0.clone(), destructor));
-
-        Ok(f)
-    }
 }
 
 impl<'lua, 'scope> Drop for Scope<'lua, 'scope> {
@@ -596,6 +560,7 @@ impl<'lua, 'scope> Drop for Scope<'lua, 'scope> {
     }
 }
 
+#[allow(clippy::type_complexity)]
 enum NonStaticMethod<'lua, T> {
     Method(Box<dyn Fn(&'lua Lua, &T, MultiValue<'lua>) -> Result<MultiValue<'lua>>>),
     MethodMut(Box<dyn FnMut(&'lua Lua, &mut T, MultiValue<'lua>) -> Result<MultiValue<'lua>>>),
@@ -604,8 +569,8 @@ enum NonStaticMethod<'lua, T> {
 }
 
 struct NonStaticUserDataMethods<'lua, T: UserData> {
-    methods: Vec<(Vec<u8>, NonStaticMethod<'lua, T>)>,
-    meta_methods: Vec<(MetaMethod, NonStaticMethod<'lua, T>)>,
+    methods: Vec<(String, NonStaticMethod<'lua, T>)>,
+    meta_methods: Vec<(String, NonStaticMethod<'lua, T>)>,
 }
 
 impl<'lua, T: UserData> Default for NonStaticUserDataMethods<'lua, T> {
@@ -618,190 +583,162 @@ impl<'lua, T: UserData> Default for NonStaticUserDataMethods<'lua, T> {
 }
 
 impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'lua, T> {
-    fn add_method<S, A, R, M>(&mut self, name: &S, method: M)
+    fn add_method<M, A, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        S: AsRef<[u8]> + ?Sized,
+        M: Fn(&'lua Lua, &T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.methods.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::Method(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let method = NonStaticMethod::Method(Box::new(move |lua, ud, args| {
+            method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.methods.push((name.as_ref().into(), method));
     }
 
-    fn add_method_mut<S, A, R, M>(&mut self, name: &S, mut method: M)
+    fn add_method_mut<M, A, R>(&mut self, name: impl AsRef<str>, mut method: M)
     where
-        S: AsRef<[u8]> + ?Sized,
+        M: FnMut(&'lua Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.methods.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let method = NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
+            method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.methods.push((name.as_ref().into(), method));
     }
 
     #[cfg(feature = "async")]
-    fn add_async_method<S, A, R, M, MR>(&mut self, _name: &S, _method: M)
+    fn add_async_method<M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
     where
         T: Clone,
-        S: AsRef<[u8]> + ?Sized,
+        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
-        MR: 'lua + Future<Output = Result<R>>,
+        MR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
     {
         // The panic should never happen as async non-static code wouldn't compile
         // Non-static lifetime must be bounded to 'lua lifetime
-        mlua_panic!("asynchronous methods are not supported for non-static userdata")
+        panic!("asynchronous methods are not supported for non-static userdata")
     }
 
-    fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
+    fn add_function<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
     where
-        S: AsRef<[u8]> + ?Sized,
+        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.methods.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::Function(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let func = NonStaticMethod::Function(Box::new(move |lua, args| {
+            function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.methods.push((name.as_ref().into(), func));
     }
 
-    fn add_function_mut<S, A, R, F>(&mut self, name: &S, mut function: F)
+    fn add_function_mut<F, A, R>(&mut self, name: impl AsRef<str>, mut function: F)
     where
-        S: AsRef<[u8]> + ?Sized,
+        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.methods.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let func = NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
+            function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.methods.push((name.as_ref().into(), func));
     }
 
     #[cfg(feature = "async")]
-    fn add_async_function<S, A, R, F, FR>(&mut self, _name: &S, _function: F)
+    fn add_async_function<F, A, FR, R>(&mut self, _name: impl AsRef<str>, _function: F)
     where
-        S: AsRef<[u8]> + ?Sized,
+        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
-        FR: 'lua + Future<Output = Result<R>>,
+        FR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
     {
         // The panic should never happen as async non-static code wouldn't compile
         // Non-static lifetime must be bounded to 'lua lifetime
-        mlua_panic!("asynchronous functions are not supported for non-static userdata")
+        panic!("asynchronous functions are not supported for non-static userdata")
     }
 
-    fn add_meta_method<S, A, R, M>(&mut self, meta: S, method: M)
+    fn add_meta_method<M, A, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        S: Into<MetaMethod>,
+        M: Fn(&'lua Lua, &T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.meta_methods.push((
-            meta.into(),
-            NonStaticMethod::Method(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let method = NonStaticMethod::Method(Box::new(move |lua, ud, args| {
+            method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.meta_methods.push((name.as_ref().into(), method));
     }
 
-    fn add_meta_method_mut<S, A, R, M>(&mut self, meta: S, mut method: M)
+    fn add_meta_method_mut<M, A, R>(&mut self, name: impl AsRef<str>, mut method: M)
     where
-        S: Into<MetaMethod>,
+        M: FnMut(&'lua Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.meta_methods.push((
-            meta.into(),
-            NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let method = NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
+            method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.meta_methods.push((name.as_ref().into(), method));
     }
 
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method<S, A, R, M, MR>(&mut self, _meta: S, _method: M)
+    fn add_async_meta_method<M, A, MR, R>(&mut self, _name: impl AsRef<str>, _method: M)
     where
         T: Clone,
-        S: Into<MetaMethod>,
+        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
-        MR: 'lua + Future<Output = Result<R>>,
+        MR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
     {
         // The panic should never happen as async non-static code wouldn't compile
         // Non-static lifetime must be bounded to 'lua lifetime
-        mlua_panic!("asynchronous meta methods are not supported for non-static userdata")
+        panic!("asynchronous meta methods are not supported for non-static userdata")
     }
 
-    fn add_meta_function<S, A, R, F>(&mut self, meta: S, function: F)
+    fn add_meta_function<F, A, R>(&mut self, name: impl AsRef<str>, function: F)
     where
-        S: Into<MetaMethod>,
+        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.meta_methods.push((
-            meta.into(),
-            NonStaticMethod::Function(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let func = NonStaticMethod::Function(Box::new(move |lua, args| {
+            function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.meta_methods.push((name.as_ref().into(), func));
     }
 
-    fn add_meta_function_mut<S, A, R, F>(&mut self, meta: S, mut function: F)
+    fn add_meta_function_mut<F, A, R>(&mut self, name: impl AsRef<str>, mut function: F)
     where
-        S: Into<MetaMethod>,
+        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.meta_methods.push((
-            meta.into(),
-            NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
-                function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let func = NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
+            function(lua, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.meta_methods.push((name.as_ref().into(), func));
     }
 
     #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_function<S, A, R, F, FR>(&mut self, _meta: S, _function: F)
+    fn add_async_meta_function<F, A, FR, R>(&mut self, _name: impl AsRef<str>, _function: F)
     where
-        S: Into<MetaMethod>,
+        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
-        FR: 'lua + Future<Output = Result<R>>,
+        FR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
     {
         // The panic should never happen as async non-static code wouldn't compile
         // Non-static lifetime must be bounded to 'lua lifetime
-        mlua_panic!("asynchronous meta functions are not supported for non-static userdata")
+        panic!("asynchronous meta functions are not supported for non-static userdata")
     }
 }
 
 struct NonStaticUserDataFields<'lua, T: UserData> {
-    field_getters: Vec<(Vec<u8>, NonStaticMethod<'lua, T>)>,
-    field_setters: Vec<(Vec<u8>, NonStaticMethod<'lua, T>)>,
+    field_getters: Vec<(String, NonStaticMethod<'lua, T>)>,
+    field_setters: Vec<(String, NonStaticMethod<'lua, T>)>,
     #[allow(clippy::type_complexity)]
-    meta_fields: Vec<(MetaMethod, Box<dyn Fn(&'lua Lua) -> Result<Value<'lua>>>)>,
+    meta_fields: Vec<(String, Box<dyn Fn(&'lua Lua) -> Result<Value<'lua>>>)>,
 }
 
 impl<'lua, T: UserData> Default for NonStaticUserDataFields<'lua, T> {
@@ -815,80 +752,67 @@ impl<'lua, T: UserData> Default for NonStaticUserDataFields<'lua, T> {
 }
 
 impl<'lua, T: UserData> UserDataFields<'lua, T> for NonStaticUserDataFields<'lua, T> {
-    fn add_field_method_get<S, R, M>(&mut self, name: &S, method: M)
+    fn add_field_method_get<M, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        S: AsRef<[u8]> + ?Sized,
-        R: ToLua<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>,
+        M: Fn(&'lua Lua, &T) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua<'lua>,
     {
-        self.field_getters.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::Method(Box::new(move |lua, ud, _| {
-                method(lua, ud)?.to_lua_multi(lua)
-            })),
-        ));
+        let method = NonStaticMethod::Method(Box::new(move |lua, ud, _| {
+            method(lua, ud)?.into_lua_multi(lua)
+        }));
+        self.field_getters.push((name.as_ref().into(), method));
     }
 
-    fn add_field_method_set<S, A, M>(&mut self, name: &S, mut method: M)
+    fn add_field_method_set<M, A>(&mut self, name: impl AsRef<str>, mut method: M)
     where
-        S: AsRef<[u8]> + ?Sized,
+        M: FnMut(&'lua Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua<'lua>,
-        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<()>,
     {
-        self.field_setters.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
-                method(lua, ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let method = NonStaticMethod::MethodMut(Box::new(move |lua, ud, args| {
+            method(lua, ud, A::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.field_setters.push((name.as_ref().into(), method));
     }
 
-    fn add_field_function_get<S, R, F>(&mut self, name: &S, function: F)
+    fn add_field_function_get<F, R>(&mut self, name: impl AsRef<str>, function: F)
     where
-        S: AsRef<[u8]> + ?Sized,
-        R: ToLua<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>,
+        F: Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua<'lua>,
     {
-        self.field_getters.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::Function(Box::new(move |lua, args| {
-                function(lua, AnyUserData::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
-            })),
-        ));
+        let func = NonStaticMethod::Function(Box::new(move |lua, args| {
+            function(lua, AnyUserData::from_lua_multi(args, lua)?)?.into_lua_multi(lua)
+        }));
+        self.field_getters.push((name.as_ref().into(), func));
     }
 
-    fn add_field_function_set<S, A, F>(&mut self, name: &S, mut function: F)
+    fn add_field_function_set<F, A>(&mut self, name: impl AsRef<str>, mut function: F)
     where
-        S: AsRef<[u8]> + ?Sized,
+        F: FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua<'lua>,
-        F: 'static + MaybeSend + FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()>,
     {
-        self.field_setters.push((
-            name.as_ref().to_vec(),
-            NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
-                let (ud, val) = <_>::from_lua_multi(args, lua)?;
-                function(lua, ud, val)?.to_lua_multi(lua)
-            })),
-        ));
+        let func = NonStaticMethod::FunctionMut(Box::new(move |lua, args| {
+            let (ud, val) = <_>::from_lua_multi(args, lua)?;
+            function(lua, ud, val)?.into_lua_multi(lua)
+        }));
+        self.field_setters.push((name.as_ref().into(), func));
     }
 
-    fn add_meta_field_with<S, R, F>(&mut self, meta: S, f: F)
+    fn add_meta_field_with<F, R>(&mut self, name: impl AsRef<str>, f: F)
     where
-        S: Into<MetaMethod>,
-        F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>,
-        R: ToLua<'lua>,
+        F: Fn(&'lua Lua) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua<'lua>,
     {
-        let meta = meta.into();
+        let name = name.as_ref().to_string();
         self.meta_fields.push((
-            meta.clone(),
+            name.clone(),
             Box::new(move |lua| {
-                let value = f(lua)?.to_lua(lua)?;
-                if meta == MetaMethod::Index || meta == MetaMethod::NewIndex {
+                let value = f(lua)?.into_lua(lua)?;
+                if name == MetaMethod::Index || name == MetaMethod::NewIndex {
                     match value {
                         Value::Nil | Value::Table(_) | Value::Function(_) => {}
                         _ => {
                             return Err(Error::MetaMethodTypeError {
-                                method: meta.to_string(),
+                                method: name.clone(),
                                 type_name: value.type_name(),
                                 message: Some("expected nil, table or function".to_string()),
                             })

src/serde/de.rs

@@ -8,8 +8,8 @@ use rustc_hash::FxHashSet;
 use serde::de::{self, IntoDeserializer};
 
 use crate::error::{Error, Result};
-use crate::ffi;
 use crate::table::{Table, TablePairs, TableSequence};
+use crate::userdata::AnyUserData;
 use crate::value::Value;
 
 /// A struct for deserializing Lua values into Rust values.
@@ -72,7 +72,7 @@ impl Options {
     ///
     /// [`deny_recursive_tables`]: #structfield.deny_recursive_tables
     #[must_use]
-    pub fn deny_recursive_tables(mut self, enabled: bool) -> Self {
+    pub const fn deny_recursive_tables(mut self, enabled: bool) -> Self {
         self.deny_recursive_tables = enabled;
         self
     }
@@ -132,6 +132,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             Value::Table(ref t) if t.raw_len() > 0 || t.is_array() => 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))
+            }
             Value::Function(_)
             | Value::Thread(_)
             | Value::UserData(_)
@@ -164,8 +167,8 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     #[inline]
     fn deserialize_enum<V>(
         self,
-        _name: &str,
-        _variants: &'static [&'static str],
+        name: &'static str,
+        variants: &'static [&'static str],
         visitor: V,
     ) -> Result<V::Value>
     where
@@ -199,6 +202,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                 (variant, Some(value), Some(_guard))
             }
             Value::String(variant) => (variant.to_str()?.to_owned(), None, None),
+            Value::UserData(ud) if ud.is_serializable() => {
+                return serde_userdata(ud, |value| value.deserialize_enum(name, variants, visitor));
+            }
             _ => return Err(de::Error::custom("bad enum value")),
         };
 
@@ -245,6 +251,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                     ))
                 }
             }
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_seq(visitor))
+            }
             value => Err(de::Error::invalid_type(
                 de::Unexpected::Other(value.type_name()),
                 &"table",
@@ -300,6 +309,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                     ))
                 }
             }
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_map(visitor))
+            }
             value => Err(de::Error::invalid_type(
                 de::Unexpected::Other(value.type_name()),
                 &"table",
@@ -320,10 +332,22 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
         self.deserialize_map(visitor)
     }
 
+    #[inline]
+    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match self.value {
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_newtype_struct(name, visitor))
+            }
+            _ => visitor.visit_newtype_struct(self),
+        }
+    }
+
     serde::forward_to_deserialize_any! {
         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes
-        byte_buf unit unit_struct newtype_struct
-        identifier ignored_any
+        byte_buf unit unit_struct identifier ignored_any
     }
 }
 
@@ -556,9 +580,7 @@ impl RecursionGuard {
     #[inline]
     fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
         let visited = Rc::clone(visited);
-        let lua = table.0.lua;
-        let ptr =
-            unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+        let ptr = table.to_pointer();
         visited.borrow_mut().insert(ptr);
         RecursionGuard { ptr, visited }
     }
@@ -578,9 +600,7 @@ fn check_value_if_skip(
 ) -> Result<bool> {
     match value {
         Value::Table(table) => {
-            let lua = table.0.lua;
-            let ptr =
-                unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+            let ptr = table.to_pointer();
             if visited.borrow().contains(&ptr) {
                 if options.deny_recursive_tables {
                     return Err(de::Error::custom("recursive table detected"));
@@ -588,6 +608,7 @@ fn check_value_if_skip(
                 return Ok(true); // skip
             }
         }
+        Value::UserData(ud) if ud.is_serializable() => {}
         Value::Function(_)
         | Value::Thread(_)
         | Value::UserData(_)
@@ -601,3 +622,11 @@ fn check_value_if_skip(
     }
     Ok(false) // do not skip
 }
+
+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()))
+}

src/serde/mod.rs

@@ -8,14 +8,15 @@ use serde::{Deserialize, Serialize};
 use crate::error::Result;
 use crate::ffi;
 use crate::lua::Lua;
+use crate::private::Sealed;
 use crate::table::Table;
 use crate::types::LightUserData;
-use crate::util::{assert_stack, check_stack, StackGuard};
+use crate::util::check_stack;
 use crate::value::Value;
 
 /// Trait for serializing/deserializing Lua values using Serde.
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
-pub trait LuaSerdeExt<'lua> {
+pub trait LuaSerdeExt<'lua>: Sealed {
     /// A special value (lightuserdata) to encode/decode optional (none) values.
     ///
     /// Requires `feature = "serialize"`
@@ -158,6 +159,7 @@ pub trait LuaSerdeExt<'lua> {
     ///     Ok(())
     /// }
     /// ```
+    #[allow(clippy::wrong_self_convention)]
     fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> Result<T>;
 
     /// Deserializes a [`Value`] into any serde deserializable object with options.
@@ -189,6 +191,7 @@ pub trait LuaSerdeExt<'lua> {
     ///     Ok(())
     /// }
     /// ```
+    #[allow(clippy::wrong_self_convention)]
     fn from_value_with<T: Deserialize<'lua>>(
         &'lua self,
         value: Value<'lua>,
@@ -203,12 +206,8 @@ impl<'lua> LuaSerdeExt<'lua> for Lua {
 
     fn array_metatable(&'lua self) -> Table<'lua> {
         unsafe {
-            let _sg = StackGuard::new(self.state);
-            assert_stack(self.state, 1);
-
-            push_array_metatable(self.state);
-
-            Table(self.pop_ref())
+            push_array_metatable(self.ref_thread());
+            Table(self.pop_ref_thread())
         }
     }
 
@@ -257,7 +256,7 @@ pub(crate) unsafe fn init_metatables(state: *mut ffi::lua_State) -> Result<()> {
 }
 
 pub(crate) unsafe fn push_array_metatable(state: *mut ffi::lua_State) {
-    let array_metatable_key = &ARRAY_METATABLE_REGISTRY_KEY as *const u8 as *mut c_void;
+    let array_metatable_key = &ARRAY_METATABLE_REGISTRY_KEY as *const u8 as *const c_void;
     ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, array_metatable_key);
 }
 

src/serde/ser.rs

@@ -10,7 +10,7 @@ use crate::string::String;
 use crate::table::Table;
 use crate::types::Integer;
 use crate::util::{check_stack, StackGuard};
-use crate::value::{ToLua, Value};
+use crate::value::{IntoLua, Value};
 
 /// A struct for serializing Rust values into Lua values.
 #[derive(Debug)]
@@ -110,7 +110,7 @@ macro_rules! lua_serialize_number {
     ($name:ident, $t:ty) => {
         #[inline]
         fn $name(self, value: $t) -> Result<Value<'lua>> {
-            value.to_lua(self.lua)
+            value.into_lua(self.lua)
         }
     };
 }
@@ -320,17 +320,25 @@ impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
         T: Serialize + ?Sized,
     {
         let lua = self.table.0.lua;
+        let state = lua.state();
         let value = lua.to_value_with(value, self.options)?;
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 4)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
 
             lua.push_ref(&self.table.0);
             lua.push_value(value)?;
-            protect_lua!(lua.state, 2, 0, fn(state) {
+            if lua.unlikely_memory_error() {
                 let len = ffi::lua_rawlen(state, -2) as Integer;
                 ffi::lua_rawseti(state, -2, len + 1);
-            })
+                ffi::lua_pop(state, 1);
+                Ok(())
+            } else {
+                protect_lua!(state, 2, 0, fn(state) {
+                    let len = ffi::lua_rawlen(state, -2) as Integer;
+                    ffi::lua_rawseti(state, -2, len + 1);
+                })
+            }
         }
     }
 

src/stdlib.rs

@@ -46,12 +46,14 @@ impl StdLib {
     ///
     /// Requires `feature = "luajit"`
     #[cfg(any(feature = "luajit", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
     pub const JIT: StdLib = StdLib(1 << 9);
 
     /// (**unsafe**) [`ffi`](http://luajit.org/ext_ffi.html) library
     ///
     /// Requires `feature = "luajit"`
     #[cfg(any(feature = "luajit", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
     pub const FFI: StdLib = StdLib(1 << 30);
     /// (**unsafe**) [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10) library
     pub const DEBUG: StdLib = StdLib(1 << 31);
@@ -61,7 +63,10 @@ impl StdLib {
     /// (**unsafe**) All standard libraries
     pub const ALL: StdLib = StdLib(u32::MAX);
     /// The safe subset of the standard libraries
+    #[cfg(not(feature = "luau"))]
     pub const ALL_SAFE: StdLib = StdLib((1 << 30) - 1);
+    #[cfg(feature = "luau")]
+    pub const ALL_SAFE: StdLib = StdLib(u32::MAX);
 
     pub fn contains(self, lib: Self) -> bool {
         (self & lib).0 != 0

src/string.rs

@@ -1,6 +1,8 @@
-use std::borrow::Cow;
+use std::borrow::{Borrow, Cow};
+use std::hash::{Hash, Hasher};
+use std::os::raw::c_void;
 use std::string::String as StdString;
-use std::{slice, str};
+use std::{fmt, slice, str};
 
 #[cfg(feature = "serialize")]
 use {
@@ -11,12 +13,11 @@ use {
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{assert_stack, StackGuard};
 
 /// Handle to an internal Lua string.
 ///
 /// Unlike Rust strings, Lua strings may not be valid UTF-8.
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct String<'lua>(pub(crate) LuaRef<'lua>);
 
 impl<'lua> String<'lua> {
@@ -38,6 +39,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn to_str(&self) -> Result<&str> {
         str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
             from: "string",
@@ -64,6 +66,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn to_string_lossy(&self) -> Cow<'_, str> {
         StdString::from_utf8_lossy(self.as_bytes())
     }
@@ -85,6 +88,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn as_bytes(&self) -> &[u8] {
         let nulled = self.as_bytes_with_nul();
         &nulled[..nulled.len() - 1]
@@ -92,25 +96,61 @@ impl<'lua> String<'lua> {
 
     /// Get the bytes that make up this string, including the trailing nul byte.
     pub fn as_bytes_with_nul(&self) -> &[u8] {
-        let lua = self.0.lua;
+        let ref_thread = self.0.lua.ref_thread();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
-
-            lua.push_ref(&self.0);
             mlua_debug_assert!(
-                ffi::lua_type(lua.state, -1) == ffi::LUA_TSTRING,
+                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 data = ffi::lua_tolstring(lua.state, -1, &mut size);
+            let data = ffi::lua_tolstring(ref_thread, self.0.index, &mut size);
 
             slice::from_raw_parts(data as *const u8, size + 1)
         }
     }
+
+    /// Converts the string to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_topointer(ref_thread, self.0.index) }
+    }
+}
+
+impl<'lua> fmt::Debug for String<'lua> {
+    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) {
+            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(())
+    }
 }
 
 impl<'lua> AsRef<[u8]> for String<'lua> {
@@ -119,6 +159,12 @@ impl<'lua> AsRef<[u8]> for String<'lua> {
     }
 }
 
+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.
 //
 // This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str`, `String` and `mlua::String`
@@ -129,13 +175,21 @@ impl<'lua> AsRef<[u8]> for String<'lua> {
 // in other ways.
 impl<'lua, T> PartialEq<T> for String<'lua>
 where
-    T: AsRef<[u8]>,
+    T: AsRef<[u8]> + ?Sized,
 {
     fn eq(&self, other: &T) -> bool {
         self.as_bytes() == other.as_ref()
     }
 }
 
+impl<'lua> Eq for String<'lua> {}
+
+impl<'lua> Hash for String<'lua> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.as_bytes().hash(state);
+    }
+}
+
 #[cfg(feature = "serialize")]
 impl<'lua> Serialize for String<'lua> {
     fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
@@ -148,3 +202,10 @@ impl<'lua> Serialize for String<'lua> {
         }
     }
 }
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(String: Send);
+}

src/table.rs

@@ -1,18 +1,20 @@
 use std::marker::PhantomData;
+use std::os::raw::c_void;
 
 #[cfg(feature = "serialize")]
 use {
     rustc_hash::FxHashSet,
     serde::ser::{self, Serialize, SerializeMap, SerializeSeq, Serializer},
-    std::{cell::RefCell, os::raw::c_void, result::Result as StdResult},
+    std::{cell::RefCell, result::Result as StdResult},
 };
 
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::function::Function;
+use crate::private::Sealed;
 use crate::types::{Integer, LuaRef};
 use crate::util::{assert_stack, check_stack, StackGuard};
-use crate::value::{FromLua, FromLuaMulti, Nil, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Nil, Value};
 
 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
@@ -21,6 +23,20 @@ use {futures_core::future::LocalBoxFuture, futures_util::future};
 #[derive(Clone, Debug)]
 pub struct Table<'lua>(pub(crate) LuaRef<'lua>);
 
+/// Owned handle to an internal Lua table.
+#[cfg(feature = "unstable")]
+#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
+#[derive(Clone, Debug)]
+pub struct OwnedTable(pub(crate) crate::types::LuaOwnedRef);
+
+#[cfg(feature = "unstable")]
+impl OwnedTable {
+    /// Get borrowed handle to the underlying Lua table.
+    pub const fn to_ref(&self) -> Table {
+        Table(self.0.to_ref())
+    }
+}
+
 #[allow(clippy::len_without_is_empty)]
 impl<'lua> Table<'lua> {
     /// Sets a key-value pair in the table.
@@ -56,19 +72,25 @@ impl<'lua> Table<'lua> {
     /// ```
     ///
     /// [`raw_set`]: #method.raw_set
-    pub fn set<K: ToLua<'lua>, V: ToLua<'lua>>(&self, key: K, value: V) -> Result<()> {
-        let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
-        let value = value.to_lua(lua)?;
+    pub fn set<K: IntoLua<'lua>, V: IntoLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_set(key, value);
+        }
 
+        let lua = self.0.lua;
+        let key = key.into_lua(lua)?;
+        let value = value.into_lua(lua)?;
+
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 5)?;
 
             lua.push_ref(&self.0);
             lua.push_value(key)?;
             lua.push_value(value)?;
-            protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_settable(state, -3))
+            protect_lua!(state, 3, 0, fn(state) ffi::lua_settable(state, -3))
         }
     }
 
@@ -96,17 +118,23 @@ impl<'lua> Table<'lua> {
     /// ```
     ///
     /// [`raw_get`]: #method.raw_get
-    pub fn get<K: ToLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
+    pub fn get<K: IntoLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_get(key);
+        }
+
         let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
+        let state = lua.state();
+        let key = key.into_lua(lua)?;
 
         let value = unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 4)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
 
             lua.push_ref(&self.0);
             lua.push_value(key)?;
-            protect_lua!(lua.state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;
+            protect_lua!(state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;
 
             lua.pop_value()
         };
@@ -114,19 +142,57 @@ impl<'lua> Table<'lua> {
     }
 
     /// Checks whether the table contains a non-nil value for `key`.
-    pub fn contains_key<K: ToLua<'lua>>(&self, key: K) -> Result<bool> {
-        let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
+    pub fn contains_key<K: IntoLua<'lua>>(&self, key: K) -> Result<bool> {
+        Ok(self.get::<_, Value>(key)? != Value::Nil)
+    }
 
+    /// Appends a value to the back of the table.
+    pub fn push<V: IntoLua<'lua>>(&self, value: V) -> Result<()> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_push(value);
+        }
+
+        let lua = self.0.lua;
+        let state = lua.state();
+        let value = value.into_lua(lua)?;
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 4)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
 
             lua.push_ref(&self.0);
-            lua.push_value(key)?;
-            protect_lua!(lua.state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;
-            Ok(ffi::lua_isnil(lua.state, -1) == 0)
+            lua.push_value(value)?;
+            protect_lua!(state, 2, 0, fn(state) {
+                let len = ffi::luaL_len(state, -2) as Integer;
+                ffi::lua_seti(state, -2, len + 1);
+            })?
         }
+        Ok(())
+    }
+
+    /// Removes the last element from the table and returns it.
+    pub fn pop<V: FromLua<'lua>>(&self) -> Result<V> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_pop();
+        }
+
+        let lua = self.0.lua;
+        let state = lua.state();
+        let value = unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
+
+            lua.push_ref(&self.0);
+            protect_lua!(state, 1, 1, fn(state) {
+                let len = ffi::luaL_len(state, -1) as Integer;
+                ffi::lua_geti(state, -1, len);
+                ffi::lua_pushnil(state);
+                ffi::lua_seti(state, -3, len);
+            })?;
+            lua.pop_value()
+        };
+        V::from_lua(value, lua)
     }
 
     /// Compares two tables for equality.
@@ -186,34 +252,46 @@ impl<'lua> Table<'lua> {
     }
 
     /// Sets a key-value pair without invoking metamethods.
-    pub fn raw_set<K: ToLua<'lua>, V: ToLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+    pub fn raw_set<K: IntoLua<'lua>, V: IntoLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
         let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
-        let value = value.to_lua(lua)?;
+        let state = lua.state();
+        let key = key.into_lua(lua)?;
+        let value = value.into_lua(lua)?;
 
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 5)?;
 
             lua.push_ref(&self.0);
             lua.push_value(key)?;
             lua.push_value(value)?;
-            protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_rawset(state, -3))
+
+            if lua.unlikely_memory_error() {
+                ffi::lua_rawset(state, -3);
+                ffi::lua_pop(state, 1);
+                Ok(())
+            } else {
+                protect_lua!(state, 3, 0, fn(state) ffi::lua_rawset(state, -3))
+            }
         }
     }
 
     /// Gets the value associated to `key` without invoking metamethods.
-    pub fn raw_get<K: ToLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
+    pub fn raw_get<K: IntoLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
         let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
+        let state = lua.state();
+        let key = key.into_lua(lua)?;
 
         let value = unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 3)?;
 
             lua.push_ref(&self.0);
             lua.push_value(key)?;
-            ffi::lua_rawget(lua.state, -2);
+            ffi::lua_rawget(state, -2);
 
             lua.pop_value()
         };
@@ -222,21 +300,23 @@ impl<'lua> Table<'lua> {
 
     /// Inserts element value at position `idx` to the table, shifting up the elements from `table[idx]`.
     /// The worst case complexity is O(n), where n is the table length.
-    pub fn raw_insert<V: ToLua<'lua>>(&self, idx: Integer, value: V) -> Result<()> {
+    pub fn raw_insert<V: IntoLua<'lua>>(&self, idx: Integer, value: V) -> Result<()> {
         let lua = self.0.lua;
+        let state = lua.state();
+
         let size = self.raw_len();
         if idx < 1 || idx > size + 1 {
             return Err(Error::RuntimeError("index out of bounds".to_string()));
         }
 
-        let value = value.to_lua(lua)?;
+        let value = value.into_lua(lua)?;
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 5)?;
 
             lua.push_ref(&self.0);
             lua.push_value(value)?;
-            protect_lua!(lua.state, 2, 0, |state| {
+            protect_lua!(state, 2, 0, |state| {
                 for i in (idx..=size).rev() {
                     // table[i+1] = table[i]
                     ffi::lua_rawgeti(state, -2, i);
@@ -247,6 +327,58 @@ impl<'lua> Table<'lua> {
         }
     }
 
+    /// Appends a value to the back of the table without invoking metamethods.
+    pub fn raw_push<V: IntoLua<'lua>>(&self, value: V) -> Result<()> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
+        let lua = self.0.lua;
+        let state = lua.state();
+        let value = value.into_lua(lua)?;
+
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
+
+            lua.push_ref(&self.0);
+            lua.push_value(value)?;
+
+            unsafe fn callback(state: *mut ffi::lua_State) {
+                let len = ffi::lua_rawlen(state, -2) as Integer;
+                ffi::lua_rawseti(state, -2, len + 1);
+            }
+
+            if lua.unlikely_memory_error() {
+                callback(state);
+            } else {
+                protect_lua!(state, 2, 0, fn(state) callback(state))?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Removes the last element from the table and returns it, without invoking metamethods.
+    pub fn raw_pop<V: FromLua<'lua>>(&self) -> Result<V> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
+        let lua = self.0.lua;
+        let state = lua.state();
+        let value = unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 3)?;
+
+            lua.push_ref(&self.0);
+            let len = ffi::lua_rawlen(state, -1) as Integer;
+            ffi::lua_rawgeti(state, -1, len);
+            // Set slot to nil (it must be safe to do)
+            ffi::lua_pushnil(state);
+            ffi::lua_rawseti(state, -3, len);
+            lua.pop_value()
+        };
+        V::from_lua(value, lua)
+    }
+
     /// Removes a key from the table.
     ///
     /// If `key` is an integer, mlua shifts down the elements from `table[key+1]`,
@@ -254,9 +386,10 @@ impl<'lua> Table<'lua> {
     /// where n is the table length.
     ///
     /// For other key types this is equivalent to setting `table[key] = nil`.
-    pub fn raw_remove<K: ToLua<'lua>>(&self, key: K) -> Result<()> {
+    pub fn raw_remove<K: IntoLua<'lua>>(&self, key: K) -> Result<()> {
         let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
+        let state = lua.state();
+        let key = key.into_lua(lua)?;
         match key {
             Value::Integer(idx) => {
                 let size = self.raw_len();
@@ -264,11 +397,11 @@ impl<'lua> Table<'lua> {
                     return Err(Error::RuntimeError("index out of bounds".to_string()));
                 }
                 unsafe {
-                    let _sg = StackGuard::new(lua.state);
-                    check_stack(lua.state, 4)?;
+                    let _sg = StackGuard::new(state);
+                    check_stack(state, 4)?;
 
                     lua.push_ref(&self.0);
-                    protect_lua!(lua.state, 1, 0, |state| {
+                    protect_lua!(state, 1, 0, |state| {
                         for i in idx..size {
                             ffi::lua_rawgeti(state, -1, i + 1);
                             ffi::lua_rawseti(state, -2, i);
@@ -282,32 +415,73 @@ impl<'lua> Table<'lua> {
         }
     }
 
+    /// Clears the table, removing all keys and values from array and hash parts,
+    /// without invoking metamethods.
+    ///
+    /// This method is useful to clear the table while keeping its capacity.
+    pub fn clear(&self) -> Result<()> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
+        let lua = self.0.lua;
+        unsafe {
+            #[cfg(feature = "luau")]
+            ffi::lua_cleartable(lua.ref_thread(), self.0.index);
+
+            #[cfg(not(feature = "luau"))]
+            {
+                let state = lua.state();
+                check_stack(state, 4)?;
+
+                lua.push_ref(&self.0);
+
+                // Clear array part
+                for i in 1..=ffi::lua_rawlen(state, -1) {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_rawseti(state, -2, i as Integer);
+                }
+
+                // Clear hash part
+                // It must be safe as long as we don't use invalid keys
+                ffi::lua_pushnil(state);
+                while ffi::lua_next(state, -2) != 0 {
+                    ffi::lua_pop(state, 1); // pop value
+                    ffi::lua_pushvalue(state, -1); // copy key
+                    ffi::lua_pushnil(state);
+                    ffi::lua_rawset(state, -4);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     /// Returns the result of the Lua `#` operator.
     ///
     /// This might invoke the `__len` metamethod. Use the [`raw_len`] method if that is not desired.
     ///
     /// [`raw_len`]: #method.raw_len
     pub fn len(&self) -> Result<Integer> {
+        // Fast track
+        if !self.has_metatable() {
+            return Ok(self.raw_len());
+        }
+
         let lua = self.0.lua;
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 4)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 4)?;
 
             lua.push_ref(&self.0);
-            protect_lua!(lua.state, 1, 0, |state| ffi::luaL_len(state, -1))
+            protect_lua!(state, 1, 0, |state| ffi::luaL_len(state, -1))
         }
     }
 
     /// Returns the result of the Lua `#` operator, without invoking the `__len` metamethod.
     pub fn raw_len(&self) -> Integer {
-        let lua = self.0.lua;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
-
-            lua.push_ref(&self.0);
-            ffi::lua_rawlen(lua.state, -1) as Integer
-        }
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_rawlen(ref_thread, self.0.index) as Integer }
     }
 
     /// Returns a reference to the metatable of this table, or `None` if no metatable is set.
@@ -315,12 +489,13 @@ impl<'lua> Table<'lua> {
     /// Unlike the `getmetatable` Lua function, this method ignores the `__metatable` field.
     pub fn get_metatable(&self) -> Option<Table<'lua>> {
         let lua = self.0.lua;
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 2);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 2);
 
             lua.push_ref(&self.0);
-            if ffi::lua_getmetatable(lua.state, -1) == 0 {
+            if ffi::lua_getmetatable(state, -1) == 0 {
                 None
             } else {
                 Some(Table(lua.pop_ref()))
@@ -333,41 +508,86 @@ impl<'lua> Table<'lua> {
     /// If `metatable` is `None`, the metatable is removed (if no metatable is set, this does
     /// nothing).
     pub fn set_metatable(&self, metatable: Option<Table<'lua>>) {
+        // Workaround to throw readonly error without returning Result
+        #[cfg(feature = "luau")]
+        if self.is_readonly() {
+            panic!("attempt to modify a readonly table");
+        }
+
         let lua = self.0.lua;
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 2);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 2);
 
             lua.push_ref(&self.0);
             if let Some(metatable) = metatable {
                 lua.push_ref(&metatable.0);
             } else {
-                ffi::lua_pushnil(lua.state);
+                ffi::lua_pushnil(state);
             }
-            ffi::lua_setmetatable(lua.state, -2);
+            ffi::lua_setmetatable(state, -2);
         }
     }
 
+    /// Returns true if the table has metatable attached.
+    #[doc(hidden)]
+    #[inline]
+    pub fn has_metatable(&self) -> bool {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe {
+            if ffi::lua_getmetatable(ref_thread, self.0.index) != 0 {
+                ffi::lua_pop(ref_thread, 1);
+                return true;
+            }
+        }
+        false
+    }
+
     /// Sets `readonly` attribute on the table.
     ///
     /// Requires `feature = "luau"`
-    #[cfg(feature = "luau")]
+    #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn set_readonly(&self, enabled: bool) {
-        let lua = self.0.lua;
+        let ref_thread = self.0.lua.ref_thread();
         unsafe {
-            lua.ref_thread_exec(|refthr| ffi::lua_setreadonly(refthr, self.0.index, enabled as _));
+            ffi::lua_setreadonly(ref_thread, self.0.index, enabled as _);
+            if !enabled {
+                // Reset "safeenv" flag
+                ffi::lua_setsafeenv(ref_thread, self.0.index, 0);
+            }
         }
     }
 
     /// Returns `readonly` attribute of the table.
     ///
     /// Requires `feature = "luau"`
-    #[cfg(feature = "luau")]
+    #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn is_readonly(&self) -> bool {
-        let lua = self.0.lua;
-        unsafe { lua.ref_thread_exec(|refthr| ffi::lua_getreadonly(refthr, self.0.index) != 0) }
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_getreadonly(ref_thread, self.0.index) != 0 }
+    }
+
+    /// Converts the table to a generic C pointer.
+    ///
+    /// Different tables will give different pointers.
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_topointer(ref_thread, self.0.index) }
+    }
+
+    /// Convert this handle to owned version.
+    #[cfg(feature = "unstable")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
+    #[inline]
+    pub fn into_owned(self) -> OwnedTable {
+        OwnedTable(self.0.into_owned())
     }
 
     /// Consume this table and return an iterator over the pairs of the table.
@@ -495,18 +715,29 @@ impl<'lua> Table<'lua> {
     #[cfg(feature = "serialize")]
     pub(crate) fn is_array(&self) -> bool {
         let lua = self.0.lua;
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 3);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 3);
 
             lua.push_ref(&self.0);
-            if ffi::lua_getmetatable(lua.state, -1) == 0 {
+            if ffi::lua_getmetatable(state, -1) == 0 {
                 return false;
             }
-            crate::serde::push_array_metatable(lua.state);
-            ffi::lua_rawequal(lua.state, -1, -2) != 0
+            crate::serde::push_array_metatable(state);
+            ffi::lua_rawequal(state, -1, -2) != 0
         }
     }
+
+    #[cfg(feature = "luau")]
+    #[inline(always)]
+    pub(crate) fn check_readonly_write(&self) -> Result<()> {
+        if self.is_readonly() {
+            let err = "attempt to modify a readonly table".to_string();
+            return Err(Error::RuntimeError(err));
+        }
+        Ok(())
+    }
 }
 
 impl<'lua> PartialEq for Table<'lua> {
@@ -523,13 +754,13 @@ impl<'lua> AsRef<Table<'lua>> for Table<'lua> {
 }
 
 /// An extension trait for `Table`s that provides a variety of convenient functionality.
-pub trait TableExt<'lua> {
+pub trait TableExt<'lua>: Sealed {
     /// Calls the table as function assuming it has `__call` metamethod.
     ///
     /// The metamethod is called with the table as its first argument, followed by the passed arguments.
     fn call<A, R>(&self, args: A) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
     /// Asynchronously calls the table as function assuming it has `__call` metamethod.
@@ -540,7 +771,7 @@ pub trait TableExt<'lua> {
     fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut;
 
     /// Gets the function associated to `key` from the table and executes it,
@@ -552,8 +783,8 @@ pub trait TableExt<'lua> {
     /// This might invoke the `__index` metamethod.
     fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
     /// Gets the function associated to `key` from the table and executes it,
@@ -565,8 +796,8 @@ pub trait TableExt<'lua> {
     /// This might invoke the `__index` metamethod.
     fn call_function<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>;
 
     /// Gets the function associated to `key` from the table and asynchronously executes it,
@@ -580,8 +811,8 @@ pub trait TableExt<'lua> {
     fn call_async_method<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut;
 
     /// Gets the function associated to `key` from the table and asynchronously executes it,
@@ -599,15 +830,15 @@ pub trait TableExt<'lua> {
     ) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut;
 }
 
 impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call<A, R>(&self, args: A) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         // Convert table to a function and call via pcall that respects the `__call` metamethod.
@@ -618,7 +849,7 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         Function(self.0.clone()).call_async(args)
@@ -626,20 +857,20 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
 
     fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         let lua = self.0.lua;
-        let mut args = args.to_lua_multi(lua)?;
+        let mut args = args.into_lua_multi(lua)?;
         args.push_front(Value::Table(self.clone()));
         self.get::<_, Function>(key)?.call(args)
     }
 
     fn call_function<K, A, R>(&self, key: K, args: A) -> Result<R>
     where
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         self.get::<_, Function>(key)?.call(args)
@@ -649,12 +880,12 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call_async_method<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         let lua = self.0.lua;
-        let mut args = match args.to_lua_multi(lua) {
+        let mut args = match args.into_lua_multi(lua) {
             Ok(args) => args,
             Err(e) => return Box::pin(future::err(e)),
         };
@@ -666,8 +897,8 @@ impl<'lua> TableExt<'lua> for Table<'lua> {
     fn call_async_function<'fut, K, A, R>(&self, key: K, args: A) -> LocalBoxFuture<'fut, Result<R>>
     where
         'lua: 'fut,
-        K: ToLua<'lua>,
-        A: ToLuaMulti<'lua>,
+        K: IntoLua<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua> + 'fut,
     {
         match self.get::<_, Function>(key) {
@@ -687,8 +918,7 @@ impl<'lua> Serialize for Table<'lua> {
             static VISITED: RefCell<FxHashSet<*const c_void>> = RefCell::new(FxHashSet::default());
         }
 
-        let lua = self.0.lua;
-        let ptr = unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) };
+        let ptr = self.to_pointer();
         let res = VISITED.with(|visited| {
             {
                 let mut visited = visited.borrow_mut();
@@ -743,15 +973,16 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(prev_key) = self.key.take() {
             let lua = self.table.lua;
+            let state = lua.state();
 
             let res = (|| unsafe {
-                let _sg = StackGuard::new(lua.state);
-                check_stack(lua.state, 5)?;
+                let _sg = StackGuard::new(state);
+                check_stack(state, 5)?;
 
                 lua.push_ref(&self.table);
                 lua.push_value(prev_key)?;
 
-                let next = protect_lua!(lua.state, 2, ffi::LUA_MULTRET, |state| {
+                let next = protect_lua!(state, 2, ffi::LUA_MULTRET, |state| {
                     ffi::lua_next(state, -2)
                 })?;
                 if next != 0 {
@@ -803,16 +1034,17 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(index) = self.index.take() {
             let lua = self.table.lua;
+            let state = lua.state();
 
             let res = (|| unsafe {
-                let _sg = StackGuard::new(lua.state);
-                check_stack(lua.state, 1 + if self.raw { 0 } else { 3 })?;
+                let _sg = StackGuard::new(state);
+                check_stack(state, 1 + if self.raw { 0 } else { 3 })?;
 
                 lua.push_ref(&self.table);
                 let res = if self.raw {
-                    ffi::lua_rawgeti(lua.state, -1, index)
+                    ffi::lua_rawgeti(state, -1, index)
                 } else {
-                    protect_lua!(lua.state, 1, 1, |state| ffi::lua_geti(state, -1, index))?
+                    protect_lua!(state, 1, 1, |state| ffi::lua_geti(state, -1, index))?
                 };
                 match res {
                     ffi::LUA_TNIL if index > self.len.unwrap_or(0) => Ok(None),
@@ -833,3 +1065,13 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(Table: Send);
+
+    #[cfg(feature = "unstable")]
+    static_assertions::assert_not_impl_any!(OwnedTable: Send);
+}

src/thread.rs

@@ -4,8 +4,8 @@ use std::os::raw::c_int;
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{check_stack, error_traceback, pop_error, StackGuard};
-use crate::value::{FromLuaMulti, ToLuaMulti};
+use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
+use crate::value::{FromLuaMulti, IntoLuaMulti};
 
 #[cfg(any(
     feature = "lua54",
@@ -22,10 +22,9 @@ use {
     },
     futures_core::{future::Future, stream::Stream},
     std::{
-        cell::RefCell,
         marker::PhantomData,
-        os::raw::c_void,
         pin::Pin,
+        ptr::NonNull,
         task::{Context, Poll, Waker},
     },
 };
@@ -57,10 +56,9 @@ pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
 /// [`Stream`]: futures_core::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-#[derive(Debug)]
 pub struct AsyncThread<'lua, R> {
     thread: Thread<'lua>,
-    args0: RefCell<Option<Result<MultiValue<'lua>>>>,
+    args0: Option<Result<MultiValue<'lua>>>,
     ret: PhantomData<R>,
     recycle: bool,
 }
@@ -109,18 +107,19 @@ impl<'lua> Thread<'lua> {
     /// ```
     pub fn resume<A, R>(&self, args: A) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         let lua = self.0.lua;
-        let mut args = args.to_lua_multi(lua)?;
+        let state = lua.state();
+
+        let mut args = args.into_lua_multi(lua)?;
         let nargs = args.len() as c_int;
         let results = unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, cmp::max(nargs + 1, 3))?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, cmp::max(nargs + 1, 3))?;
 
-            let thread_state =
-                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));
+            let thread_state = ffi::lua_tothread(lua.ref_thread(), self.0.index);
 
             let status = ffi::lua_status(thread_state);
             if status != ffi::LUA_YIELD && ffi::lua_gettop(thread_state) == 0 {
@@ -131,19 +130,27 @@ impl<'lua> Thread<'lua> {
             for arg in args.drain_all() {
                 lua.push_value(arg)?;
             }
-            ffi::lua_xmove(lua.state, thread_state, nargs);
+            ffi::lua_xmove(state, thread_state, nargs);
 
             let mut nresults = 0;
 
-            let ret = ffi::lua_resume(thread_state, lua.state, nargs, &mut nresults as *mut c_int);
+            let ret = ffi::lua_resume(thread_state, state, nargs, &mut nresults as *mut c_int);
             if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
-                protect_lua!(lua.state, 0, 0, |_| error_traceback(thread_state))?;
-                return Err(pop_error(thread_state, ret));
+                if ret == ffi::LUA_ERRMEM {
+                    // Don't call error handler for memory errors
+                    return Err(pop_error(thread_state, ret));
+                }
+                check_stack(state, 3)?;
+                protect_lua!(state, 0, 1, |state| error_traceback_thread(
+                    state,
+                    thread_state
+                ))?;
+                return Err(pop_error(state, ret));
             }
 
             let mut results = args; // Reuse MultiValue container
-            check_stack(lua.state, nresults + 2)?; // 2 is extra for `lua.pop_value()` below
-            ffi::lua_xmove(thread_state, lua.state, nresults);
+            check_stack(state, nresults + 2)?; // 2 is extra for `lua.pop_value()` below
+            ffi::lua_xmove(thread_state, state, nresults);
 
             for _ in 0..nresults {
                 results.push_front(lua.pop_value());
@@ -157,8 +164,7 @@ impl<'lua> Thread<'lua> {
     pub fn status(&self) -> ThreadStatus {
         let lua = self.0.lua;
         unsafe {
-            let thread_state =
-                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));
+            let thread_state = ffi::lua_tothread(lua.ref_thread(), self.0.index);
 
             let status = ffi::lua_status(thread_state);
             if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
@@ -193,12 +199,13 @@ impl<'lua> Thread<'lua> {
     ))]
     pub fn reset(&self, func: Function<'lua>) -> Result<()> {
         let lua = self.0.lua;
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 2)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
 
             lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
+            let thread_state = ffi::lua_tothread(state, -1);
 
             #[cfg(feature = "lua54")]
             let status = ffi::lua_resetthread(thread_state);
@@ -207,12 +214,19 @@ impl<'lua> Thread<'lua> {
                 return Err(pop_error(thread_state, status));
             }
             #[cfg(all(feature = "luajit", feature = "vendored"))]
-            ffi::lua_resetthread(lua.state, thread_state);
+            ffi::lua_resetthread(state, thread_state);
             #[cfg(feature = "luau")]
             ffi::lua_resetthread(thread_state);
 
             lua.push_ref(&func.0);
-            ffi::lua_xmove(lua.state, thread_state, 1);
+            ffi::lua_xmove(state, thread_state, 1);
+
+            #[cfg(feature = "luau")]
+            {
+                // Inherit `LUA_GLOBALSINDEX` from the caller
+                ffi::lua_xpush(state, thread_state, ffi::LUA_GLOBALSINDEX);
+                ffi::lua_replace(thread_state, ffi::LUA_GLOBALSINDEX);
+            }
 
             Ok(())
         }
@@ -267,17 +281,65 @@ impl<'lua> Thread<'lua> {
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
-        let args = args.to_lua_multi(self.0.lua);
+        let args = args.into_lua_multi(self.0.lua);
         AsyncThread {
             thread: self,
-            args0: RefCell::new(Some(args)),
+            args0: Some(args),
             ret: PhantomData,
             recycle: false,
         }
     }
+
+    /// Enables sandbox mode on this thread.
+    ///
+    /// 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()`].
+    ///
+    /// 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.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result};
+    /// # 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);
+    ///     Ok(())
+    /// })?)?;
+    /// thread.sandbox()?;
+    /// thread.resume(())?;
+    ///
+    /// // The global environment should be unchanged
+    /// assert_eq!(lua.globals().get::<_, Option<u32>>("var")?, None);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(any(feature = "luau", docsrs))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    #[doc(hidden)]
+    pub fn sandbox(&self) -> Result<()> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let thread = ffi::lua_tothread(lua.ref_thread(), self.0.index);
+            check_stack(thread, 1)?;
+            check_stack(state, 3)?;
+            // Inherit `LUA_GLOBALSINDEX` from the caller
+            ffi::lua_xpush(state, thread, ffi::LUA_GLOBALSINDEX);
+            ffi::lua_replace(thread, ffi::LUA_GLOBALSINDEX);
+            protect_lua!(state, 0, 0, |_| ffi::luaL_sandboxthread(thread))
+        }
+    }
 }
 
 impl<'lua> PartialEq for Thread<'lua> {
@@ -295,12 +357,24 @@ impl<'lua, R> AsyncThread<'lua, R> {
 }
 
 #[cfg(feature = "async")]
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+#[cfg(any(
+    feature = "lua54",
+    all(feature = "luajit", feature = "vendored"),
+    feature = "luau",
+))]
 impl<'lua, R> Drop for AsyncThread<'lua, R> {
     fn drop(&mut self) {
         if self.recycle {
             unsafe {
-                self.thread.0.lua.recycle_thread(&mut self.thread);
+                let lua = self.thread.0.lua;
+                // For Lua 5.4 this also closes all pending to-be-closed variables
+                if !lua.recycle_thread(&mut self.thread) {
+                    #[cfg(feature = "lua54")]
+                    if self.thread.status() == ThreadStatus::Error {
+                        let thread_state = ffi::lua_tothread(lua.ref_thread(), self.thread.0.index);
+                        ffi::lua_resetthread(thread_state);
+                    }
+                }
             }
         }
     }
@@ -321,11 +395,14 @@ where
             _ => return Poll::Ready(None),
         };
 
-        let _wg = WakerGuard::new(lua, cx.waker().clone());
-        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
-            self.thread.resume(args?)?
+        let _wg = WakerGuard::new(lua, cx.waker());
+
+        // This is safe as we are not moving the whole struct
+        let this = unsafe { self.get_unchecked_mut() };
+        let ret: MultiValue = if let Some(args) = this.args0.take() {
+            this.thread.resume(args?)?
         } else {
-            self.thread.resume(())?
+            this.thread.resume(())?
         };
 
         if is_poll_pending(&ret) {
@@ -352,18 +429,21 @@ where
             _ => return Poll::Ready(Err(Error::CoroutineInactive)),
         };
 
-        let _wg = WakerGuard::new(lua, cx.waker().clone());
-        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
-            self.thread.resume(args?)?
+        let _wg = WakerGuard::new(lua, cx.waker());
+
+        // This is safe as we are not moving the whole struct
+        let this = unsafe { self.get_unchecked_mut() };
+        let ret: MultiValue = if let Some(args) = this.args0.take() {
+            this.thread.resume(args?)?
         } else {
-            self.thread.resume(())?
+            this.thread.resume(())?
         };
 
         if is_poll_pending(&ret) {
             return Poll::Pending;
         }
 
-        if let ThreadStatus::Resumable = self.thread.status() {
+        if let ThreadStatus::Resumable = this.thread.status() {
             // Ignore value returned via yield()
             cx.waker().wake_by_ref();
             return Poll::Pending;
@@ -378,34 +458,46 @@ where
 fn is_poll_pending(val: &MultiValue) -> bool {
     match val.iter().enumerate().last() {
         Some((0, Value::LightUserData(ud))) => {
-            ud.0 == &ASYNC_POLL_PENDING as *const u8 as *mut c_void
+            std::ptr::eq(ud.0 as *const u8, &ASYNC_POLL_PENDING as *const u8)
         }
         _ => false,
     }
 }
 
 #[cfg(feature = "async")]
-struct WakerGuard<'lua> {
+struct WakerGuard<'lua, 'a> {
     lua: &'lua Lua,
-    prev: Option<Waker>,
+    prev: NonNull<Waker>,
+    _phantom: PhantomData<&'a ()>,
 }
 
 #[cfg(feature = "async")]
-impl<'lua> WakerGuard<'lua> {
+impl<'lua, 'a> WakerGuard<'lua, 'a> {
     #[inline]
-    pub fn new(lua: &Lua, waker: Waker) -> Result<WakerGuard> {
+    pub fn new(lua: &'lua Lua, waker: &'a Waker) -> Result<WakerGuard<'lua, 'a>> {
         unsafe {
-            let prev = lua.set_waker(Some(waker));
-            Ok(WakerGuard { lua, prev })
+            let prev = lua.set_waker(NonNull::from(waker));
+            Ok(WakerGuard {
+                lua,
+                prev,
+                _phantom: PhantomData,
+            })
         }
     }
 }
 
 #[cfg(feature = "async")]
-impl<'lua> Drop for WakerGuard<'lua> {
+impl<'lua, 'a> Drop for WakerGuard<'lua, 'a> {
     fn drop(&mut self) {
         unsafe {
-            self.lua.set_waker(self.prev.take());
+            self.lua.set_waker(self.prev);
         }
     }
 }
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(Thread: Send);
+}

src/types.rs

@@ -1,5 +1,7 @@
+use std::cell::UnsafeCell;
 use std::hash::{Hash, Hasher};
 use std::os::raw::{c_int, c_void};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::{fmt, mem, ptr};
 
@@ -13,7 +15,7 @@ use crate::error::Result;
 use crate::ffi;
 #[cfg(not(feature = "luau"))]
 use crate::hook::Debug;
-use crate::lua::Lua;
+use crate::lua::{ExtraData, Lua};
 use crate::util::{assert_stack, StackGuard};
 use crate::value::MultiValue;
 
@@ -29,31 +31,42 @@ pub struct LightUserData(pub *mut c_void);
 pub(crate) type Callback<'lua, 'a> =
     Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> Result<MultiValue<'lua>> + 'a>;
 
-pub(crate) struct CallbackUpvalue<'lua> {
-    pub(crate) lua: Lua,
-    pub(crate) func: Callback<'lua, 'static>,
+pub(crate) struct Upvalue<T> {
+    pub(crate) data: T,
+    pub(crate) extra: Arc<UnsafeCell<ExtraData>>,
 }
 
+pub(crate) type CallbackUpvalue = Upvalue<Callback<'static, 'static>>;
+
 #[cfg(feature = "async")]
 pub(crate) type AsyncCallback<'lua, 'a> =
     Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> LocalBoxFuture<'lua, Result<MultiValue<'lua>>> + 'a>;
 
 #[cfg(feature = "async")]
-pub(crate) struct AsyncCallbackUpvalue<'lua> {
-    pub(crate) lua: Lua,
-    pub(crate) func: AsyncCallback<'lua, 'static>,
-}
+pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback<'static, 'static>>;
 
 #[cfg(feature = "async")]
-pub(crate) struct AsyncPollUpvalue<'lua> {
-    pub(crate) lua: Lua,
-    pub(crate) fut: LocalBoxFuture<'lua, Result<MultiValue<'lua>>>,
+pub(crate) type AsyncPollUpvalue = Upvalue<LocalBoxFuture<'static, Result<MultiValue<'static>>>>;
+
+/// Type to set next Luau VM action after executing interrupt function.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub enum VmState {
+    Continue,
+    Yield,
 }
+
 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()> + Send>>;
+pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()> + Send>;
 
 #[cfg(all(not(feature = "send"), not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()>>>;
+pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()>>;
+
+#[cfg(all(feature = "luau", feature = "send"))]
+pub(crate) type InterruptCallback = Arc<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(feature = "send", feature = "lua54"))]
 pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()> + Send>;
@@ -71,7 +84,7 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}
 
-pub(crate) struct DestructedUserdataMT;
+pub(crate) struct DestructedUserdata;
 
 /// An auto generated key into the Lua registry.
 ///
@@ -92,6 +105,7 @@ pub(crate) struct DestructedUserdataMT;
 /// [`AnyUserData::get_user_value`]: crate::AnyUserData::get_user_value
 pub struct RegistryKey {
     pub(crate) registry_id: c_int,
+    pub(crate) is_nil: AtomicBool,
     pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
 }
 
@@ -117,15 +131,27 @@ impl Eq for RegistryKey {}
 
 impl Drop for RegistryKey {
     fn drop(&mut self) {
-        let mut unref_list = mlua_expect!(self.unref_list.lock(), "unref list poisoned");
-        if let Some(list) = unref_list.as_mut() {
-            list.push(self.registry_id);
+        // We don't need to collect nil slot
+        if self.registry_id > ffi::LUA_REFNIL {
+            let mut unref_list = mlua_expect!(self.unref_list.lock(), "unref list poisoned");
+            if let Some(list) = unref_list.as_mut() {
+                list.push(self.registry_id);
+            }
         }
     }
 }
 
 impl RegistryKey {
-    // Destroys the RegistryKey without adding to the drop list
+    // Creates a new instance of `RegistryKey`
+    pub(crate) const fn new(id: c_int, unref_list: Arc<Mutex<Option<Vec<c_int>>>>) -> Self {
+        RegistryKey {
+            registry_id: id,
+            is_nil: AtomicBool::new(id == ffi::LUA_REFNIL),
+            unref_list,
+        }
+    }
+
+    // Destroys the `RegistryKey` without adding to the unref list
     pub(crate) fn take(self) -> c_int {
         let registry_id = self.registry_id;
         unsafe {
@@ -134,11 +160,46 @@ impl RegistryKey {
         }
         registry_id
     }
+
+    // Returns true if this `RegistryKey` holds a nil value
+    #[inline(always)]
+    pub(crate) fn is_nil(&self) -> bool {
+        self.is_nil.load(Ordering::Relaxed)
+    }
+
+    // Marks value of this `RegistryKey` as `Nil`
+    #[inline(always)]
+    pub(crate) fn set_nil(&self, enabled: bool) {
+        // We cannot replace previous value with nil in as this will break
+        // Lua mechanism to find free keys.
+        // Instead, we set a special flag to mark value as nil.
+        self.is_nil.store(enabled, Ordering::Relaxed);
+    }
 }
 
 pub(crate) struct LuaRef<'lua> {
     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,
+        }
+    }
+
+    #[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> {
@@ -155,8 +216,8 @@ impl<'lua> Clone for LuaRef<'lua> {
 
 impl<'lua> Drop for LuaRef<'lua> {
     fn drop(&mut self) {
-        if self.index > 0 {
-            self.lua.drop_ref(self);
+        if self.drop {
+            self.lua.drop_ref_index(self.index);
         }
     }
 }
@@ -164,12 +225,79 @@ impl<'lua> Drop for LuaRef<'lua> {
 impl<'lua> PartialEq for LuaRef<'lua> {
     fn eq(&self, other: &Self) -> bool {
         let lua = self.lua;
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 2);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 2);
             lua.push_ref(self);
             lua.push_ref(other);
-            ffi::lua_rawequal(lua.state, -1, -2) == 1
+            ffi::lua_rawequal(state, -1, -2) == 1
         }
     }
 }
+
+#[cfg(feature = "unstable")]
+pub(crate) struct LuaOwnedRef {
+    pub(crate) lua: Lua,
+    pub(crate) index: c_int,
+    _non_send: std::marker::PhantomData<*const ()>,
+}
+
+#[cfg(feature = "unstable")]
+impl fmt::Debug for LuaOwnedRef {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "OwnedRef({})", self.index)
+    }
+}
+
+#[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) {
+        self.lua.drop_ref_index(self.index);
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl LuaOwnedRef {
+    pub(crate) const fn new(lua: Lua, index: c_int) -> Self {
+        #[cfg(feature = "send")]
+        {
+            let _lua = lua;
+            let _index = index;
+            panic!("mlua must be compiled without \"send\" feature to use Owned types");
+        }
+
+        #[cfg(not(feature = "send"))]
+        LuaOwnedRef {
+            lua,
+            index,
+            _non_send: std::marker::PhantomData,
+        }
+    }
+
+    pub(crate) const fn to_ref(&self) -> LuaRef {
+        LuaRef {
+            lua: &self.lua,
+            index: self.index,
+            drop: false,
+        }
+    }
+}
+
+#[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);
+}

src/userdata_ext.rs

@@ -0,0 +1,205 @@
+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_core::future::LocalBoxFuture, futures_util::future};
+
+/// 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<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut;
+
+    /// Calls the userdata method, assuming it has `__index` metamethod
+    /// and a function associated to `name`.
+    fn call_method<A, R>(&self, name: impl AsRef<str>, args: A) -> Result<R>
+    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<'fut, A, R>(
+        &self,
+        name: impl AsRef<str>,
+        args: A,
+    ) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut;
+
+    /// 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: impl AsRef<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<'fut, A, R>(
+        &self,
+        name: impl AsRef<str>,
+        args: A,
+    ) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut;
+}
+
+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::RuntimeError(
+                "attempt to index a userdata value".to_string(),
+            )),
+        }
+    }
+
+    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::RuntimeError(
+                "attempt to index a userdata value".to_string(),
+            )),
+        }
+    }
+
+    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::RuntimeError(
+                "attempt to call a userdata value".to_string(),
+            )),
+        }
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut,
+    {
+        let metatable = match self.get_metatable() {
+            Ok(metatable) => metatable,
+            Err(err) => return Box::pin(future::err(err)),
+        };
+        match metatable.get::<Value>(MetaMethod::Call) {
+            Ok(Value::Function(func)) => func.call_async((self.clone(), args)),
+            Ok(_) => Box::pin(future::err(Error::RuntimeError(
+                "attempt to call a userdata value".to_string(),
+            ))),
+            Err(err) => Box::pin(future::err(err)),
+        }
+    }
+
+    fn call_method<A, R>(&self, name: impl AsRef<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<'fut, A, R>(
+        &self,
+        name: impl AsRef<str>,
+        args: A,
+    ) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut,
+    {
+        self.call_async_function(name, (self.clone(), args))
+    }
+
+    fn call_function<A, R>(&self, name: impl AsRef<str>, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua>,
+    {
+        match self.get(name.as_ref())? {
+            Value::Function(func) => func.call(args),
+            val => Err(Error::RuntimeError(format!(
+                "attempt to call a {} value",
+                val.type_name()
+            ))),
+        }
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async_function<'fut, A, R>(
+        &self,
+        name: impl AsRef<str>,
+        args: A,
+    ) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut,
+    {
+        match self.get(name.as_ref()) {
+            Ok(Value::Function(func)) => func.call_async(args),
+            Ok(val) => Box::pin(future::err(Error::RuntimeError(format!(
+                "attempt to call a {} value",
+                val.type_name()
+            )))),
+            Err(err) => Box::pin(future::err(err)),
+        }
+    }
+}

src/userdata_impl.rs

@@ -1,6 +1,7 @@
-use std::any::TypeId;
+use std::any::{self, TypeId};
 use std::cell::{Ref, RefCell, RefMut};
 use std::marker::PhantomData;
+use std::string::String as StdString;
 use std::sync::{Arc, Mutex, RwLock};
 
 use crate::error::{Error, Result};
@@ -11,7 +12,7 @@ use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
 };
 use crate::util::{check_stack, get_userdata, StackGuard};
-use crate::value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti, Value};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
 #[cfg(not(feature = "send"))]
 use std::rc::Rc;
@@ -19,23 +20,37 @@ use std::rc::Rc;
 #[cfg(feature = "async")]
 use {
     crate::types::AsyncCallback,
-    futures_core::future::Future,
     futures_util::future::{self, TryFutureExt},
+    std::future::Future,
 };
 
-pub(crate) struct StaticUserDataMethods<'lua, T: 'static + UserData> {
-    pub(crate) methods: Vec<(Vec<u8>, Callback<'lua, 'static>)>,
+pub struct UserDataRegistrar<'lua, T: 'static> {
+    // Fields
+    pub(crate) field_getters: Vec<(String, Callback<'lua, 'static>)>,
+    pub(crate) field_setters: Vec<(String, Callback<'lua, 'static>)>,
+    #[allow(clippy::type_complexity)]
+    pub(crate) meta_fields: Vec<(
+        String,
+        Box<dyn Fn(&'lua Lua) -> Result<Value<'lua>> + 'static>,
+    )>,
+
+    // Methods
+    pub(crate) methods: Vec<(String, Callback<'lua, 'static>)>,
     #[cfg(feature = "async")]
-    pub(crate) async_methods: Vec<(Vec<u8>, AsyncCallback<'lua, 'static>)>,
-    pub(crate) meta_methods: Vec<(MetaMethod, Callback<'lua, 'static>)>,
+    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<(MetaMethod, AsyncCallback<'lua, 'static>)>,
+    pub(crate) async_meta_methods: Vec<(String, AsyncCallback<'lua, 'static>)>,
+
     _type: PhantomData<T>,
 }
 
-impl<'lua, T: 'static + UserData> Default for StaticUserDataMethods<'lua, T> {
-    fn default() -> StaticUserDataMethods<'lua, T> {
-        StaticUserDataMethods {
+impl<'lua, T: 'static> UserDataRegistrar<'lua, T> {
+    pub(crate) const fn new() -> Self {
+        UserDataRegistrar {
+            field_getters: Vec::new(),
+            field_setters: Vec::new(),
+            meta_fields: Vec::new(),
             methods: Vec::new(),
             #[cfg(feature = "async")]
             async_methods: Vec::new(),
@@ -45,470 +60,372 @@ impl<'lua, T: 'static + UserData> Default for StaticUserDataMethods<'lua, T> {
             _type: PhantomData,
         }
     }
-}
 
-impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMethods<'lua, T> {
-    fn add_method<S, A, R, M>(&mut self, name: &S, method: M)
+    fn box_method<M, A, R>(name: &str, method: M) -> Callback<'lua, 'static>
     where
-        S: AsRef<[u8]> + ?Sized,
+        M: Fn(&'lua Lua, &T, A) -> Result<R> + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        self.methods
-            .push((name.as_ref().to_vec(), Self::box_method(method)));
-    }
+        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))?
+            };
+        }
 
-    fn add_method_mut<S, A, R, M>(&mut self, name: &S, method: M)
-    where
-        S: AsRef<[u8]> + ?Sized,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
-    {
-        self.methods
-            .push((name.as_ref().to_vec(), Self::box_method_mut(method)));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_method<S, A, R, M, MR>(&mut self, name: &S, method: M)
-    where
-        T: Clone,
-        S: AsRef<[u8]> + ?Sized,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
-        MR: 'lua + Future<Output = Result<R>>,
-    {
-        self.async_methods
-            .push((name.as_ref().to_vec(), Self::box_async_method(method)));
-    }
-
-    fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
-    where
-        S: AsRef<[u8]> + ?Sized,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
-    {
-        self.methods
-            .push((name.as_ref().to_vec(), Self::box_function(function)));
-    }
-
-    fn add_function_mut<S, A, R, F>(&mut self, name: &S, function: F)
-    where
-        S: AsRef<[u8]> + ?Sized,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
-    {
-        self.methods
-            .push((name.as_ref().to_vec(), Self::box_function_mut(function)));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_function<S, A, R, F, FR>(&mut self, name: &S, function: F)
-    where
-        S: AsRef<[u8]> + ?Sized,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
-        FR: 'lua + Future<Output = Result<R>>,
-    {
-        self.async_methods
-            .push((name.as_ref().to_vec(), Self::box_async_function(function)));
-    }
-
-    fn add_meta_method<S, A, R, M>(&mut self, meta: S, method: M)
-    where
-        S: Into<MetaMethod>,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
-    {
-        self.meta_methods
-            .push((meta.into(), Self::box_method(method)));
-    }
-
-    fn add_meta_method_mut<S, A, R, M>(&mut self, meta: S, method: M)
-    where
-        S: Into<MetaMethod>,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
-    {
-        self.meta_methods
-            .push((meta.into(), Self::box_method_mut(method)));
-    }
-
-    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_method<S, A, R, M, MR>(&mut self, meta: S, method: M)
-    where
-        T: Clone,
-        S: Into<MetaMethod>,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
-        MR: 'lua + Future<Output = Result<R>>,
-    {
-        self.async_meta_methods
-            .push((meta.into(), Self::box_async_method(method)));
-    }
-
-    fn add_meta_function<S, A, R, F>(&mut self, meta: S, function: F)
-    where
-        S: Into<MetaMethod>,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
-    {
-        self.meta_methods
-            .push((meta.into(), Self::box_function(function)));
-    }
-
-    fn add_meta_function_mut<S, A, R, F>(&mut self, meta: S, function: F)
-    where
-        S: Into<MetaMethod>,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
-    {
-        self.meta_methods
-            .push((meta.into(), Self::box_function_mut(function)));
-    }
-
-    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
-    fn add_async_meta_function<S, A, R, F, FR>(&mut self, meta: S, function: F)
-    where
-        S: Into<MetaMethod>,
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
-        FR: 'lua + Future<Output = Result<R>>,
-    {
-        self.async_meta_methods
-            .push((meta.into(), Self::box_async_function(function)));
-    }
-
-    // Below are internal methods used in generated code
-
-    fn add_callback(&mut self, name: Vec<u8>, callback: Callback<'lua, 'static>) {
-        self.methods.push((name, callback));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_callback(&mut self, name: Vec<u8>, callback: AsyncCallback<'lua, 'static>) {
-        self.async_methods.push((name, callback));
-    }
-
-    fn add_meta_callback(&mut self, meta: MetaMethod, callback: Callback<'lua, 'static>) {
-        self.meta_methods.push((meta, callback));
-    }
-
-    #[cfg(feature = "async")]
-    fn add_async_meta_callback(
-        &mut self,
-        meta: MetaMethod,
-        callback: AsyncCallback<'lua, 'static>,
-    ) {
-        self.async_meta_methods.push((meta, callback))
-    }
-}
-
-impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
-    fn box_method<A, R, M>(method: M) -> Callback<'lua, 'static>
-    where
-        A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
-    {
         Box::new(move |lua, mut args| {
-            if let Some(front) = args.pop_front() {
-                let userdata = AnyUserData::from_lua(front, lua)?;
-                unsafe {
-                    let _sg = StackGuard::new(lua.state);
-                    check_stack(lua.state, 2)?;
+            let front = args.pop_front();
+            let call = |ud| {
+                // Self was at index 1, so we pass 2 here
+                let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                method(lua, ud, args)?.into_lua_multi(lua)
+            };
 
-                    let type_id = lua.push_userdata_ref(&userdata.0)?;
+            if let Some(front) = front {
+                let state = lua.state();
+                let userdata = try_self_arg!(AnyUserData::from_lua(front, lua));
+                unsafe {
+                    let _sg = StackGuard::new(state);
+                    check_stack(state, 2)?;
+
+                    let type_id = try_self_arg!(lua.push_userdata_ref(&userdata.0));
                     match type_id {
                         Some(id) if id == TypeId::of::<T>() => {
-                            let ud = get_userdata_ref::<T>(lua.state)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            let ud = try_self_arg!(get_userdata_ref::<T>(state));
+                            call(&ud)
                         }
                         #[cfg(not(feature = "send"))]
                         Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                            let ud = get_userdata_ref::<Rc<RefCell<T>>>(lua.state)?;
-                            let ud = ud.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            let ud = try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(state));
+                            let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
+                            call(&ud)
                         }
                         Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                            let ud = get_userdata_ref::<Arc<Mutex<T>>>(lua.state)?;
-                            let ud = ud.try_lock().map_err(|_| Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            let ud = try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(state));
+                            let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
+                            call(&ud)
+                        }
+                        #[cfg(feature = "parking_lot")]
+                        Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
+                            let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(state);
+                            let ud = try_self_arg!(ud);
+                            let ud = try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
+                            call(&ud)
                         }
                         Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                            let ud = get_userdata_ref::<Arc<RwLock<T>>>(lua.state)?;
-                            let ud = ud.try_read().map_err(|_| Error::UserDataBorrowError)?;
-                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            let ud = try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(state));
+                            let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
+                            call(&ud)
                         }
-                        _ => Err(Error::UserDataTypeMismatch),
+                        #[cfg(feature = "parking_lot")]
+                        Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
+                            let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(state);
+                            let ud = try_self_arg!(ud);
+                            let ud = try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
+                            call(&ud)
+                        }
+                        _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
                     }
                 }
             } else {
-                Err(Error::FromLuaConversionError {
-                    from: "missing argument",
-                    to: "userdata",
-                    message: None,
-                })
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                Err(Error::bad_self_argument(&name, err))
             }
         })
     }
 
-    fn box_method_mut<A, R, M>(method: M) -> Callback<'lua, 'static>
+    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: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
+        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, mut args| {
-            if let Some(front) = args.pop_front() {
-                let userdata = AnyUserData::from_lua(front, lua)?;
-                let mut method = method
-                    .try_borrow_mut()
-                    .map_err(|_| Error::RecursiveMutCallback)?;
-                unsafe {
-                    let _sg = StackGuard::new(lua.state);
-                    check_stack(lua.state, 2)?;
+            let mut method = method
+                .try_borrow_mut()
+                .map_err(|_| Error::RecursiveMutCallback)?;
+            let front = args.pop_front();
+            let call = |ud| {
+                // Self was at index 1, so we pass 2 here
+                let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                method(lua, ud, args)?.into_lua_multi(lua)
+            };
 
-                    let type_id = lua.push_userdata_ref(&userdata.0)?;
+            if let Some(front) = front {
+                let state = lua.state();
+                let userdata = try_self_arg!(AnyUserData::from_lua(front, lua));
+                unsafe {
+                    let _sg = StackGuard::new(state);
+                    check_stack(state, 2)?;
+
+                    let type_id = try_self_arg!(lua.push_userdata_ref(&userdata.0));
                     match type_id {
                         Some(id) if id == TypeId::of::<T>() => {
-                            let mut ud = get_userdata_mut::<T>(lua.state)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            let mut ud = try_self_arg!(get_userdata_mut::<T>(state));
+                            call(&mut ud)
                         }
                         #[cfg(not(feature = "send"))]
                         Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                            let ud = get_userdata_mut::<Rc<RefCell<T>>>(lua.state)?;
-                            let mut ud = ud
-                                .try_borrow_mut()
-                                .map_err(|_| Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                            let ud = try_self_arg!(get_userdata_mut::<Rc<RefCell<T>>>(state));
+                            let mut ud =
+                                try_self_arg!(ud.try_borrow_mut(), Error::UserDataBorrowMutError);
+                            call(&mut ud)
                         }
                         Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                            let ud = get_userdata_mut::<Arc<Mutex<T>>>(lua.state)?;
+                            let ud = try_self_arg!(get_userdata_mut::<Arc<Mutex<T>>>(state));
                             let mut ud =
-                                ud.try_lock().map_err(|_| Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                                try_self_arg!(ud.try_lock(), Error::UserDataBorrowMutError);
+                            call(&mut ud)
+                        }
+                        #[cfg(feature = "parking_lot")]
+                        Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
+                            let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(state);
+                            let ud = try_self_arg!(ud);
+                            let mut ud =
+                                try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowMutError));
+                            call(&mut ud)
                         }
                         Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                            let ud = get_userdata_mut::<Arc<RwLock<T>>>(lua.state)?;
+                            let ud = try_self_arg!(get_userdata_mut::<Arc<RwLock<T>>>(state));
                             let mut ud =
-                                ud.try_write().map_err(|_| Error::UserDataBorrowMutError)?;
-                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                                try_self_arg!(ud.try_write(), Error::UserDataBorrowMutError);
+                            call(&mut ud)
                         }
-                        _ => Err(Error::UserDataTypeMismatch),
+                        #[cfg(feature = "parking_lot")]
+                        Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
+                            let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(state);
+                            let ud = try_self_arg!(ud);
+                            let mut ud =
+                                try_self_arg!(ud.try_write().ok_or(Error::UserDataBorrowMutError));
+                            call(&mut ud)
+                        }
+                        _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
                     }
                 }
             } else {
-                Err(Error::FromLuaConversionError {
-                    from: "missing argument",
-                    to: "userdata",
-                    message: None,
-                })
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                Err(Error::bad_self_argument(&name, err))
             }
         })
     }
 
     #[cfg(feature = "async")]
-    fn box_async_method<A, R, M, MR>(method: M) -> AsyncCallback<'lua, 'static>
+    fn box_async_method<M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'lua, 'static>
     where
         T: Clone,
+        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
         A: FromLuaMulti<'lua>,
-        R: ToLuaMulti<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
-        MR: 'lua + Future<Output = Result<R>>,
+        MR: Future<Output = Result<R>> + '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, mut args| {
+            let front = args.pop_front();
+            let call = |ud| {
+                // Self was at index 1, so we pass 2 here
+                let args = A::from_lua_multi_args(args, 2, Some(&name), lua)?;
+                Ok(method(lua, ud, args))
+            };
+
             let fut_res = || {
-                if let Some(front) = args.pop_front() {
+                if let Some(front) = front {
+                    let state = lua.state();
                     let userdata = AnyUserData::from_lua(front, lua)?;
                     unsafe {
-                        let _sg = StackGuard::new(lua.state);
-                        check_stack(lua.state, 2)?;
+                        let _sg = StackGuard::new(state);
+                        check_stack(state, 2)?;
 
-                        let type_id = lua.push_userdata_ref(&userdata.0)?;
+                        let type_id = try_self_arg!(lua.push_userdata_ref(&userdata.0));
                         match type_id {
                             Some(id) if id == TypeId::of::<T>() => {
-                                let ud = get_userdata_ref::<T>(lua.state)?;
-                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                                let ud = get_userdata_ref::<T>(state)?;
+                                call(ud.clone())
                             }
                             #[cfg(not(feature = "send"))]
                             Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
-                                let ud = get_userdata_ref::<Rc<RefCell<T>>>(lua.state)?;
-                                let ud = ud.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
-                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                                let ud = try_self_arg!(get_userdata_ref::<Rc<RefCell<T>>>(state));
+                                let ud = try_self_arg!(ud.try_borrow(), Error::UserDataBorrowError);
+                                call(ud.clone())
                             }
                             Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
-                                let ud = get_userdata_ref::<Arc<Mutex<T>>>(lua.state)?;
-                                let ud = ud.try_lock().map_err(|_| Error::UserDataBorrowError)?;
-                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                                let ud = try_self_arg!(get_userdata_ref::<Arc<Mutex<T>>>(state));
+                                let ud = try_self_arg!(ud.try_lock(), Error::UserDataBorrowError);
+                                call(ud.clone())
+                            }
+                            #[cfg(feature = "parking_lot")]
+                            Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
+                                let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(state);
+                                let ud = try_self_arg!(ud);
+                                let ud =
+                                    try_self_arg!(ud.try_lock().ok_or(Error::UserDataBorrowError));
+                                call(ud.clone())
                             }
                             Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
-                                let ud = get_userdata_ref::<Arc<RwLock<T>>>(lua.state)?;
-                                let ud = ud.try_read().map_err(|_| Error::UserDataBorrowError)?;
-                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                                let ud = try_self_arg!(get_userdata_ref::<Arc<RwLock<T>>>(state));
+                                let ud = try_self_arg!(ud.try_read(), Error::UserDataBorrowError);
+                                call(ud.clone())
                             }
-                            _ => Err(Error::UserDataTypeMismatch),
+                            #[cfg(feature = "parking_lot")]
+                            Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
+                                let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(state);
+                                let ud = try_self_arg!(ud);
+                                let ud =
+                                    try_self_arg!(ud.try_read().ok_or(Error::UserDataBorrowError));
+                                call(ud.clone())
+                            }
+                            _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
                         }
                     }
                 } else {
-                    Err(Error::FromLuaConversionError {
-                        from: "missing argument",
-                        to: "userdata",
-                        message: None,
-                    })
+                    let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                    Err(Error::bad_self_argument(&name, err))
                 }
             };
             match fut_res() {
-                Ok(fut) => Box::pin(fut.and_then(move |ret| future::ready(ret.to_lua_multi(lua)))),
+                Ok(fut) => {
+                    Box::pin(fut.and_then(move |ret| future::ready(ret.into_lua_multi(lua))))
+                }
                 Err(e) => Box::pin(future::err(e)),
             }
         })
     }
 
-    fn box_function<A, R, F>(function: F) -> Callback<'lua, 'static>
+    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: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
-        Box::new(move |lua, args| function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua))
+        let name = get_function_name::<T>(name);
+        Box::new(move |lua, args| {
+            function(lua, A::from_lua_multi_args(args, 1, Some(&name), lua)?)?.into_lua_multi(lua)
+        })
     }
 
-    fn box_function_mut<A, R, F>(function: F) -> Callback<'lua, 'static>
+    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: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
+        R: IntoLuaMulti<'lua>,
     {
+        let name = get_function_name::<T>(name);
         let function = RefCell::new(function);
         Box::new(move |lua, args| {
             let function = &mut *function
                 .try_borrow_mut()
                 .map_err(|_| Error::RecursiveMutCallback)?;
-            function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+            function(lua, A::from_lua_multi_args(args, 1, Some(&name), lua)?)?.into_lua_multi(lua)
         })
     }
 
     #[cfg(feature = "async")]
-    fn box_async_function<A, R, F, FR>(function: F) -> AsyncCallback<'lua, 'static>
+    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>,
-        R: ToLuaMulti<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
-        FR: 'lua + Future<Output = Result<R>>,
+        FR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
     {
+        let name = get_function_name::<T>(name);
         Box::new(move |lua, args| {
-            let args = match A::from_lua_multi(args, lua) {
+            let args = match A::from_lua_multi_args(args, 1, Some(&name), lua) {
                 Ok(args) => args,
                 Err(e) => return Box::pin(future::err(e)),
             };
-            Box::pin(function(lua, args).and_then(move |ret| future::ready(ret.to_lua_multi(lua))))
+            Box::pin(
+                function(lua, args).and_then(move |ret| future::ready(ret.into_lua_multi(lua))),
+            )
         })
     }
 }
 
-pub(crate) struct StaticUserDataFields<'lua, T: 'static + UserData> {
-    pub(crate) field_getters: Vec<(Vec<u8>, Callback<'lua, 'static>)>,
-    pub(crate) field_setters: Vec<(Vec<u8>, Callback<'lua, 'static>)>,
-    #[allow(clippy::type_complexity)]
-    pub(crate) meta_fields: Vec<(
-        MetaMethod,
-        Box<dyn Fn(&'lua Lua) -> Result<Value<'lua>> + 'static>,
-    )>,
-    _type: PhantomData<T>,
+// Returns function name for the type `T`, without the module path
+fn get_function_name<T: 'static>(name: &str) -> StdString {
+    let type_name = any::type_name::<T>().rsplit("::").next().unwrap();
+    format!("{type_name}.{name}",)
 }
 
-impl<'lua, T: 'static + UserData> Default for StaticUserDataFields<'lua, T> {
-    fn default() -> StaticUserDataFields<'lua, T> {
-        StaticUserDataFields {
-            field_getters: Vec::new(),
-            field_setters: Vec::new(),
-            meta_fields: Vec::new(),
-            _type: PhantomData,
-        }
-    }
-}
-
-impl<'lua, T: 'static + UserData> UserDataFields<'lua, T> for StaticUserDataFields<'lua, T> {
-    fn add_field_method_get<S, R, M>(&mut self, name: &S, method: M)
+impl<'lua, T: 'static> UserDataFields<'lua, T> for UserDataRegistrar<'lua, T> {
+    fn add_field_method_get<M, R>(&mut self, name: impl AsRef<str>, method: M)
     where
-        S: AsRef<[u8]> + ?Sized,
-        R: ToLua<'lua>,
-        M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>,
+        M: Fn(&'lua Lua, &T) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua<'lua>,
     {
-        self.field_getters.push((
-            name.as_ref().to_vec(),
-            StaticUserDataMethods::box_method(move |lua, data, ()| method(lua, data)),
-        ));
+        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<S, A, M>(&mut self, name: &S, method: M)
+    fn add_field_method_set<M, A>(&mut self, name: impl AsRef<str>, method: M)
     where
-        S: AsRef<[u8]> + ?Sized,
+        M: FnMut(&'lua Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua<'lua>,
-        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<()>,
     {
-        self.field_setters.push((
-            name.as_ref().to_vec(),
-            StaticUserDataMethods::box_method_mut(method),
-        ));
+        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<S, R, F>(&mut self, name: &S, function: F)
+    fn add_field_function_get<F, R>(&mut self, name: impl AsRef<str>, function: F)
     where
-        S: AsRef<[u8]> + ?Sized,
-        R: ToLua<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>,
+        F: Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua<'lua>,
     {
-        self.field_getters.push((
-            name.as_ref().to_vec(),
-            StaticUserDataMethods::<T>::box_function(function),
-        ));
+        let name = name.as_ref();
+        let func = Self::box_function(name, function);
+        self.field_getters.push((name.into(), func));
     }
 
-    fn add_field_function_set<S, A, F>(&mut self, name: &S, mut function: F)
+    fn add_field_function_set<F, A>(&mut self, name: impl AsRef<str>, mut function: F)
     where
-        S: AsRef<[u8]> + ?Sized,
+        F: FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()> + MaybeSend + 'static,
         A: FromLua<'lua>,
-        F: 'static + MaybeSend + FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()>,
     {
-        self.field_setters.push((
-            name.as_ref().to_vec(),
-            StaticUserDataMethods::<T>::box_function_mut(move |lua, (data, val)| {
-                function(lua, data, val)
-            }),
-        ));
+        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_with<S, R, F>(&mut self, meta: S, f: F)
+    fn add_meta_field_with<F, R>(&mut self, name: impl AsRef<str>, f: F)
     where
-        S: Into<MetaMethod>,
-        R: ToLua<'lua>,
-        F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>,
+        F: Fn(&'lua Lua) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua<'lua>,
     {
-        let meta = meta.into();
+        let name = name.as_ref().to_string();
         self.meta_fields.push((
-            meta.clone(),
+            name.clone(),
             Box::new(move |lua| {
-                let value = f(lua)?.to_lua(lua)?;
-                if meta == MetaMethod::Index || meta == MetaMethod::NewIndex {
+                let value = f(lua)?.into_lua(lua)?;
+                if name == MetaMethod::Index || name == MetaMethod::NewIndex {
                     match value {
                         Value::Nil | Value::Table(_) | Value::Function(_) => {}
                         _ => {
                             return Err(Error::MetaMethodTypeError {
-                                method: meta.to_string(),
+                                method: name.clone(),
                                 type_name: value.type_name(),
                                 message: Some("expected nil, table or function".to_string()),
                             })
@@ -522,15 +439,179 @@ impl<'lua, T: 'static + UserData> UserDataFields<'lua, T> for StaticUserDataFiel
 
     // Below are internal methods
 
-    fn add_field_getter(&mut self, name: Vec<u8>, callback: Callback<'lua, 'static>) {
+    fn add_field_getter(&mut self, name: String, callback: Callback<'lua, 'static>) {
         self.field_getters.push((name, callback));
     }
 
-    fn add_field_setter(&mut self, name: Vec<u8>, callback: Callback<'lua, 'static>) {
+    fn add_field_setter(&mut self, name: String, callback: Callback<'lua, 'static>) {
         self.field_setters.push((name, callback));
     }
 }
 
+impl<'lua, T: 'static> UserDataMethods<'lua, T> for UserDataRegistrar<'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<M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    where
+        T: Clone,
+        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
+    {
+        let name = name.as_ref();
+        self.async_methods
+            .push((name.into(), Self::box_async_method(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<M, A, MR, R>(&mut self, name: impl AsRef<str>, method: M)
+    where
+        T: Clone,
+        M: Fn(&'lua Lua, T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti<'lua>,
+        MR: Future<Output = Result<R>> + 'lua,
+        R: IntoLuaMulti<'lua>,
+    {
+        let name = name.as_ref();
+        self.async_meta_methods
+            .push((name.into(), Self::box_async_method(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 add_callback(&mut self, name: String, callback: Callback<'lua, 'static>) {
+        self.methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_callback(&mut self, name: String, callback: AsyncCallback<'lua, 'static>) {
+        self.async_methods.push((name, callback));
+    }
+
+    fn add_meta_callback(&mut self, name: String, callback: Callback<'lua, 'static>) {
+        self.meta_methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_meta_callback(&mut self, meta: String, callback: AsyncCallback<'lua, 'static>) {
+        self.async_meta_methods.push((meta, callback))
+    }
+}
+
 #[inline]
 unsafe fn get_userdata_ref<'a, T>(state: *mut ffi::lua_State) -> Result<Ref<'a, T>> {
     (*get_userdata::<UserDataCell<T>>(state, -1)).try_borrow()
@@ -543,9 +624,9 @@ unsafe fn get_userdata_mut<'a, T>(state: *mut ffi::lua_State) -> Result<RefMut<'
 
 macro_rules! lua_userdata_impl {
     ($type:ty) => {
-        impl<T: 'static + UserData> UserData for $type {
+        impl<T: UserData + 'static> UserData for $type {
             fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
-                let mut orig_fields = StaticUserDataFields::default();
+                let mut orig_fields = UserDataRegistrar::new();
                 T::add_fields(&mut orig_fields);
                 for (name, callback) in orig_fields.field_getters {
                     fields.add_field_getter(name, callback);
@@ -556,7 +637,7 @@ macro_rules! lua_userdata_impl {
             }
 
             fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-                let mut orig_methods = StaticUserDataMethods::default();
+                let mut orig_methods = UserDataRegistrar::new();
                 T::add_methods(&mut orig_methods);
                 for (name, callback) in orig_methods.methods {
                     methods.add_callback(name, callback);
@@ -581,3 +662,12 @@ macro_rules! lua_userdata_impl {
 lua_userdata_impl!(Rc<RefCell<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.rs

@@ -1,6 +1,7 @@
 use std::any::{Any, TypeId};
 use std::ffi::CStr;
 use std::fmt::Write;
+use std::mem::MaybeUninit;
 use std::os::raw::{c_char, c_int, c_void};
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
 use std::sync::Arc;
@@ -11,6 +12,7 @@ use rustc_hash::FxHashMap;
 
 use crate::error::{Error, Result};
 use crate::ffi;
+use crate::memory::MemoryState;
 
 static METATABLE_CACHE: Lazy<FxHashMap<TypeId, u8>> = Lazy::new(|| {
     let mut map = FxHashMap::with_capacity_and_hasher(32, Default::default());
@@ -46,7 +48,6 @@ pub unsafe fn check_stack(state: *mut ffi::lua_State, amount: c_int) -> Result<(
 pub struct StackGuard {
     state: *mut ffi::lua_State,
     top: c_int,
-    extra: c_int,
 }
 
 impl StackGuard {
@@ -58,17 +59,6 @@ impl StackGuard {
         StackGuard {
             state,
             top: ffi::lua_gettop(state),
-            extra: 0,
-        }
-    }
-
-    // Similar to `new`, but checks and keeps `extra` elements from top of the stack on Drop.
-    #[inline]
-    pub unsafe fn new_extra(state: *mut ffi::lua_State, extra: c_int) -> StackGuard {
-        StackGuard {
-            state,
-            top: ffi::lua_gettop(state),
-            extra,
         }
     }
 }
@@ -77,14 +67,11 @@ impl Drop for StackGuard {
     fn drop(&mut self) {
         unsafe {
             let top = ffi::lua_gettop(self.state);
-            if top < self.top + self.extra {
+            if top < self.top {
                 mlua_panic!("{} too many stack values popped", self.top - top)
             }
-            if top > self.top + self.extra {
-                if self.extra > 0 {
-                    ffi::lua_rotate(self.state, self.top + 1, self.extra);
-                }
-                ffi::lua_settop(self.state, self.top + self.extra);
+            if top > self.top {
+                ffi::lua_settop(self.state, self.top);
             }
         }
     }
@@ -103,8 +90,10 @@ pub unsafe fn protect_lua_call(
 ) -> Result<()> {
     let stack_start = ffi::lua_gettop(state) - nargs;
 
-    ffi::lua_pushcfunction(state, error_traceback);
-    ffi::lua_pushcfunction(state, f);
+    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);
     }
@@ -136,26 +125,21 @@ where
     F: Fn(*mut ffi::lua_State) -> R,
     R: Copy,
 {
-    union URes<R: Copy> {
-        uninit: (),
-        init: R,
-    }
-
     struct Params<F, R: Copy> {
         function: F,
-        result: URes<R>,
+        result: MaybeUninit<R>,
         nresults: c_int,
     }
 
     unsafe extern "C" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
     where
-        R: Copy,
         F: Fn(*mut ffi::lua_State) -> R,
+        R: Copy,
     {
         let params = ffi::lua_touserdata(state, -1) as *mut Params<F, R>;
         ffi::lua_pop(state, 1);
 
-        (*params).result.init = ((*params).function)(state);
+        (*params).result.write(((*params).function)(state));
 
         if (*params).nresults == ffi::LUA_MULTRET {
             ffi::lua_gettop(state)
@@ -166,15 +150,17 @@ where
 
     let stack_start = ffi::lua_gettop(state) - nargs;
 
-    ffi::lua_pushcfunction(state, error_traceback);
-    ffi::lua_pushcfunction(state, do_call::<F, R>);
+    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: f,
-        result: URes { uninit: () },
+        result: MaybeUninit::uninit(),
         nresults,
     };
 
@@ -185,7 +171,7 @@ where
     if ret == ffi::LUA_OK {
         // `LUA_OK` is only returned when the `do_call` function has completed successfully, so
         // `params.result` is definitely initialized.
-        Ok(params.result.init)
+        Ok(params.result.assume_init())
     } else {
         Err(pop_error(state, ret))
     }
@@ -203,7 +189,7 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
         "pop_error called with non-error return code"
     );
 
-    match get_gc_userdata::<WrappedFailure>(state, -1).as_mut() {
+    match get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_mut() {
         Some(WrappedFailure::Error(err)) => {
             ffi::lua_pop(state, 1);
             err.clone()
@@ -246,30 +232,38 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
     }
 }
 
-// Uses 3 stack spaces, does not call checkstack.
-#[inline]
-pub unsafe fn push_string<S: AsRef<[u8]> + ?Sized>(
-    state: *mut ffi::lua_State,
-    s: &S,
-) -> Result<()> {
-    let s = s.as_ref();
-    protect_lua!(state, 0, 1, |state| {
+// Uses 3 (or 1 if unprotected) stack spaces, does not call checkstack.
+#[inline(always)]
+pub unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect: bool) -> Result<()> {
+    // Always use protected mode if the string is too long
+    if protect || s.len() > (1 << 30) {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
+        })
+    } else {
         ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
-    })
+        Ok(())
+    }
 }
 
 // Uses 3 stack spaces, does not call checkstack.
 #[inline]
-pub unsafe fn push_table(state: *mut ffi::lua_State, narr: c_int, nrec: c_int) -> Result<()> {
-    protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
+pub unsafe fn push_table(
+    state: *mut ffi::lua_State,
+    narr: c_int,
+    nrec: c_int,
+    protect: bool,
+) -> Result<()> {
+    if protect {
+        protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
+    } else {
+        ffi::lua_createtable(state, narr, nrec);
+        Ok(())
+    }
 }
 
 // Uses 4 stack spaces, does not call checkstack.
-pub unsafe fn rawset_field<S>(state: *mut ffi::lua_State, table: c_int, field: &S) -> Result<()>
-where
-    S: AsRef<[u8]> + ?Sized,
-{
-    let field = field.as_ref();
+pub unsafe fn rawset_field(state: *mut ffi::lua_State, table: c_int, field: &str) -> Result<()> {
     ffi::lua_pushvalue(state, table);
     protect_lua!(state, 2, 0, |state| {
         ffi::lua_pushlstring(state, field.as_ptr() as *const c_char, field.len());
@@ -281,10 +275,14 @@ where
 // Internally uses 3 stack spaces, does not call checkstack.
 #[cfg(not(feature = "luau"))]
 #[inline]
-pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
-    let ud = protect_lua!(state, 0, 1, |state| {
+pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
+        })?
+    } else {
         ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
-    })?;
+    };
     ptr::write(ud, t);
     Ok(())
 }
@@ -292,20 +290,20 @@ pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
 // Internally uses 3 stack spaces, does not call checkstack.
 #[cfg(feature = "luau")]
 #[inline]
-pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
+pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
     unsafe extern "C" fn destructor<T>(ud: *mut c_void) {
-        let ud = ud as *mut T;
-        if *(ud.offset(1) as *mut u8) == 0 {
-            ptr::drop_in_place(ud);
-        }
+        ptr::drop_in_place(ud as *mut T);
     }
 
-    let ud = protect_lua!(state, 0, 1, |state| {
-        let size = mem::size_of::<T>() + 1;
+    let size = mem::size_of::<T>();
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
+        })?
+    } else {
         ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
-    })?;
+    };
     ptr::write(ud, t);
-    *(ud.offset(1) as *mut u8) = 0; // Mark as not destructed
 
     Ok(())
 }
@@ -313,10 +311,19 @@ pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
 // Internally uses 3 stack spaces, does not call checkstack.
 #[cfg(feature = "lua54")]
 #[inline]
-pub unsafe fn push_userdata_uv<T>(state: *mut ffi::lua_State, t: T, nuvalue: c_int) -> Result<()> {
-    let ud = protect_lua!(state, 0, 1, |state| {
+pub unsafe fn push_userdata_uv<T>(
+    state: *mut ffi::lua_State,
+    t: T,
+    nuvalue: c_int,
+    protect: bool,
+) -> Result<()> {
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
+        })?
+    } else {
         ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
-    })?;
+    };
     ptr::write(ud, t);
     Ok(())
 }
@@ -340,33 +347,51 @@ pub unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
     get_destructed_userdata_metatable(state);
     ffi::lua_setmetatable(state, -2);
     let ud = get_userdata::<T>(state, -1);
+
+    // Update userdata tag to disable destructor and mark as destructed
+    #[cfg(feature = "luau")]
+    ffi::lua_setuserdatatag(state, -1, 1);
+
     ffi::lua_pop(state, 1);
-    if cfg!(feature = "luau") {
-        *(ud.offset(1) as *mut u8) = 1; // Mark as destructed
-    }
     ptr::read(ud)
 }
 
 // Pushes the userdata and attaches a metatable with __gc method.
 // Internally uses 3 stack spaces, does not call checkstack.
-pub unsafe fn push_gc_userdata<T: Any>(state: *mut ffi::lua_State, t: T) -> Result<()> {
-    push_userdata(state, t)?;
+pub unsafe fn push_gc_userdata<T: Any>(
+    state: *mut ffi::lua_State,
+    t: T,
+    protect: bool,
+) -> Result<()> {
+    push_userdata(state, t, protect)?;
     get_gc_metatable::<T>(state);
     ffi::lua_setmetatable(state, -2);
     Ok(())
 }
 
 // Uses 2 stack spaces, does not call checkstack
-pub unsafe fn get_gc_userdata<T: Any>(state: *mut ffi::lua_State, index: c_int) -> *mut T {
+pub unsafe fn get_gc_userdata<T: Any>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+    mt_ptr: *const c_void,
+) -> *mut T {
     let ud = ffi::lua_touserdata(state, index) as *mut T;
     if ud.is_null() || ffi::lua_getmetatable(state, index) == 0 {
         return ptr::null_mut();
     }
-    get_gc_metatable::<T>(state);
-    let res = ffi::lua_rawequal(state, -1, -2);
-    ffi::lua_pop(state, 2);
-    if res == 0 {
-        return ptr::null_mut();
+    if !mt_ptr.is_null() {
+        let ud_mt_ptr = ffi::lua_topointer(state, -1);
+        ffi::lua_pop(state, 1);
+        if !ptr::eq(ud_mt_ptr, mt_ptr) {
+            return ptr::null_mut();
+        }
+    } else {
+        get_gc_metatable::<T>(state);
+        let res = ffi::lua_rawequal(state, -1, -2);
+        ffi::lua_pop(state, 2);
+        if res == 0 {
+            return ptr::null_mut();
+        }
     }
     ud
 }
@@ -389,11 +414,17 @@ unsafe fn init_userdata_metatable_index(state: *mut ffi::lua_State) -> Result<()
     }
     ffi::lua_pop(state, 1);
 
-    // Create and cache `__index` helper
+    // Create and cache `__index` generator
     let code = cstr!(
         r#"
             local error, isfunction = ...
             return function (__index, field_getters, methods)
+                -- Fastpath to return methods table for index access
+                if __index == nil and field_getters == nil then
+                    return methods
+                end
+
+                -- Alternatively return a function for index access
                 return function (self, key)
                     if field_getters ~= nil then
                         local field_getter = field_getters[key]
@@ -443,7 +474,7 @@ pub unsafe fn init_userdata_metatable_newindex(state: *mut ffi::lua_State) -> Re
     }
     ffi::lua_pop(state, 1);
 
-    // Create and cache `__newindex` helper
+    // Create and cache `__newindex` generator
     let code = cstr!(
         r#"
             local error, isfunction = ...
@@ -505,7 +536,7 @@ pub unsafe fn init_userdata_metatable<T>(
         // Push `__index` generator function
         init_userdata_metatable_index(state)?;
 
-        push_string(state, "__index")?;
+        push_string(state, b"__index", true)?;
         let index_type = ffi::lua_rawget(state, -3);
         match index_type {
             ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
@@ -530,7 +561,7 @@ pub unsafe fn init_userdata_metatable<T>(
         // Push `__newindex` generator function
         init_userdata_metatable_newindex(state)?;
 
-        push_string(state, "__newindex")?;
+        push_string(state, b"__newindex", true)?;
         let newindex_type = ffi::lua_rawget(state, -3);
         match newindex_type {
             ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
@@ -636,13 +667,20 @@ where
 }
 
 pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
+    // Luau calls error handler for memory allocation errors, skip it
+    // See https://github.com/Roblox/luau/issues/880
+    #[cfg(feature = "luau")]
+    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_gc_userdata::<WrappedFailure>(state, -1).is_null() {
+    if get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
         let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
         if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
             ffi::luaL_traceback(state, state, s, 0);
@@ -653,6 +691,20 @@ pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
     1
 }
 
+// A variant of `error_traceback` that can safely inspect another (yielded) thread stack
+pub unsafe fn error_traceback_thread(state: *mut ffi::lua_State, thread: *mut ffi::lua_State) {
+    // Move error object to the main thread to safely call `__tostring` metamethod if present
+    ffi::lua_xmove(thread, state, 1);
+
+    if get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
+        let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
+        if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+            ffi::luaL_traceback(state, thread, s, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+}
+
 // A variant of `pcall` that does not allow Lua to catch Rust panics from `callback_error`.
 pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
     ffi::luaL_checkstack(state, 2, ptr::null());
@@ -669,7 +721,7 @@ pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
         ffi::lua_gettop(state)
     } else {
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             ffi::lua_error(state);
         }
@@ -685,7 +737,7 @@ pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
         ffi::luaL_checkstack(state, 2, ptr::null());
 
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             1
         } else {
@@ -715,7 +767,7 @@ pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
         ffi::lua_gettop(state) - 1
     } else {
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             ffi::lua_error(state);
         }
@@ -758,7 +810,7 @@ pub unsafe fn init_gc_metatable<T: Any>(
 ) -> Result<()> {
     check_stack(state, 6)?;
 
-    push_table(state, 0, 3)?;
+    push_table(state, 0, 3, true)?;
 
     #[cfg(not(feature = "luau"))]
     {
@@ -799,7 +851,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         callback_error(state, |_| {
             check_stack(state, 3)?;
 
-            let err_buf = match get_gc_userdata::<WrappedFailure>(state, -1).as_ref() {
+            let err_buf = match get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref() {
                 Some(WrappedFailure::Error(error)) => {
                     let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
                     ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
@@ -810,7 +862,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
                     // 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);
+                    let _ = write!(&mut (*err_buf), "{error}");
                     Ok(err_buf)
                 }
                 Some(WrappedFailure::Panic(Some(ref panic))) => {
@@ -821,9 +873,9 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
                     ffi::lua_pop(state, 2);
 
                     if let Some(msg) = panic.downcast_ref::<&str>() {
-                        let _ = write!(&mut (*err_buf), "{}", msg);
+                        let _ = write!(&mut (*err_buf), "{msg}");
                     } else if let Some(msg) = panic.downcast_ref::<String>() {
-                        let _ = write!(&mut (*err_buf), "{}", msg);
+                        let _ = write!(&mut (*err_buf), "{msg}");
                     } else {
                         let _ = write!(&mut (*err_buf), "<panic>");
                     };
@@ -836,7 +888,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
                 }
             }?;
 
-            push_string(state, &*err_buf)?;
+            push_string(state, (*err_buf).as_bytes(), true)?;
             (*err_buf).clear();
 
             Ok(1)
@@ -857,7 +909,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         callback_error(state, |_| Err(Error::CallbackDestructed))
     }
 
-    push_table(state, 0, 26)?;
+    push_table(state, 0, 26, true)?;
     ffi::lua_pushcfunction(state, destructed_error);
     for &method in &[
         "__add",
@@ -899,6 +951,8 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         "__pairs",
         #[cfg(any(feature = "lua53", feature = "lua52", feature = "luajit52"))]
         "__ipairs",
+        #[cfg(feature = "luau")]
+        "__iter",
         #[cfg(feature = "lua54")]
         "__close",
     ] {
@@ -914,7 +968,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
 
     // Create error print buffer
     init_gc_metatable::<String>(state, None)?;
-    push_gc_userdata(state, String::new())?;
+    push_gc_userdata(state, String::new(), true)?;
     protect_lua!(state, 1, 0, fn(state) {
         let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
         ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
@@ -970,7 +1024,7 @@ pub(crate) unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> Stri
             let v = ffi::lua_tovector(state, index);
             mlua_debug_assert!(!v.is_null(), "vector is null");
             let (x, y, z) = (*v, *v.add(1), *v.add(2));
-            format!("vector({},{},{})", x, y, z)
+            format!("vector({x},{y},{z})")
         }
         ffi::LUA_TSTRING => {
             let mut size = 0;
@@ -992,6 +1046,13 @@ pub(crate) unsafe fn get_destructed_userdata_metatable(state: *mut ffi::lua_Stat
     ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, key);
 }
 
+pub(crate) unsafe fn ptr_to_cstr_bytes<'a>(input: *const c_char) -> Option<&'a [u8]> {
+    if input.is_null() {
+        return None;
+    }
+    Some(CStr::from_ptr(input).to_bytes())
+}
+
 static DESTRUCTED_USERDATA_METATABLE: u8 = 0;
 static ERROR_PRINT_BUFFER_KEY: u8 = 0;
 static USERDATA_METATABLE_INDEX: u8 = 0;

src/value.rs

@@ -1,5 +1,8 @@
 use std::iter::{self, FromIterator};
-use std::{slice, str, vec};
+use std::ops::Index;
+use std::os::raw::c_void;
+use std::sync::Arc;
+use std::{ptr, slice, str, vec};
 
 #[cfg(feature = "serialize")]
 use {
@@ -9,6 +12,7 @@ use {
 };
 
 use crate::error::{Error, Result};
+use crate::ffi;
 use crate::function::Function;
 use crate::lua::Lua;
 use crate::string::String;
@@ -90,7 +94,31 @@ impl<'lua> Value<'lua> {
         match (self, other.as_ref()) {
             (Value::Table(a), Value::Table(b)) => a.equals(b),
             (Value::UserData(a), Value::UserData(b)) => a.equals(b),
-            _ => Ok(self == other.as_ref()),
+            (a, b) => Ok(a == b),
+        }
+    }
+
+    /// 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.
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        unsafe {
+            match self {
+                Value::LightUserData(ud) => ud.0,
+                Value::Table(t) => t.to_pointer(),
+                Value::String(s) => s.to_pointer(),
+                Value::Function(Function(r))
+                | Value::Thread(Thread(r))
+                | Value::UserData(AnyUserData(r)) => {
+                    ffi::lua_topointer(r.lua.ref_thread(), r.index)
+                }
+                _ => ptr::null(),
+            }
         }
     }
 }
@@ -135,8 +163,7 @@ impl<'lua> Serialize for Value<'lua> {
             Value::Boolean(b) => serializer.serialize_bool(*b),
             #[allow(clippy::useless_conversion)]
             Value::Integer(i) => serializer
-                .serialize_i64((*i).try_into().expect("cannot convert lua_Integer to i64")),
-            #[allow(clippy::useless_conversion)]
+                .serialize_i64((*i).try_into().expect("cannot convert Lua Integer to i64")),
             Value::Number(n) => serializer.serialize_f64(*n),
             #[cfg(feature = "luau")]
             Value::Vector(x, y, z) => (x, y, z).serialize(serializer),
@@ -153,15 +180,34 @@ impl<'lua> Serialize for Value<'lua> {
 }
 
 /// Trait for types convertible to `Value`.
-pub trait ToLua<'lua> {
+pub trait IntoLua<'lua> {
     /// Performs the conversion.
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>>;
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>>;
 }
 
 /// Trait for types convertible from `Value`.
 pub trait FromLua<'lua>: Sized {
     /// Performs the conversion.
-    fn from_lua(lua_value: Value<'lua>, lua: &'lua Lua) -> Result<Self>;
+    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)]
+    fn from_lua_arg(
+        value: Value<'lua>,
+        i: usize,
+        to: Option<&str>,
+        lua: &'lua Lua,
+    ) -> Result<Self> {
+        Self::from_lua(value, 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.
@@ -170,15 +216,20 @@ pub struct MultiValue<'lua>(Vec<Value<'lua>>);
 
 impl<'lua> MultiValue<'lua> {
     /// Creates an empty `MultiValue` containing no values.
-    #[inline]
-    pub fn new() -> MultiValue<'lua> {
+    pub const fn new() -> MultiValue<'lua> {
         MultiValue(Vec::new())
     }
 
     /// Similar to `new` but can return previously used container with allocated capacity.
     #[inline]
-    pub(crate) fn new_or_cached(lua: &'lua Lua) -> MultiValue<'lua> {
-        lua.new_or_cached_multivalue()
+    pub(crate) fn new_or_pooled(lua: &'lua Lua) -> MultiValue<'lua> {
+        lua.new_multivalue_from_pool()
+    }
+
+    /// Clears and returns previously allocated multivalue container to the pool.
+    #[inline]
+    pub(crate) fn return_to_pool(multivalue: Self, lua: &Lua) {
+        lua.return_multivalue_to_pool(multivalue);
     }
 }
 
@@ -212,7 +263,24 @@ impl<'a, 'lua> IntoIterator for &'a MultiValue<'lua> {
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
-        (&self.0).iter().rev()
+        self.0.iter().rev()
+    }
+}
+
+impl<'lua> Index<usize> for MultiValue<'lua> {
+    type Output = Value<'lua>;
+
+    #[inline]
+    fn index(&self, index: usize) -> &Self::Output {
+        if let Some(result) = self.get(index) {
+            result
+        } else {
+            panic!(
+                "index out of bounds: the len is {} but the index is {}",
+                self.len(),
+                index
+            )
+        }
     }
 }
 
@@ -230,19 +298,27 @@ impl<'lua> MultiValue<'lua> {
         v
     }
 
+    #[inline]
+    pub fn get(&self, index: usize) -> Option<&Value<'lua>> {
+        if index < self.0.len() {
+            return self.0.get(self.0.len() - index - 1);
+        }
+        None
+    }
+
     #[inline]
     pub(crate) fn reserve(&mut self, size: usize) {
         self.0.reserve(size);
     }
 
     #[inline]
-    pub(crate) fn push_front(&mut self, value: Value<'lua>) {
-        self.0.push(value);
+    pub fn pop_front(&mut self) -> Option<Value<'lua>> {
+        self.0.pop()
     }
 
     #[inline]
-    pub(crate) fn pop_front(&mut self) -> Option<Value<'lua>> {
-        self.0.pop()
+    pub fn push_front(&mut self, value: Value<'lua>) {
+        self.0.push(value);
     }
 
     #[inline]
@@ -286,11 +362,11 @@ impl<'lua> MultiValue<'lua> {
 
 /// Trait for types convertible to any number of Lua values.
 ///
-/// This is a generalization of `ToLua`, allowing any number of resulting Lua values instead of just
-/// one. Any type that implements `ToLua` will automatically implement this trait.
-pub trait ToLuaMulti<'lua> {
+/// 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> {
     /// Performs the conversion.
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>>;
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>>;
 }
 
 /// Trait for types that can be created from an arbitrary number of Lua values.
@@ -305,4 +381,28 @@ pub trait FromLuaMulti<'lua>: Sized {
     /// 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_multi_args(
+        values: MultiValue<'lua>,
+        i: usize,
+        to: Option<&str>,
+        lua: &'lua Lua,
+    ) -> Result<Self> {
+        let _ = (i, to);
+        Self::from_lua_multi(values, lua)
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(Value: Send);
+    static_assertions::assert_not_impl_any!(MultiValue: Send);
 }

tests/async.rs

@@ -1,19 +1,15 @@
 #![cfg(feature = "async")]
 
-use std::cell::Cell;
-use std::rc::Rc;
-use std::sync::{
-    atomic::{AtomicI64, AtomicU64, Ordering},
-    Arc,
-};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
 use std::time::Duration;
 
 use futures_timer::Delay;
 use futures_util::stream::TryStreamExt;
 
 use mlua::{
-    Error, Function, Lua, LuaOptions, Result, StdLib, Table, TableExt, Thread, UserData,
-    UserDataMethods, Value,
+    AnyUserDataExt, Error, Function, Lua, LuaOptions, Result, StdLib, Table, TableExt, UserData,
+    UserDataMethods,
 };
 
 #[tokio::test]
@@ -30,6 +26,20 @@ async fn test_async_function() -> Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "unstable")]
+#[tokio::test]
+async fn test_async_function_wrap() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = Function::wrap_async(|_, s: String| async move { Ok(s) });
+    lua.globals().set("f", f)?;
+
+    let res: String = lua.load(r#"f("hello")"#).eval_async().await?;
+    assert_eq!(res, "hello");
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_sleep() -> Result<()> {
     let lua = Lua::new();
@@ -75,7 +85,10 @@ async fn test_async_call() -> Result<()> {
 async fn test_async_bind_call() -> Result<()> {
     let lua = Lua::new();
 
-    let sum = lua.create_async_function(|_lua, (a, b): (i64, i64)| async move { Ok(a + b) })?;
+    let sum = lua.create_async_function(|_lua, (a, b): (i64, i64)| async move {
+        tokio::task::yield_now().await;
+        Ok(a + b)
+    })?;
 
     let plus_10 = sum.bind(10)?;
     lua.globals().set("plus_10", plus_10)?;
@@ -171,6 +184,38 @@ async fn test_async_return_async_closure() -> Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "lua54")]
+#[tokio::test]
+async fn test_async_lua54_to_be_closed() -> Result<()> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    globals.set("close_count", 0)?;
+
+    let code = r#"
+        local t <close> = setmetatable({}, {
+            __close = function()
+                close_count = close_count + 1
+            end
+        })
+        error "test"
+    "#;
+    let f = lua.load(code).into_function()?;
+
+    // Test close using call_async
+    let _ = f.call_async::<_, ()>(()).await;
+    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+
+    // Don't close by default when awaiting async threads
+    let co = lua.create_thread(f.clone())?;
+    let _ = co.clone().into_async::<_, ()>(()).await;
+    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+    let _ = co.reset(f);
+    assert_eq!(globals.get::<_, usize>("close_count")?, 2);
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_thread_stream() -> Result<()> {
     let lua = Lua::new();
@@ -228,7 +273,7 @@ async fn test_async_thread() -> Result<()> {
 
 #[tokio::test]
 async fn test_async_table() -> Result<()> {
-    let options = LuaOptions::new().thread_cache_size(4);
+    let options = LuaOptions::new().thread_pool_size(4);
     let lua = Lua::new_with(StdLib::ALL_SAFE, options)?;
 
     let table = lua.create_table()?;
@@ -275,6 +320,28 @@ async fn test_async_table() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_async_thread_pool() -> Result<()> {
+    let options = LuaOptions::new().thread_pool_size(4);
+    let lua = Lua::new_with(StdLib::ALL_SAFE, options)?;
+
+    let error_f = lua.create_async_function(|_, ()| async move {
+        Delay::new(Duration::from_millis(10)).await;
+        Err::<(), _>(Error::RuntimeError("test".to_string()))
+    })?;
+
+    let sleep = lua.create_async_function(|_, n| async move {
+        Delay::new(Duration::from_millis(n)).await;
+        Ok(format!("elapsed:{}ms", n))
+    })?;
+
+    assert!(error_f.call_async::<_, ()>(()).await.is_err());
+    // Next call should use cached thread
+    assert_eq!(sleep.call_async::<_, String>(3).await?, "elapsed:3ms");
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_userdata() -> Result<()> {
     #[derive(Clone)]
@@ -366,123 +433,37 @@ async fn test_async_userdata() -> Result<()> {
     .exec_async()
     .await?;
 
-    Ok(())
-}
+    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?;
 
-#[tokio::test]
-async fn test_async_scope() -> Result<()> {
-    let ref lua = Lua::new();
-
-    let ref rc = Rc::new(Cell::new(0));
-
-    let fut = lua.async_scope(|scope| async move {
-        let f = scope.create_async_function(move |_, n: u64| {
-            let rc2 = rc.clone();
-            async move {
-                rc2.set(42);
-                Delay::new(Duration::from_millis(n)).await;
-                assert_eq!(Rc::strong_count(&rc2), 2);
-                Ok(())
-            }
-        })?;
-
-        lua.globals().set("f", f.clone())?;
-
-        assert_eq!(Rc::strong_count(rc), 1);
-        let _ = f.call_async::<u64, ()>(10).await?;
-        assert_eq!(Rc::strong_count(rc), 1);
-
-        // Create future in partialy polled state (Poll::Pending)
-        let g = lua.create_thread(f)?;
-        g.resume::<u64, ()>(10)?;
-        lua.globals().set("g", g)?;
-        assert_eq!(Rc::strong_count(rc), 2);
-
-        Ok(())
-    });
-
-    assert_eq!(Rc::strong_count(rc), 1);
-    let _ = fut.await?;
-    assert_eq!(Rc::strong_count(rc), 1);
-
-    match lua
-        .globals()
-        .get::<_, Function>("f")?
-        .call_async::<_, ()>(10)
-        .await
-    {
-        Err(Error::CallbackError { ref cause, .. }) => match cause.as_ref() {
-            Error::CallbackDestructed => {}
-            e => panic!("expected `CallbackDestructed` error cause, got {:?}", e),
-        },
-        r => panic!("improper return for destructed function: {:?}", r),
-    };
-
-    match lua.globals().get::<_, Thread>("g")?.resume::<_, Value>(()) {
-        Err(Error::CallbackError { ref cause, .. }) => match cause.as_ref() {
-            Error::CallbackDestructed => {}
-            e => panic!("expected `CallbackDestructed` error cause, got {:?}", e),
-        },
-        r => panic!("improper return for destructed function: {:?}", r),
-    };
+    #[cfg(not(any(feature = "lua51", feature = "luau")))]
+    assert_eq!(userdata.call_async::<_, String>(()).await?, "elapsed:24ms");
 
     Ok(())
 }
 
 #[tokio::test]
-async fn test_async_scope_userdata() -> Result<()> {
-    #[derive(Clone)]
-    struct MyUserData(Arc<AtomicI64>);
+async fn test_async_thread_error() -> Result<()> {
+    struct MyUserData;
 
     impl UserData for MyUserData {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_async_method("get_value", |_, data, ()| async move {
-                Delay::new(Duration::from_millis(10)).await;
-                Ok(data.0.load(Ordering::Relaxed))
-            });
-
-            methods.add_async_method("set_value", |_, data, n| async move {
-                Delay::new(Duration::from_millis(10)).await;
-                data.0.store(n, Ordering::Relaxed);
-                Ok(())
-            });
-
-            methods.add_async_function("sleep", |_, n| async move {
-                Delay::new(Duration::from_millis(n)).await;
-                Ok(format!("elapsed:{}ms", n))
-            });
+            methods.add_meta_method("__tostring", |_, _this, ()| Ok("myuserdata error"))
         }
     }
 
-    let ref lua = Lua::new();
-
-    let ref arc = Arc::new(AtomicI64::new(11));
-
-    lua.async_scope(|scope| async move {
-        let ud = scope.create_userdata(MyUserData(arc.clone()))?;
-        lua.globals().set("userdata", ud)?;
-        lua.load(
-            r#"
-            assert(userdata:get_value() == 11)
-            userdata:set_value(12)
-            assert(userdata.sleep(5) == "elapsed:5ms")
-            assert(userdata:get_value() == 12)
-        "#,
-        )
-        .exec_async()
-        .await
-    })
-    .await?;
-
-    assert_eq!(Arc::strong_count(arc), 1);
-
-    match lua.load("userdata:get_value()").exec_async().await {
-        Err(Error::CallbackError { ref cause, .. }) => match cause.as_ref() {
-            Error::CallbackDestructed => {}
-            e => panic!("expected `CallbackDestructed` error cause, got {:?}", e),
-        },
-        r => panic!("improper return for destructed userdata: {:?}", r),
-    };
+    let lua = Lua::new();
+    let result = lua
+        .load("function x(...) error(...) end x(...)")
+        .set_name("chunk")
+        .call_async::<_, ()>(MyUserData)
+        .await;
+    assert!(
+        matches!(result, Err(Error::RuntimeError(cause)) if cause.contains("myuserdata error")),
+        "improper error traceback from dead thread"
+    );
 
     Ok(())
 }

tests/chunk.rs

@@ -0,0 +1,53 @@
+use std::fs;
+use std::io;
+
+use mlua::{Lua, Result};
+
+#[test]
+fn test_chunk_path() -> Result<()> {
+    let lua = Lua::new();
+
+    let temp_dir = tempfile::tempdir().unwrap();
+    fs::write(
+        temp_dir.path().join("module.lua"),
+        r#"
+        return 321
+    "#,
+    )?;
+    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() {
+        Err(err) if err.downcast_ref::<io::Error>().unwrap().kind() == io::ErrorKind::NotFound => {}
+        res => panic!("expected io::Error, got {:?}", res),
+    };
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "macros")]
+fn test_chunk_macro() -> Result<()> {
+    let lua = Lua::new();
+
+    let name = "Rustacean";
+    let table = vec![1];
+
+    let data = lua.create_table()?;
+    data.raw_set("num", 1)?;
+
+    lua.globals().set("g", 123)?;
+
+    lua.load(mlua::chunk! {
+        assert($name == "Rustacean")
+        assert($table[1] == 1)
+        assert($data.num == 1)
+        assert(g == 123)
+        s = 321
+    })
+    .exec()?;
+
+    assert_eq!(lua.globals().get::<_, i32>("s")?, 321);
+
+    Ok(())
+}

tests/compile/async_nonstatic_userdata.rs

@@ -1,8 +1,6 @@
-use mlua::{Lua, UserData, UserDataMethods};
+use mlua::{UserData, UserDataMethods};
 
 fn main() {
-    let ref lua = Lua::new();
-
     #[derive(Clone)]
     struct MyUserData<'a>(&'a i64);
 

tests/compile/async_nonstatic_userdata.stderr

@@ -1,36 +1,14 @@
-error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
-  --> $DIR/async_nonstatic_userdata.rs:11:72
+error: lifetime may not live long enough
+  --> tests/compile/async_nonstatic_userdata.rs:9:13
    |
-11 |               methods.add_async_method("print", |_, data, ()| async move {
-   |  ________________________________________________________________________^
-12 | |                 println!("{}", data.0);
-13 | |                 Ok(())
-14 | |             });
-   | |_____________^
+7  |       impl<'a> UserData for MyUserData<'a> {
+   |            -- lifetime `'a` defined here
+8  |           fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+   |                          ---- lifetime `'lua` defined here
+9  | /             methods.add_async_method("print", |_, data, ()| async move {
+10 | |                 println!("{}", data.0);
+11 | |                 Ok(())
+12 | |             });
+   | |______________^ argument requires that `'a` must outlive `'lua`
    |
-note: first, the lifetime cannot outlive the lifetime `'a` as defined on the impl at 9:10...
-  --> $DIR/async_nonstatic_userdata.rs:9:10
-   |
-9  |     impl<'a> UserData for MyUserData<'a> {
-   |          ^^
-note: ...so that the types are compatible
-  --> $DIR/async_nonstatic_userdata.rs:11:72
-   |
-11 |               methods.add_async_method("print", |_, data, ()| async move {
-   |  ________________________________________________________________________^
-12 | |                 println!("{}", data.0);
-13 | |                 Ok(())
-14 | |             });
-   | |_____________^
-   = note: expected `(MyUserData<'_>,)`
-              found `(MyUserData<'a>,)`
-note: but, the lifetime must be valid for the lifetime `'lua` as defined on the method body at 10:24...
-  --> $DIR/async_nonstatic_userdata.rs:10:24
-   |
-10 |         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-   |                        ^^^^
-note: ...so that the type `impl Future` will meet its required lifetime bounds
-  --> $DIR/async_nonstatic_userdata.rs:11:21
-   |
-11 |             methods.add_async_method("print", |_, data, ()| async move {
-   |                     ^^^^^^^^^^^^^^^^
+   = help: consider adding the following bound: `'a: 'lua`

tests/compile/function_borrow.stderr

@@ -1,10 +1,10 @@
-error[E0373]: closure may outlive the current function, but it borrows `test`, which is owned by the current function
+error[E0373]: closure may outlive the current function, but it borrows `test.0`, which is owned by the current function
   --> tests/compile/function_borrow.rs:9:33
    |
 9  |     let _ = lua.create_function(|_, ()| -> Result<i32> {
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^ may outlive borrowed value `test`
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^ may outlive borrowed value `test.0`
 10 |         Ok(test.0)
-   |            ------ `test` is borrowed here
+   |            ------ `test.0` is borrowed here
    |
 note: function requires argument type to outlive `'static`
   --> tests/compile/function_borrow.rs:9:13
@@ -14,7 +14,7 @@ note: function requires argument type to outlive `'static`
 10 | |         Ok(test.0)
 11 | |     });
    | |______^
-help: to force the closure to take ownership of `test` (and any other referenced variables), use the `move` keyword
+help: to force the closure to take ownership of `test.0` (and any other referenced variables), use the `move` keyword
    |
 9  |     let _ = lua.create_function(move |_, ()| -> Result<i32> {
    |                                 ++++

tests/compile/lua_norefunwindsafe.stderr

@@ -1,33 +1,20 @@
-error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+error[E0277]: the type `UnsafeCell<mlua::lua::LuaInner>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
    --> tests/compile/lua_norefunwindsafe.rs:7:5
     |
 7   |     catch_unwind(|| lua.create_table().unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::LuaInner>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
     |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<()>`
-    = note: required because it appears within the type `PhantomData<UnsafeCell<()>>`
+    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::LuaInner>`
+    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::LuaInner>>`
+    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::LuaInner>>>`
+    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::LuaInner>>`
     = note: required because it appears within the type `Lua`
     = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
-note: required by a bound in `catch_unwind`
-   --> $RUST/std/src/panic.rs
-    |
-    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
-
-error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> tests/compile/lua_norefunwindsafe.rs:7:5
-    |
-7   |     catch_unwind(|| lua.create_table().unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-    |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
-    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>`
-    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>>`
-    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::ExtraData>>`
-    = note: required because it appears within the type `Lua`
-    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
+note: required because it's used within this closure
+   --> tests/compile/lua_norefunwindsafe.rs:7:18
+    |
+7   |     catch_unwind(|| lua.create_table().unwrap());
+    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `catch_unwind`
    --> $RUST/std/src/panic.rs
     |

tests/compile/non_send.stderr

@@ -1,14 +1,26 @@
 error[E0277]: `Rc<Cell<i32>>` cannot be sent between threads safely
-  --> $DIR/non_send.rs:11:9
-   |
-11 |       lua.create_function(move |_, ()| {
-   |  _________^^^^^^^^^^^^^^^_-
-   | |         |
-   | |         `Rc<Cell<i32>>` cannot be sent between threads safely
-12 | |         Ok(data.get())
-13 | |     })?
-   | |_____- within this `[closure@$DIR/tests/compile/non_send.rs:11:25: 13:6]`
-   |
-   = help: within `[closure@$DIR/tests/compile/non_send.rs:11:25: 13:6]`, the trait `Send` is not implemented for `Rc<Cell<i32>>`
-   = note: required because it appears within the type `[closure@$DIR/tests/compile/non_send.rs:11:25: 13:6]`
-   = note: required because of the requirements on the impl of `mlua::types::MaybeSend` for `[closure@$DIR/tests/compile/non_send.rs:11:25: 13:6]`
+    --> tests/compile/non_send.rs:11:9
+     |
+11   |       lua.create_function(move |_, ()| {
+     |  _________^^^^^^^^^^^^^^^_-
+     | |         |
+     | |         `Rc<Cell<i32>>` cannot be sent between threads safely
+12   | |         Ok(data.get())
+13   | |     })?
+     | |_____- within this `[closure@$DIR/tests/compile/non_send.rs:11:25: 13:6]`
+     |
+     = help: within `[closure@$DIR/tests/compile/non_send.rs:11:25: 13:6]`, the trait `Send` is not implemented for `Rc<Cell<i32>>`
+note: required because it's used within this closure
+    --> tests/compile/non_send.rs:11:25
+     |
+11   |       lua.create_function(move |_, ()| {
+     |  _________________________^
+12   | |         Ok(data.get())
+13   | |     })?
+     | |_____^
+     = note: required because of the requirements on the impl of `mlua::types::MaybeSend` for `[closure@$DIR/tests/compile/non_send.rs:11:25: 13:6]`
+note: required by a bound in `Lua::create_function`
+    --> src/lua.rs
+     |
+     |         F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
+     |                      ^^^^^^^^^ required by this bound in `Lua::create_function`

tests/compile/ref_nounwindsafe.stderr

@@ -1,37 +1,22 @@
-error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+error[E0277]: the type `UnsafeCell<mlua::lua::LuaInner>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
    --> tests/compile/ref_nounwindsafe.rs:8:5
     |
 8   |     catch_unwind(move || table.set("a", "b").unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::LuaInner>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
     |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<()>`
-    = note: required because it appears within the type `PhantomData<UnsafeCell<()>>`
+    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::LuaInner>`
+    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::LuaInner>>`
+    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::LuaInner>>>`
+    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::LuaInner>>`
     = note: required because it appears within the type `Lua`
     = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
     = note: required because it appears within the type `mlua::types::LuaRef<'_>`
     = note: required because it appears within the type `LuaTable<'_>`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
-note: required by a bound in `catch_unwind`
-   --> $RUST/std/src/panic.rs
-    |
-    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
-
-error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> tests/compile/ref_nounwindsafe.rs:8:5
-    |
-8   |     catch_unwind(move || table.set("a", "b").unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-    |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
-    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>`
-    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>>`
-    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::ExtraData>>`
-    = note: required because it appears within the type `Lua`
-    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
-    = note: required because it appears within the type `mlua::types::LuaRef<'_>`
-    = note: required because it appears within the type `LuaTable<'_>`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
+note: required because it's used within this closure
+   --> tests/compile/ref_nounwindsafe.rs:8:18
+    |
+8   |     catch_unwind(move || table.set("a", "b").unwrap());
+    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `catch_unwind`
    --> $RUST/std/src/panic.rs
     |

tests/compile/scope_callback_inner.stderr

@@ -19,7 +19,7 @@ error[E0373]: closure may outlive the current function, but it borrows `inner`,
   --> tests/compile/scope_callback_inner.rs:8:34
    |
 5  |     lua.scope(|scope| {
-   |                ----- has type `&Scope<'_, '2>`
+   |                ----- has type `&mlua::Scope<'_, '2>`
 ...
 8  |             .create_function_mut(|_, t: Table| {
    |                                  ^^^^^^^^^^^^^ may outlive borrowed value `inner`

tests/compile/scope_invariance.stderr

@@ -1,13 +1,13 @@
-error[E0373]: closure may outlive the current function, but it borrows `test`, which is owned by the current function
+error[E0373]: closure may outlive the current function, but it borrows `test.field`, which is owned by the current function
   --> tests/compile/scope_invariance.rs:14:38
    |
 9  |     lua.scope(|scope| {
-   |                ----- has type `&Scope<'_, '1>`
+   |                ----- has type `&mlua::Scope<'_, '1>`
 ...
 14 |                 .create_function_mut(|_, ()| {
-   |                                      ^^^^^^^ may outlive borrowed value `test`
+   |                                      ^^^^^^^ may outlive borrowed value `test.field`
 15 |                     test.field = 42;
-   |                     ---------- `test` is borrowed here
+   |                     ---------- `test.field` is borrowed here
    |
 note: function requires argument type to outlive `'1`
   --> tests/compile/scope_invariance.rs:13:13
@@ -19,7 +19,7 @@ note: function requires argument type to outlive `'1`
 17 | |                     Ok(())
 18 | |                 })?
    | |__________________^
-help: to force the closure to take ownership of `test` (and any other referenced variables), use the `move` keyword
+help: to force the closure to take ownership of `test.field` (and any other referenced variables), use the `move` keyword
    |
 14 |                 .create_function_mut(move |_, ()| {
    |                                      ++++

tests/compile/scope_userdata_borrow.stderr

@@ -1,8 +1,8 @@
 error[E0597]: `ibad` does not live long enough
-  --> $DIR/scope_userdata_borrow.rs:15:56
+  --> tests/compile/scope_userdata_borrow.rs:15:56
    |
 11 |     lua.scope(|scope| {
-   |                ----- has type `&Scope<'_, '1>`
+   |                ----- has type `&mlua::Scope<'_, '1>`
 ...
 15 |             scope.create_nonstatic_userdata(MyUserData(&ibad)).unwrap();
    |             -------------------------------------------^^^^^--

tests/compile/static_callback_args.stderr

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

tests/error.rs

@@ -0,0 +1,33 @@
+use mlua::{Error, ErrorContext, Lua, Result};
+
+#[test]
+fn test_error_context() -> Result<()> {
+    let lua = Lua::new();
+
+    let func = lua.create_function(|_, ()| {
+        Err::<(), _>(Error::RuntimeError("runtime error".into())).context("some context")
+    })?;
+    lua.globals().set("func", func)?;
+
+    let msg = lua
+        .load("local _, err = pcall(func); return tostring(err)")
+        .eval::<String>()?;
+    assert!(msg.contains("some context"));
+    assert!(msg.contains("runtime error"));
+
+    let func2 = lua.create_function(|lua, ()| {
+        lua.globals()
+            .get::<_, String>("nonextant")
+            .with_context(|_| "failed to find global")
+    })?;
+    lua.globals().set("func2", func2)?;
+
+    let msg2 = lua
+        .load("local _, err = pcall(func2); return tostring(err)")
+        .eval::<String>()?;
+    assert!(msg2.contains("failed to find global"));
+    println!("{msg2}");
+    assert!(msg2.contains("error converting Lua nil to String"));
+
+    Ok(())
+}

tests/function.rs

@@ -42,11 +42,17 @@ fn test_bind() -> Result<()> {
     concat = concat.bind("foo")?;
     concat = concat.bind("bar")?;
     concat = concat.bind(("baz", "baf"))?;
+    assert_eq!(concat.call::<_, String>(())?, "foobarbazbaf");
     assert_eq!(
         concat.call::<_, String>(("hi", "wut"))?,
         "foobarbazbafhiwut"
     );
 
+    let mut concat2 = globals.get::<_, Function>("concat")?;
+    concat2 = concat2.bind(())?;
+    assert_eq!(concat2.call::<_, String>(())?, "");
+    assert_eq!(concat2.call::<_, String>(("ab", "cd"))?, "abcd");
+
     Ok(())
 }
 
@@ -107,3 +113,90 @@ fn test_dump() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_function_info() -> Result<()> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    lua.load(
+        r#"
+        function function1()
+            return function() end
+        end
+    "#,
+    )
+    .set_name("source1")
+    .exec()?;
+
+    let function1 = globals.get::<_, Function>("function1")?;
+    let function2 = function1.call::<_, Function>(())?;
+    let function3 = lua.create_function(|_, ()| Ok(()))?;
+
+    let function1_info = function1.info();
+    #[cfg(feature = "luau")]
+    assert_eq!(function1_info.name, Some(b"function1".to_vec()));
+    assert_eq!(function1_info.source, Some(b"source1".to_vec()));
+    assert_eq!(function1_info.line_defined, 2);
+    #[cfg(not(feature = "luau"))]
+    assert_eq!(function1_info.last_line_defined, 4);
+    assert_eq!(function1_info.what, Some(b"Lua".to_vec()));
+
+    let function2_info = function2.info();
+    assert_eq!(function2_info.name, None);
+    assert_eq!(function2_info.source, Some(b"source1".to_vec()));
+    assert_eq!(function2_info.line_defined, 3);
+    #[cfg(not(feature = "luau"))]
+    assert_eq!(function2_info.last_line_defined, 3);
+    assert_eq!(function2_info.what, Some(b"Lua".to_vec()));
+
+    let function3_info = function3.info();
+    assert_eq!(function3_info.name, None);
+    assert_eq!(function3_info.source, Some(b"=[C]".to_vec()));
+    assert_eq!(function3_info.line_defined, -1);
+    #[cfg(not(feature = "luau"))]
+    assert_eq!(function3_info.last_line_defined, -1);
+    assert_eq!(function3_info.what, Some(b"C".to_vec()));
+
+    let print_info = globals.get::<_, Function>("print")?.info();
+    #[cfg(feature = "luau")]
+    assert_eq!(print_info.name, Some(b"print".to_vec()));
+    assert_eq!(print_info.source, Some(b"=[C]".to_vec()));
+    assert_eq!(print_info.what, Some(b"C".to_vec()));
+    assert_eq!(print_info.line_defined, -1);
+
+    Ok(())
+}
+
+#[cfg(feature = "unstable")]
+#[test]
+fn test_function_wrap() -> Result<()> {
+    use mlua::Error;
+
+    let lua = Lua::new();
+
+    lua.globals()
+        .set("f", Function::wrap(|_, s: String| Ok(s)))?;
+    lua.load(r#"assert(f("hello") == "hello")"#).exec().unwrap();
+
+    let mut _i = false;
+    lua.globals().set(
+        "f",
+        Function::wrap_mut(move |lua, ()| {
+            _i = true;
+            lua.globals().get::<_, Function>("f")?.call::<_, ()>(())
+        }),
+    )?;
+    match lua.globals().get::<_, Function>("f")?.call::<_, ()>(()) {
+        Err(Error::CallbackError { ref cause, .. }) => match *cause.as_ref() {
+            Error::CallbackError { ref cause, .. } => match *cause.as_ref() {
+                Error::RecursiveMutCallback { .. } => {}
+                ref other => panic!("incorrect result: {other:?}"),
+            },
+            ref other => panic!("incorrect result: {other:?}"),
+        },
+        other => panic!("incorrect result: {other:?}"),
+    };
+
+    Ok(())
+}

tests/hooks.rs

@@ -3,6 +3,7 @@
 use std::cell::RefCell;
 use std::ops::Deref;
 use std::str;
+use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::{Arc, Mutex};
 
 use mlua::{DebugEvent, Error, HookTriggers, Lua, Result, Value};
@@ -128,18 +129,17 @@ fn test_error_within_hook() -> Result<()> {
 #[test]
 fn test_limit_execution_instructions() -> Result<()> {
     let lua = Lua::new();
-    let mut max_instructions = 10000;
 
-    #[cfg(feature = "luajit")]
     // For LuaJIT disable JIT, as compiled code does not trigger hooks
+    #[cfg(feature = "luajit")]
     lua.load("jit.off()").exec()?;
 
+    let max_instructions = AtomicI64::new(10000);
     lua.set_hook(
         HookTriggers::every_nth_instruction(30),
         move |_lua, debug| {
             assert_eq!(debug.event(), DebugEvent::Count);
-            max_instructions -= 30;
-            if max_instructions < 0 {
+            if max_instructions.fetch_sub(30, Ordering::Relaxed) <= 30 {
                 Err(Error::RuntimeError("time's up".to_string()))
             } else {
                 Ok(())

tests/luau.rs

@@ -1,9 +1,13 @@
 #![cfg(feature = "luau")]
 
 use std::env;
+use std::fmt::Debug;
 use std::fs;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
 
-use mlua::{Error, Lua, Result, Value};
+use mlua::{Compiler, CoverageInfo, Error, Lua, Result, Table, ThreadStatus, Value, VmState};
 
 #[test]
 fn test_require() -> Result<()> {
@@ -13,8 +17,11 @@ fn test_require() -> Result<()> {
     fs::write(
         temp_dir.path().join("module.luau"),
         r#"
-        counter = counter or 0
-        return counter + 1
+        counter = (counter or 0) + 1
+        return {
+            counter = counter,
+            error = function() error("test") end,
+        }
     "#,
     )?;
 
@@ -22,9 +29,12 @@ fn test_require() -> Result<()> {
     lua.load(
         r#"
         local module = require("module")
-        assert(module == 1)
+        assert(module.counter == 1)
         module = require("module")
-        assert(module == 1)
+        assert(module.counter == 1)
+
+        local ok, err = pcall(module.error)
+        assert(not ok and string.find(err, "module.luau") ~= nil)
     "#,
     )
     .exec()
@@ -34,17 +44,32 @@ fn test_require() -> Result<()> {
 fn test_vectors() -> Result<()> {
     let lua = Lua::new();
 
-    let globals = lua.globals();
-    globals.set(
-        "vector",
-        lua.create_function(|_, (x, y, z)| Ok(Value::Vector(x, y, z)))?,
-    )?;
-
-    let v: [f32; 3] = lua
-        .load("return vector(1, 2, 3) + vector(3, 2, 1)")
-        .eval()?;
+    let v: [f32; 3] = lua.load("vector(1, 2, 3) + vector(3, 2, 1)").eval()?;
     assert_eq!(v, [4.0, 4.0, 4.0]);
 
+    // Test vector methods
+    lua.load(
+        r#"
+        local v = vector(1, 2, 3)
+        assert(v.x == 1)
+        assert(v.y == 2)
+        assert(v.z == 3)
+    "#,
+    )
+    .exec()?;
+
+    // Test vector methods (fastcall)
+    lua.load(
+        r#"
+        local v = vector(1, 2, 3)
+        assert(v.x == 1)
+        assert(v.y == 2)
+        assert(v.z == 3)
+    "#,
+    )
+    .set_compiler(Compiler::new().set_vector_ctor(Some("vector".to_string())))
+    .exec()?;
+
     Ok(())
 }
 
@@ -52,18 +77,234 @@ fn test_vectors() -> Result<()> {
 fn test_readonly_table() -> Result<()> {
     let lua = Lua::new();
 
-    let t = lua.create_table()?;
+    let t = lua.create_sequence_from([1])?;
     assert!(!t.is_readonly());
     t.set_readonly(true);
     assert!(t.is_readonly());
 
-    match t.set("key", "value") {
-        Err(Error::RuntimeError(err)) if err.contains("Attempt to modify a readonly table") => {}
-        r => panic!(
-            "expected RuntimeError(...) with a specific message, got {:?}",
-            r
-        ),
-    };
+    #[track_caller]
+    fn check_readonly_error<T: Debug>(res: Result<T>) {
+        match res {
+            Err(Error::RuntimeError(e)) if e.contains("attempt to modify a readonly table") => {}
+            r => panic!("expected RuntimeError(...) with a specific message, got {r:?}"),
+        }
+    }
+
+    check_readonly_error(t.set("key", "value"));
+    check_readonly_error(t.raw_set("key", "value"));
+    check_readonly_error(t.raw_insert(1, "value"));
+    check_readonly_error(t.raw_remove(1));
+    check_readonly_error(t.push("value"));
+    check_readonly_error(t.pop::<Value>());
+    check_readonly_error(t.raw_push("value"));
+    check_readonly_error(t.raw_pop::<Value>());
+
+    // Special case
+    match catch_unwind(AssertUnwindSafe(|| t.set_metatable(None))) {
+        Ok(_) => panic!("expected panic, got nothing"),
+        Err(_) => {}
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_sandbox() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.sandbox(true)?;
+
+    lua.load("global = 123").exec()?;
+    let n: i32 = lua.load("return global").eval()?;
+    assert_eq!(n, 123);
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(123));
+
+    // Threads should inherit "main" globals
+    let f = lua.create_function(|lua, ()| lua.globals().get::<_, i32>("global"))?;
+    let co = lua.create_thread(f.clone())?;
+    assert_eq!(co.resume::<_, Option<i32>>(())?, Some(123));
+
+    // Sandboxed threads should also inherit "main" globals
+    let co = lua.create_thread(f)?;
+    co.sandbox()?;
+    assert_eq!(co.resume::<_, Option<i32>>(())?, Some(123));
+
+    lua.sandbox(false)?;
+
+    // Previously set variable `global` should be cleared now
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, None);
+
+    // Readonly flags should be cleared as well
+    let table = lua.globals().get::<_, Table>("table")?;
+    table.set("test", "test")?;
+
+    Ok(())
+}
+
+#[test]
+fn test_sandbox_threads() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = lua.create_function(|lua, v: Value| lua.globals().set("global", v))?;
+
+    let co = lua.create_thread(f.clone())?;
+    co.resume(321)?;
+    // The main state should see the `global` variable (as the thread is not sandboxed)
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(321));
+
+    let co = lua.create_thread(f.clone())?;
+    co.sandbox()?;
+    co.resume(123)?;
+    // The main state should see the previous `global` value (as the thread is sandboxed)
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(321));
+
+    // Try to reset the (sandboxed) thread
+    co.reset(f)?;
+    co.resume(111)?;
+    assert_eq!(lua.globals().get::<_, Option<i32>>("global")?, Some(111));
+
+    Ok(())
+}
+
+#[test]
+fn test_interrupts() -> Result<()> {
+    let lua = Lua::new();
+
+    let interrupts_count = Arc::new(AtomicU64::new(0));
+    let interrupts_count2 = interrupts_count.clone();
+
+    lua.set_interrupt(move |_| {
+        interrupts_count2.fetch_add(1, Ordering::Relaxed);
+        Ok(VmState::Continue)
+    });
+    let f = lua
+        .load(
+            r#"
+        local x = 2 + 3
+        local y = x * 63
+        local z = string.len(x..", "..y)
+    "#,
+        )
+        .into_function()?;
+    f.call(())?;
+
+    assert!(interrupts_count.load(Ordering::Relaxed) > 0);
+
+    //
+    // Test yields from interrupt
+    //
+    let yield_count = Arc::new(AtomicU64::new(0));
+    let yield_count2 = yield_count.clone();
+    lua.set_interrupt(move |_| {
+        if yield_count2.fetch_add(1, Ordering::Relaxed) == 1 {
+            return Ok(VmState::Yield);
+        }
+        Ok(VmState::Continue)
+    });
+    let co = lua.create_thread(
+        lua.load(
+            r#"
+            local a = {1, 2, 3}
+            local b = 0
+            for _, x in ipairs(a) do b += x end
+            return b
+        "#,
+        )
+        .into_function()?,
+    )?;
+    co.resume(())?;
+    assert_eq!(co.status(), ThreadStatus::Resumable);
+    let result: i32 = co.resume(())?;
+    assert_eq!(result, 6);
+    assert_eq!(yield_count.load(Ordering::Relaxed), 7);
+    assert_eq!(co.status(), ThreadStatus::Unresumable);
+
+    //
+    // Test errors in interrupts
+    //
+    lua.set_interrupt(|_| Err(Error::RuntimeError("error from interrupt".into())));
+    match f.call::<_, ()>(()) {
+        Err(Error::CallbackError { cause, .. }) => match *cause {
+            Error::RuntimeError(ref m) if m == "error from interrupt" => {}
+            ref e => panic!("expected RuntimeError with a specific message, got {:?}", e),
+        },
+        r => panic!("expected CallbackError, got {:?}", r),
+    }
+
+    lua.remove_interrupt();
+
+    Ok(())
+}
+
+#[test]
+fn test_coverage() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.set_compiler(Compiler::default().set_coverage_level(1));
+
+    let f = lua
+        .load(
+            r#"local v = vector(1, 2, 3)
+        assert(v.x == 1 and v.y == 2 and v.z == 3)
+
+        function abc(i)
+            if i < 5 then
+                return 0
+            else
+                return 1
+            end
+        end
+
+        (function()
+            (function() abc(10) end)()
+        end)()
+        "#,
+        )
+        .into_function()?;
+
+    f.call(())?;
+
+    let mut report = Vec::new();
+    f.coverage(|cov| {
+        report.push(cov);
+    });
+
+    assert_eq!(
+        report[0],
+        CoverageInfo {
+            function: None,
+            line_defined: 1,
+            depth: 0,
+            hits: vec![-1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1],
+        }
+    );
+    assert_eq!(
+        report[1],
+        CoverageInfo {
+            function: Some("abc".into()),
+            line_defined: 4,
+            depth: 1,
+            hits: vec![-1, -1, -1, -1, -1, 1, 0, -1, 1, -1, -1, -1, -1, -1, -1, -1],
+        }
+    );
+    assert_eq!(
+        report[2],
+        CoverageInfo {
+            function: None,
+            line_defined: 12,
+            depth: 1,
+            hits: vec![-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1],
+        }
+    );
+    assert_eq!(
+        report[3],
+        CoverageInfo {
+            function: None,
+            line_defined: 13,
+            depth: 2,
+            hits: vec![-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1],
+        }
+    );
 
     Ok(())
 }

tests/macros.rs

@@ -1,29 +0,0 @@
-#![cfg(feature = "macros")]
-
-use mlua::{chunk, Lua, Result};
-
-#[test]
-fn test_chunk_macro() -> Result<()> {
-    let lua = Lua::new();
-
-    let name = "Rustacean";
-    let table = vec![1];
-
-    let data = lua.create_table()?;
-    data.raw_set("num", 1)?;
-
-    lua.globals().set("g", 123)?;
-
-    lua.load(chunk! {
-        assert($name == "Rustacean")
-        assert($table[1] == 1)
-        assert($data.num == 1)
-        assert(g == 123)
-        s = 321
-    })
-    .exec()?;
-
-    assert_eq!(lua.globals().get::<_, i32>("s")?, 321);
-
-    Ok(())
-}

tests/memory.rs

@@ -1,11 +1,7 @@
 use std::sync::Arc;
 
-use mlua::{Lua, Result, UserData};
+use mlua::{Error, GCMode, Lua, Result, UserData};
 
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-use mlua::Error;
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
 #[test]
 fn test_memory_limit() -> Result<()> {
     let lua = Lua::new();
@@ -21,6 +17,15 @@ fn test_memory_limit() -> Result<()> {
         .into_function()?;
     f.call::<_, ()>(()).expect("should trigger no memory limit");
 
+    if cfg!(feature = "luajit") && cfg!(not(feature = "vendored")) {
+        // we don't support setting memory limit for non-vendored luajit
+        assert!(matches!(
+            lua.set_memory_limit(0),
+            Err(Error::MemoryLimitNotAvailable)
+        ));
+        return Ok(());
+    }
+
     lua.set_memory_limit(initial_memory + 10000)?;
     match f.call::<_, ()>(()) {
         Err(Error::MemoryError(_)) => {}
@@ -33,13 +38,39 @@ fn test_memory_limit() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_memory_limit_thread() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = lua
+        .load("local t = {}; for i = 1,10000 do t[i] = i end")
+        .into_function()?;
+
+    if cfg!(feature = "luajit") && cfg!(not(feature = "vendored")) {
+        // we don't support setting memory limit for non-vendored luajit
+        return Ok(());
+    }
+
+    lua.set_memory_limit(lua.used_memory() + 10000)?;
+    let thread = lua.create_thread(f)?;
+    match thread.resume::<_, ()>(()) {
+        Err(Error::MemoryError(_)) => {}
+        something_else => panic!("did not trigger memory error: {:?}", something_else),
+    };
+
+    Ok(())
+}
+
 #[test]
 fn test_gc_control() -> Result<()> {
     let lua = Lua::new();
     let globals = lua.globals();
 
     #[cfg(feature = "lua54")]
-    assert_eq!(lua.gc_gen(0, 0), mlua::GCMode::Incremental);
+    {
+        assert_eq!(lua.gc_gen(0, 0), GCMode::Incremental);
+        assert_eq!(lua.gc_inc(0, 0, 0), GCMode::Generational);
+    }
 
     #[cfg(any(
         feature = "lua54",
@@ -55,6 +86,8 @@ fn test_gc_control() -> Result<()> {
         assert!(lua.gc_is_running());
     }
 
+    assert_eq!(lua.gc_inc(200, 100, 13), GCMode::Incremental);
+
     struct MyUserdata(Arc<()>);
     impl UserData for MyUserdata {}
 
@@ -67,9 +100,6 @@ fn test_gc_control() -> Result<()> {
     lua.gc_collect()?;
     assert_eq!(Arc::strong_count(&rc), 1);
 
-    #[cfg(feature = "lua54")]
-    assert_eq!(lua.gc_inc(0, 0, 0), mlua::GCMode::Generational);
-
     Ok(())
 }
 

tests/module/.cargo/config

@@ -1,8 +1,11 @@
 [target.x86_64-apple-darwin]
-rustflags = ["-C", "link-args=-rdynamic"]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
 
 [target.aarch64-apple-darwin]
-rustflags = ["-C", "link-args=-rdynamic"]
-
-[target.x86_64-unknown-linux-gnu]
-rustflags = ["-C", "link-args=-rdynamic"]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]

tests/module/Cargo.toml

@@ -1,8 +1,16 @@
 [package]
-name = "module_runner"
+name = "test_module"
 version = "0.0.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-edition = "2018"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[workspace]
+members = [
+    "loader",
+]
 
 [features]
 lua54 = ["mlua/lua54"]
@@ -10,7 +18,6 @@ lua53 = ["mlua/lua53"]
 lua52 = ["mlua/lua52"]
 lua51 = ["mlua/lua51"]
 luajit = ["mlua/luajit"]
-vendored = ["mlua/vendored"]
 
 [dependencies]
-mlua = { path = "../.." }
+mlua = { path = "../..", features = ["module"] }

tests/module/loader/.cargo/config

@@ -0,0 +1,8 @@
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-args=-rdynamic"]
+
+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-args=-rdynamic"]
+
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-args=-rdynamic"]

tests/module/loader/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "module_loader"
+version = "0.0.0"
+authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
+edition = "2021"
+
+[features]
+lua54 = ["mlua/lua54"]
+lua53 = ["mlua/lua53"]
+lua52 = ["mlua/lua52"]
+lua51 = ["mlua/lua51"]
+luajit = ["mlua/luajit"]
+vendored = ["mlua/vendored"]
+
+[dependencies]
+mlua = { path = "../../.." }

tests/module/loader/tests/load.rs

@@ -8,7 +8,7 @@ fn test_module() -> Result<()> {
     let lua = make_lua()?;
     lua.load(
         r#"
-        local mod = require("rust_module")
+        local mod = require("test_module")
         assert(mod.sum(2,2) == 4)
     "#,
     )
@@ -20,8 +20,8 @@ fn test_module_multi() -> Result<()> {
     let lua = make_lua()?;
     lua.load(
         r#"
-        local mod = require("rust_module")
-        local mod2 = require("rust_module.second")
+        local mod = require("test_module")
+        local mod2 = require("test_module.second")
         assert(mod.check_userdata(mod2.userdata) == 123)
     "#,
     )
@@ -33,7 +33,7 @@ fn test_module_error() -> Result<()> {
     let lua = make_lua()?;
     lua.load(
         r#"
-        local ok, err = pcall(require, "rust_module.error")
+        local ok, err = pcall(require, "test_module.error")
         assert(not ok)
         assert(string.find(tostring(err), "custom module error"))
     "#,
@@ -55,7 +55,7 @@ fn test_module_from_thread() -> Result<()> {
         local mod
 
         local co = coroutine.create(function(a, b)
-            mod = require("rust_module")
+            mod = require("test_module")
             assert(mod.sum(a, b) == a + b)
         end)
 

tests/module/src/lib.rs

@@ -0,0 +1,39 @@
+use mlua::prelude::*;
+
+fn sum(_: &Lua, (a, b): (i64, i64)) -> LuaResult<i64> {
+    Ok(a + b)
+}
+
+fn used_memory(lua: &Lua, _: ()) -> LuaResult<usize> {
+    Ok(lua.used_memory())
+}
+
+fn check_userdata(_: &Lua, ud: LuaAnyUserData) -> LuaResult<i32> {
+    Ok(ud.borrow::<MyUserData>()?.0)
+}
+
+#[mlua::lua_module]
+fn test_module(lua: &Lua) -> LuaResult<LuaTable> {
+    let exports = lua.create_table()?;
+    exports.set("sum", lua.create_function(sum)?)?;
+    exports.set("used_memory", lua.create_function(used_memory)?)?;
+    exports.set("check_userdata", lua.create_function(check_userdata)?)?;
+    Ok(exports)
+}
+
+#[derive(Clone, Copy)]
+struct MyUserData(i32);
+
+impl LuaUserData for MyUserData {}
+
+#[mlua::lua_module(name = "test_module_second")]
+fn test_module2(lua: &Lua) -> LuaResult<LuaTable> {
+    let exports = lua.create_table()?;
+    exports.set("userdata", MyUserData(123))?;
+    Ok(exports)
+}
+
+#[mlua::lua_module]
+fn test_module_error(_: &Lua) -> LuaResult<LuaTable> {
+    Err("custom module error".into_lua_err())
+}

tests/scope.rs

@@ -356,3 +356,107 @@ fn test_scope_nonstatic_userdata_drop() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_scope_userdata_ref() -> Result<()> {
+    let lua = Lua::new();
+
+    struct MyUserData(Cell<i64>);
+
+    impl UserData for MyUserData {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_method("inc", |_, data, ()| {
+                data.0.set(data.0.get() + 1);
+                Ok(())
+            });
+
+            methods.add_method("dec", |_, data, ()| {
+                data.0.set(data.0.get() - 1);
+                Ok(())
+            });
+        }
+    }
+
+    let data = MyUserData(Cell::new(1));
+    lua.scope(|scope| {
+        let ud = scope.create_userdata_ref(&data)?;
+        modify_userdata(&lua, ud)
+    })?;
+    assert_eq!(data.0.get(), 2);
+
+    Ok(())
+}
+
+#[test]
+fn test_scope_userdata_ref_mut() -> Result<()> {
+    let lua = Lua::new();
+
+    struct MyUserData(i64);
+
+    impl UserData for MyUserData {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_method_mut("inc", |_, data, ()| {
+                data.0 += 1;
+                Ok(())
+            });
+
+            methods.add_method_mut("dec", |_, data, ()| {
+                data.0 -= 1;
+                Ok(())
+            });
+        }
+    }
+
+    let mut data = MyUserData(1);
+    lua.scope(|scope| {
+        let ud = scope.create_userdata_ref_mut(&mut data)?;
+        modify_userdata(&lua, ud)
+    })?;
+    assert_eq!(data.0, 2);
+
+    Ok(())
+}
+
+#[test]
+fn test_scope_any_userdata_ref() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.register_userdata_type::<Cell<i64>>(|reg| {
+        reg.add_method("inc", |_, data, ()| {
+            data.set(data.get() + 1);
+            Ok(())
+        });
+
+        reg.add_method("dec", |_, data, ()| {
+            data.set(data.get() - 1);
+            Ok(())
+        });
+    })?;
+
+    let data = Cell::new(1i64);
+    lua.scope(|scope| {
+        let ud = scope.create_any_userdata_ref(&data)?;
+        modify_userdata(&lua, ud)
+    })?;
+    assert_eq!(data.get(), 2);
+
+    Ok(())
+}
+
+fn modify_userdata(lua: &Lua, ud: AnyUserData) -> Result<()> {
+    let f: Function = lua
+        .load(
+            r#"
+    function(u)
+        u:inc()
+        u:dec()
+        u:inc()
+    end
+"#,
+        )
+        .eval()?;
+
+    f.call(ud)?;
+
+    Ok(())
+}

tests/serde.rs

@@ -1,6 +1,7 @@
 #![cfg(feature = "serialize")]
 
 use std::collections::HashMap;
+use std::error::Error as StdError;
 
 use mlua::{
     DeserializeOptions, Error, Lua, LuaSerdeExt, Result as LuaResult, SerializeOptions, UserData,
@@ -9,7 +10,7 @@ use mlua::{
 use serde::{Deserialize, Serialize};
 
 #[test]
-fn test_serialize() -> Result<(), Box<dyn std::error::Error>> {
+fn test_serialize() -> Result<(), Box<dyn StdError>> {
     #[derive(Serialize)]
     struct MyUserData(i64, String);
 
@@ -115,7 +116,7 @@ fn test_serialize_in_scope() -> LuaResult<()> {
 }
 
 #[test]
-fn test_serialize_failure() -> Result<(), Box<dyn std::error::Error>> {
+fn test_serialize_failure() -> Result<(), Box<dyn StdError>> {
     #[derive(Serialize)]
     struct MyUserData(i64);
 
@@ -146,7 +147,7 @@ fn test_serialize_failure() -> Result<(), Box<dyn std::error::Error>> {
 
 #[cfg(feature = "luau")]
 #[test]
-fn test_serialize_vector() -> Result<(), Box<dyn std::error::Error>> {
+fn test_serialize_vector() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
 
     let globals = lua.globals();
@@ -235,7 +236,7 @@ fn test_to_value_enum() -> LuaResult<()> {
 }
 
 #[test]
-fn test_to_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
+fn test_to_value_with_options() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
     let globals = lua.globals();
     globals.set("null", lua.null())?;
@@ -305,7 +306,7 @@ fn test_to_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn test_from_value_nested_tables() -> Result<(), Box<dyn std::error::Error>> {
+fn test_from_value_nested_tables() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
 
     let value = lua
@@ -335,7 +336,7 @@ fn test_from_value_nested_tables() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn test_from_value_struct() -> Result<(), Box<dyn std::error::Error>> {
+fn test_from_value_struct() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
 
     #[derive(Deserialize, PartialEq, Debug)]
@@ -376,7 +377,20 @@ fn test_from_value_struct() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn test_from_value_enum() -> Result<(), Box<dyn std::error::Error>> {
+fn test_from_value_newtype_struct() -> Result<(), Box<dyn StdError>> {
+    let lua = Lua::new();
+
+    #[derive(Deserialize, PartialEq, Debug)]
+    struct Test(f64);
+
+    let got = lua.from_value(Value::Number(123.456))?;
+    assert_eq!(Test(123.456), got);
+
+    Ok(())
+}
+
+#[test]
+fn test_from_value_enum() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
 
     #[derive(Deserialize, PartialEq, Debug)]
@@ -407,7 +421,7 @@ fn test_from_value_enum() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn test_from_value_enum_untagged() -> Result<(), Box<dyn std::error::Error>> {
+fn test_from_value_enum_untagged() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
     lua.globals().set("null", lua.null())?;
 
@@ -447,7 +461,7 @@ fn test_from_value_enum_untagged() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn test_from_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
+fn test_from_value_with_options() -> Result<(), Box<dyn StdError>> {
     let lua = Lua::new();
 
     // Deny unsupported types by default
@@ -502,3 +516,62 @@ fn test_from_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
+
+#[test]
+fn test_from_value_userdata() -> Result<(), Box<dyn StdError>> {
+    let lua = Lua::new();
+
+    // Tuple struct
+    #[derive(Serialize, Deserialize)]
+    struct MyUserData(i64, String);
+
+    impl UserData for MyUserData {}
+
+    let ud = lua.create_ser_userdata(MyUserData(123, "test userdata".into()))?;
+
+    match lua.from_value::<MyUserData>(Value::UserData(ud)) {
+        Ok(_) => {}
+        Err(err) => panic!("expected no errors, got {err:?}"),
+    };
+
+    // Newtype struct
+    #[derive(Serialize, Deserialize)]
+    struct NewtypeUserdata(String);
+
+    impl UserData for NewtypeUserdata {}
+
+    let ud = lua.create_ser_userdata(NewtypeUserdata("newtype userdata".into()))?;
+
+    match lua.from_value::<NewtypeUserdata>(Value::UserData(ud)) {
+        Ok(_) => {}
+        Err(err) => panic!("expected no errors, got {err:?}"),
+    };
+
+    // Option
+    #[derive(Serialize, Deserialize)]
+    struct UnitUserdata;
+
+    impl UserData for UnitUserdata {}
+
+    let ud = lua.create_ser_userdata(UnitUserdata)?;
+
+    match lua.from_value::<Option<()>>(Value::UserData(ud)) {
+        Ok(Some(_)) => {}
+        Ok(_) => panic!("expected `Some`, got `None`"),
+        Err(err) => panic!("expected no errors, got {err:?}"),
+    };
+
+    // Destructed userdata with skip option
+    let ud = lua.create_ser_userdata(NewtypeUserdata("newtype userdata".into()))?;
+    let _ = ud.take::<NewtypeUserdata>()?;
+
+    match lua.from_value_with::<()>(
+        Value::UserData(ud),
+        DeserializeOptions::new().deny_unsupported_types(false),
+    ) {
+        Ok(_) => {}
+        Err(err) => panic!("expected no errors, got {err:?}"),
+    };
+
+    Ok(())
+}

tests/static.rs

@@ -0,0 +1,114 @@
+use std::cell::RefCell;
+
+use mlua::{Lua, Result, Table};
+
+#[test]
+fn test_static_lua() -> Result<()> {
+    let lua = Lua::new().into_static();
+
+    thread_local! {
+        static TABLE: RefCell<Option<Table<'static>>> = RefCell::new(None);
+    }
+
+    let f = lua.create_function(|_, table: Table| {
+        TABLE.with(|t| {
+            table.raw_insert(1, "hello")?;
+            *t.borrow_mut() = Some(table);
+            Ok(())
+        })
+    })?;
+
+    f.call(lua.create_table()?)?;
+    drop(f);
+    lua.gc_collect()?;
+
+    TABLE.with(|t| {
+        assert!(t.borrow().as_ref().unwrap().len().unwrap() == 1);
+        *t.borrow_mut() = None;
+    });
+
+    // Consume the Lua instance
+    unsafe { Lua::from_static(lua) };
+
+    Ok(())
+}
+
+#[test]
+fn test_static_lua_coroutine() -> Result<()> {
+    let lua = Lua::new().into_static();
+
+    thread_local! {
+        static TABLE: RefCell<Option<Table<'static>>> = RefCell::new(None);
+    }
+
+    let f = lua.create_function(|_, table: Table| {
+        TABLE.with(|t| {
+            table.raw_insert(1, "hello")?;
+            *t.borrow_mut() = Some(table);
+            Ok(())
+        })
+    })?;
+
+    let co = lua.create_thread(f)?;
+    co.resume::<_, ()>(lua.create_table()?)?;
+    drop(co);
+    lua.gc_collect()?;
+
+    TABLE.with(|t| {
+        assert_eq!(
+            t.borrow().as_ref().unwrap().get::<_, String>(1i32).unwrap(),
+            "hello".to_string()
+        );
+        *t.borrow_mut() = None;
+    });
+
+    // Consume the Lua instance
+    unsafe { Lua::from_static(lua) };
+
+    Ok(())
+}
+
+#[cfg(feature = "async")]
+#[tokio::test]
+async fn test_static_async() -> Result<()> {
+    let lua = Lua::new().into_static();
+
+    let timer =
+        lua.create_async_function(|_, (i, n, f): (u64, u64, mlua::Function)| async move {
+            tokio::task::spawn_local(async move {
+                let dur = std::time::Duration::from_millis(i);
+                for _ in 0..n {
+                    tokio::task::spawn_local(f.call_async::<(), ()>(()));
+                    tokio::time::sleep(dur).await;
+                }
+            });
+            Ok(())
+        })?;
+    lua.globals().set("timer", timer)?;
+
+    {
+        let local_set = tokio::task::LocalSet::new();
+        local_set
+            .run_until(
+                lua.load(
+                    r#"
+                local cnt = 0
+                timer(1, 100, function()
+                    cnt = cnt + 1
+                    if cnt % 10 == 0 then
+                        collectgarbage()
+                    end
+                end)
+                "#,
+                )
+                .exec_async(),
+            )
+            .await?;
+        local_set.await;
+    }
+
+    // Consume the Lua instance
+    unsafe { Lua::from_static(lua) };
+
+    Ok(())
+}

tests/string.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::collections::HashSet;
 
 use mlua::{Lua, Result, String};
 
@@ -67,3 +68,33 @@ fn test_raw_string() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_string_hash() -> Result<()> {
+    let lua = Lua::new();
+
+    let set: HashSet<String> = lua.load(r#"{"hello", "world", "abc", 321}"#).eval()?;
+    assert_eq!(set.len(), 4);
+    assert!(set.contains(b"hello".as_ref()));
+    assert!(set.contains(b"world".as_ref()));
+    assert!(set.contains(b"abc".as_ref()));
+    assert!(set.contains(b"321".as_ref()));
+    assert!(!set.contains(b"Hello".as_ref()));
+
+    Ok(())
+}
+
+#[test]
+fn test_string_debug() -> Result<()> {
+    let lua = Lua::new();
+
+    // Valid utf8
+    let s = lua.create_string("hello")?;
+    assert_eq!(format!("{s:?}"), r#""hello""#);
+
+    // Invalid utf8
+    let s = lua.create_string(b"hello\0world\r\n\t\xF0\x90\x80")?;
+    assert_eq!(format!("{s:?}"), r#"b"hello\0world\r\n\t\xf0\x90\x80""#);
+
+    Ok(())
+}

tests/table.rs

@@ -109,6 +109,96 @@ fn test_table() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_table_push_pop() -> Result<()> {
+    let lua = Lua::new();
+
+    // Test raw access
+    let table1 = lua.create_sequence_from(vec![123])?;
+    table1.raw_push(321)?;
+    assert_eq!(
+        table1
+            .clone()
+            .raw_sequence_values::<i64>()
+            .collect::<Result<Vec<_>>>()?,
+        vec![123, 321]
+    );
+    assert_eq!(table1.raw_pop::<i64>()?, 321);
+    assert_eq!(table1.raw_pop::<i64>()?, 123);
+    assert_eq!(table1.raw_pop::<Value>()?, Value::Nil); // An extra pop should do nothing
+    assert_eq!(table1.raw_len(), 0);
+
+    // Test access through metamethods
+    let table2 = lua
+        .load(
+            r#"
+        local proxy_table = {234}
+        table2 = setmetatable({}, {
+            __len = function() return #proxy_table end,
+            __index = proxy_table,
+            __newindex = proxy_table,
+        })
+        return table2
+    "#,
+        )
+        .eval::<Table>()?;
+    table2.push(345)?;
+    assert_eq!(table2.len()?, 2);
+    assert_eq!(table2.pop::<i64>()?, 345);
+    assert_eq!(table2.pop::<i64>()?, 234);
+    assert_eq!(table2.pop::<Value>()?, Value::Nil);
+    assert_eq!(table2.len()?, 0);
+
+    Ok(())
+}
+
+#[test]
+fn test_table_clear() -> Result<()> {
+    let lua = Lua::new();
+
+    // Check readonly error
+    #[cfg(feature = "luau")]
+    {
+        let t = lua.create_table()?;
+        t.set_readonly(true);
+        assert!(matches!(
+            t.clear(),
+            Err(Error::RuntimeError(err)) if err.contains("attempt to modify a readonly table")
+        ));
+    }
+
+    let t = lua.create_table()?;
+    // Set array and hash parts
+    t.push("abc")?;
+    t.push("bcd")?;
+    t.set("a", "1")?;
+    t.set("b", "2")?;
+    t.clear()?;
+    assert_eq!(t.len()?, 0);
+    assert_eq!(t.pairs::<Value, Value>().count(), 0);
+
+    // Test table with metamethods
+    let t2 = lua
+        .load(
+            r#"
+        setmetatable({1, 2, 3, a = "1"}, {
+            __index = function() error("index error") end,
+            __newindex = function() error("newindex error") end,
+            __len = function() error("len error") end,
+            __pairs = function() error("pairs error") end,
+        })
+    "#,
+        )
+        .eval::<Table>()?;
+    assert_eq!(t2.raw_len(), 3);
+    t2.clear()?;
+    assert_eq!(t2.raw_len(), 0);
+    assert_eq!(t2.raw_get::<_, Value>("a")?, Value::Nil);
+    assert_ne!(t2.get_metatable(), None);
+
+    Ok(())
+}
+
 #[test]
 fn test_table_sequence_from() -> Result<()> {
     let lua = Lua::new();

tests/tests.rs

@@ -73,6 +73,7 @@ fn test_load() -> Result<()> {
     let result: i32 = func.call(())?;
     assert_eq!(result, 3);
 
+    assert!(lua.load("").exec().is_ok());
     assert!(lua.load("§$%§&$%&").exec().is_err());
 
     Ok(())
@@ -275,7 +276,10 @@ fn test_error() -> Result<()> {
             end, 3)
 
             local function handler(err)
-                if string.match(_VERSION, ' 5%.1$') or string.match(_VERSION, ' 5%.2$') or _VERSION == "Luau" then
+                if string.match(_VERSION, " 5%.1$")
+                    or string.match(_VERSION, " 5%.2$")
+                    or string.match(_VERSION, "Luau")
+                then
                     -- Special case for Lua 5.1/5.2 and Luau
                     local caps = string.match(err, ': (%d+)$')
                     if caps then
@@ -304,7 +308,7 @@ fn test_error() -> Result<()> {
     .exec()?;
 
     let rust_error_function =
-        lua.create_function(|_, ()| -> Result<()> { Err(TestError.to_lua_err()) })?;
+        lua.create_function(|_, ()| -> Result<()> { Err(TestError.into_lua_err()) })?;
     globals.set("rust_error_function", rust_error_function)?;
 
     let no_error = globals.get::<_, Function>("no_error")?;
@@ -502,7 +506,7 @@ fn test_result_conversions() -> Result<()> {
 
     let err = lua.create_function(|_, ()| {
         Ok(Err::<String, _>(
-            "only through failure can we succeed".to_lua_err(),
+            "only through failure can we succeed".into_lua_err(),
         ))
     })?;
     let ok = lua.create_function(|_, ()| Ok(Ok::<_, Error>("!".to_owned())))?;
@@ -560,7 +564,12 @@ fn test_num_conversion() -> Result<()> {
     assert_eq!(lua.load("1.0").eval::<f64>()?, 1.0);
     #[cfg(any(feature = "lua54", feature = "lua53"))]
     assert_eq!(lua.load("1.0").eval::<String>()?, "1.0");
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
+    #[cfg(any(
+        feature = "lua52",
+        feature = "lua51",
+        feature = "luajit",
+        feature = "luau"
+    ))]
     assert_eq!(lua.load("1.0").eval::<String>()?, "1");
 
     assert_eq!(lua.load("1.5").eval::<i64>()?, 1);
@@ -721,9 +730,9 @@ fn test_set_metatable_nil() -> Result<()> {
 fn test_named_registry_value() -> Result<()> {
     let lua = Lua::new();
 
-    lua.set_named_registry_value::<_, i32>("test", 42)?;
+    lua.set_named_registry_value::<i32>("test", 42)?;
     let f = lua.create_function(move |lua, ()| {
-        assert_eq!(lua.named_registry_value::<_, i32>("test")?, 42);
+        assert_eq!(lua.named_registry_value::<i32>("test")?, 42);
         Ok(())
     })?;
 
@@ -787,6 +796,17 @@ fn test_replace_registry_value() -> Result<()> {
     let key = lua.create_registry_value::<i32>(42)?;
     lua.replace_registry_value(&key, "new value")?;
     assert_eq!(lua.registry_value::<String>(&key)?, "new value");
+    lua.replace_registry_value(&key, Value::Nil)?;
+    assert_eq!(lua.registry_value::<Value>(&key)?, Value::Nil);
+    lua.replace_registry_value(&key, 123)?;
+    assert_eq!(lua.registry_value::<i32>(&key)?, 123);
+
+    // It should be impossible to replace (initial) nil value with non-nil
+    let key2 = lua.create_registry_value(Value::Nil)?;
+    match lua.replace_registry_value(&key2, "abc") {
+        Err(Error::RuntimeError(_)) => {}
+        r => panic!("expected RuntimeError, got {r:?}"),
+    }
 
     Ok(())
 }
@@ -838,6 +858,28 @@ fn test_mismatched_registry_key() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_registry_value_reuse() -> Result<()> {
+    let lua = Lua::new();
+
+    let r1 = lua.create_registry_value("value1")?;
+    let r1_slot = format!("{r1:?}");
+    drop(r1);
+
+    // Previous slot must not be reused by nil value
+    let r2 = lua.create_registry_value(Value::Nil)?;
+    let r2_slot = format!("{r2:?}");
+    assert_ne!(r1_slot, r2_slot);
+    drop(r2);
+
+    // But should be reused by non-nil value
+    let r3 = lua.create_registry_value("value3")?;
+    let r3_slot = format!("{r3:?}");
+    assert_eq!(r1_slot, r3_slot);
+
+    Ok(())
+}
+
 #[test]
 fn test_application_data() -> Result<()> {
     let lua = Lua::new();
@@ -1030,7 +1072,7 @@ fn test_chunk_env() -> Result<()> {
         test_var = 1
     "#,
     )
-    .set_environment(env1.clone())?
+    .set_environment(env1.clone())
     .exec()?;
 
     lua.load(
@@ -1039,18 +1081,11 @@ fn test_chunk_env() -> Result<()> {
         test_var = 2
     "#,
     )
-    .set_environment(env2.clone())?
+    .set_environment(env2.clone())
     .exec()?;
 
-    assert_eq!(
-        lua.load("test_var").set_environment(env1)?.eval::<i32>()?,
-        1
-    );
-
-    assert_eq!(
-        lua.load("test_var").set_environment(env2)?.eval::<i32>()?,
-        2
-    );
+    assert_eq!(lua.load("test_var").set_environment(env1).eval::<i32>()?, 1);
+    assert_eq!(lua.load("test_var").set_environment(env2).eval::<i32>()?, 2);
 
     Ok(())
 }
@@ -1185,7 +1220,7 @@ fn test_inspect_stack() -> Result<()> {
         assert(logline("world") == '[string "chunk"]:12 world')
     "#,
     )
-    .set_name("chunk")?
+    .set_name("chunk")
     .exec()?;
 
     Ok(())
@@ -1272,3 +1307,14 @@ fn test_luajit_cdata() {
         )
         .eval();
 }
+
+#[test]
+#[cfg(feature = "send")]
+fn test_send() {
+    let lua = Lua::new();
+    std::thread::spawn(move || {
+        let _lua = lua;
+    })
+    .join()
+    .unwrap();
+}

tests/userdata.rs

@@ -1,4 +1,10 @@
-use std::sync::{Arc, Mutex, RwLock};
+use std::string::String as StdString;
+use std::sync::Arc;
+#[cfg(not(feature = "parking_lot"))]
+use std::sync::{Mutex, RwLock};
+
+#[cfg(feature = "parking_lot")]
+use parking_lot::{Mutex, RwLock};
 
 #[cfg(not(feature = "send"))]
 use std::{cell::RefCell, rc::Rc};
@@ -7,12 +13,12 @@ use std::{cell::RefCell, rc::Rc};
 use std::sync::atomic::{AtomicI64, Ordering};
 
 use mlua::{
-    AnyUserData, Error, ExternalError, Function, Lua, MetaMethod, Nil, Result, String, UserData,
-    UserDataFields, UserDataMethods, Value,
+    AnyUserData, AnyUserDataExt, Error, ExternalError, Function, Lua, MetaMethod, Nil, Result,
+    String, UserData, UserDataFields, UserDataMethods, UserDataRef, Value,
 };
 
 #[test]
-fn test_user_data() -> Result<()> {
+fn test_userdata() -> Result<()> {
     struct UserData1(i64);
     struct UserData2(Box<i64>);
 
@@ -95,20 +101,25 @@ fn test_metamethods() -> Result<()> {
             methods.add_method("get", |_, data, ()| Ok(data.0));
             methods.add_meta_function(
                 MetaMethod::Add,
-                |_, (lhs, rhs): (MyUserData, MyUserData)| Ok(MyUserData(lhs.0 + rhs.0)),
+                |_, (lhs, rhs): (UserDataRef<Self>, UserDataRef<Self>)| {
+                    Ok(MyUserData(lhs.0 + rhs.0))
+                },
             );
             methods.add_meta_function(
                 MetaMethod::Sub,
-                |_, (lhs, rhs): (MyUserData, MyUserData)| Ok(MyUserData(lhs.0 - rhs.0)),
+                |_, (lhs, rhs): (UserDataRef<Self>, UserDataRef<Self>)| {
+                    Ok(MyUserData(lhs.0 - rhs.0))
+                },
+            );
+            methods.add_meta_function(
+                MetaMethod::Eq,
+                |_, (lhs, rhs): (UserDataRef<Self>, UserDataRef<Self>)| Ok(lhs.0 == rhs.0),
             );
-            methods.add_meta_function(MetaMethod::Eq, |_, (lhs, rhs): (MyUserData, MyUserData)| {
-                Ok(lhs.0 == rhs.0)
-            });
             methods.add_meta_method(MetaMethod::Index, |_, data, index: String| {
                 if index.to_str()? == "inner" {
                     Ok(data.0)
                 } else {
-                    Err("no such custom index".to_lua_err())
+                    Err("no such custom index".into_lua_err())
                 }
             });
             #[cfg(any(
@@ -119,13 +130,14 @@ fn test_metamethods() -> Result<()> {
             ))]
             methods.add_meta_method(MetaMethod::Pairs, |lua, data, ()| {
                 use std::iter::FromIterator;
-                let stateless_iter = lua.create_function(|_, (data, i): (MyUserData, i64)| {
-                    let i = i + 1;
-                    if i <= data.0 {
-                        return Ok(mlua::Variadic::from_iter(vec![i, i]));
-                    }
-                    return Ok(mlua::Variadic::new());
-                })?;
+                let stateless_iter =
+                    lua.create_function(|_, (data, i): (UserDataRef<Self>, i64)| {
+                        let i = i + 1;
+                        if i <= data.0 {
+                            return Ok(mlua::Variadic::from_iter(vec![i, i]));
+                        }
+                        return Ok(mlua::Variadic::new());
+                    })?;
                 Ok((stateless_iter, data.clone(), 0))
             });
         }
@@ -137,7 +149,9 @@ fn test_metamethods() -> Result<()> {
     globals.set("userdata2", MyUserData(3))?;
     globals.set("userdata3", MyUserData(3))?;
     assert_eq!(
-        lua.load("userdata1 + userdata2").eval::<MyUserData>()?.0,
+        lua.load("userdata1 + userdata2")
+            .eval::<UserDataRef<MyUserData>>()?
+            .0,
         10
     );
 
@@ -161,7 +175,12 @@ fn test_metamethods() -> Result<()> {
         )
         .eval::<Function>()?;
 
-    assert_eq!(lua.load("userdata1 - userdata2").eval::<MyUserData>()?.0, 4);
+    assert_eq!(
+        lua.load("userdata1 - userdata2")
+            .eval::<UserDataRef<MyUserData>>()?
+            .0,
+        4
+    );
     assert_eq!(lua.load("userdata1:get()").eval::<i64>()?, 7);
     assert_eq!(lua.load("userdata2.inner").eval::<i64>()?, 3);
     assert!(lua.load("userdata2.nonexist_field").eval::<()>().is_err());
@@ -300,21 +319,19 @@ fn test_userdata_take() -> Result<()> {
     fn check_userdata_take(lua: &Lua, userdata: AnyUserData, rc: Arc<i64>) -> Result<()> {
         lua.globals().set("userdata", userdata.clone())?;
         assert_eq!(Arc::strong_count(&rc), 3);
-        let userdata_copy = userdata.clone();
         {
             let _value = userdata.borrow::<MyUserdata>()?;
             // We should not be able to take userdata if it's borrowed
-            match userdata_copy.take::<MyUserdata>() {
+            match userdata.take::<MyUserdata>() {
                 Err(Error::UserDataBorrowMutError) => {}
                 r => panic!("expected `UserDataBorrowMutError` error, got {:?}", r),
             }
         }
 
-        let value = userdata_copy.take::<MyUserdata>()?;
+        let value = userdata.take::<MyUserdata>()?;
         assert_eq!(*value.0, 18);
         drop(value);
-        lua.gc_collect()?;
-        assert_eq!(Arc::strong_count(&rc), 1);
+        assert_eq!(Arc::strong_count(&rc), 2);
 
         match userdata.borrow::<MyUserdata>() {
             Err(Error::UserDataDestructed) => {}
@@ -327,6 +344,13 @@ fn test_userdata_take() -> Result<()> {
             },
             r => panic!("improper return for destructed userdata: {:?}", r),
         }
+
+        drop(userdata);
+        lua.globals().raw_remove("userdata")?;
+        lua.gc_collect()?;
+        lua.gc_collect()?;
+        assert_eq!(Arc::strong_count(&rc), 1);
+
         Ok(())
     }
 
@@ -398,9 +422,9 @@ fn test_user_values() -> Result<()> {
     ud.set_named_user_value("name", "alex")?;
     ud.set_named_user_value("age", 10)?;
 
-    assert_eq!(ud.get_named_user_value::<_, String>("name")?, "alex");
-    assert_eq!(ud.get_named_user_value::<_, i32>("age")?, 10);
-    assert_eq!(ud.get_named_user_value::<_, Value>("nonexist")?, Value::Nil);
+    assert_eq!(ud.get_named_user_value::<String>("name")?, "alex");
+    assert_eq!(ud.get_named_user_value::<i32>("age")?, 10);
+    assert_eq!(ud.get_named_user_value::<Value>("nonexist")?, Value::Nil);
 
     Ok(())
 }
@@ -524,7 +548,7 @@ fn test_metatable() -> Result<()> {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
             methods.add_function("my_type_name", |_, data: AnyUserData| {
                 let metatable = data.get_metatable()?;
-                metatable.get::<_, String>("__type_name")
+                metatable.get::<String>("__type_name")
             });
         }
     }
@@ -542,7 +566,7 @@ fn test_metatable() -> Result<()> {
     let ud: AnyUserData = globals.get("ud")?;
     let metatable = ud.get_metatable()?;
 
-    match metatable.get::<_, Value>("__gc") {
+    match metatable.get::<Value>("__gc") {
         Ok(_) => panic!("expected MetaMethodRestricted, got no error"),
         Err(Error::MetaMethodRestricted(_)) => {}
         Err(e) => panic!("expected MetaMethodRestricted, got {:?}", e),
@@ -556,11 +580,10 @@ fn test_metatable() -> Result<()> {
 
     let mut methods = metatable
         .pairs()
-        .into_iter()
         .map(|kv: Result<(_, Value)>| Ok(kv?.0))
         .collect::<Result<Vec<_>>>()?;
-    methods.sort_by_cached_key(|k| k.name().to_owned());
-    assert_eq!(methods, vec![MetaMethod::Index, "__type_name".into()]);
+    methods.sort();
+    assert_eq!(methods, vec!["__index", "__type_name"]);
 
     #[derive(Copy, Clone)]
     struct MyUserData2(i64);
@@ -623,7 +646,10 @@ fn test_userdata_wrapped() -> Result<()> {
     "#,
     )
     .exec()?;
+    #[cfg(not(feature = "parking_lot"))]
     assert_eq!(ud2.lock().unwrap().0, 3);
+    #[cfg(feature = "parking_lot")]
+    assert_eq!(ud2.lock().0, 3);
 
     let ud3 = Arc::new(RwLock::new(MyUserData(3)));
     globals.set("arc_rwlock_ud", ud3.clone())?;
@@ -634,7 +660,10 @@ fn test_userdata_wrapped() -> Result<()> {
     "#,
     )
     .exec()?;
+    #[cfg(not(feature = "parking_lot"))]
     assert_eq!(ud3.read().unwrap().0, 4);
+    #[cfg(feature = "parking_lot")]
+    assert_eq!(ud3.read().0, 4);
 
     // Test drop
     globals.set("arc_mutex_ud", Nil)?;
@@ -645,3 +674,149 @@ fn test_userdata_wrapped() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_userdata_proxy() -> Result<()> {
+    struct MyUserData(i64);
+
+    impl UserData for MyUserData {
+        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field_function_get("static_field", |_, _| Ok(123));
+            fields.add_field_method_get("n", |_, this| Ok(this.0));
+        }
+
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_function("new", |_, n| Ok(Self(n)));
+
+            methods.add_method("plus", |_, this, n: i64| Ok(this.0 + n));
+        }
+    }
+
+    let lua = Lua::new();
+    let globals = lua.globals();
+    globals.set("MyUserData", lua.create_proxy::<MyUserData>()?)?;
+
+    lua.load(
+        r#"
+        assert(MyUserData.static_field == 123)
+        local data = MyUserData.new(321)
+        assert(data.static_field == 123)
+        assert(data.n == 321)
+        assert(data:plus(1) == 322)
+
+        -- Error when accessing the proxy object fields and methods that require instance
+
+        local ok = pcall(function() return MyUserData.n end)
+        assert(not ok)
+
+        ok = pcall(function() return MyUserData:plus(1) end)
+        assert(not ok)
+    "#,
+    )
+    .exec()
+}
+
+#[test]
+fn test_any_userdata() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.register_userdata_type::<StdString>(|reg| {
+        reg.add_method("get", |_, this, ()| Ok(this.clone()));
+        reg.add_method_mut("concat", |_, this, s: String| {
+            this.push_str(&s.to_string_lossy());
+            Ok(())
+        });
+    })?;
+
+    let ud = lua.create_any_userdata("hello".to_string())?;
+    assert_eq!(&*ud.borrow::<StdString>()?, "hello");
+
+    lua.globals().set("ud", ud)?;
+    lua.load(
+        r#"
+        assert(ud:get() == "hello")
+        ud:concat(", world")
+        assert(ud:get() == "hello, world")
+    "#,
+    )
+    .exec()
+    .unwrap();
+
+    Ok(())
+}
+
+#[test]
+fn test_userdata_ext() -> Result<()> {
+    let lua = Lua::new();
+
+    #[derive(Clone, Copy)]
+    struct MyUserData(u32);
+
+    impl UserData for MyUserData {
+        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field_method_get("n", |_, this| Ok(this.0));
+            fields.add_field_method_set("n", |_, this, val| {
+                this.0 = val;
+                Ok(())
+            });
+        }
+
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_meta_method(MetaMethod::Call, |_, _this, ()| Ok("called"));
+            methods.add_method_mut("add", |_, this, x: u32| {
+                this.0 += x;
+                Ok(())
+            });
+        }
+    }
+
+    let ud = lua.create_userdata(MyUserData(123))?;
+
+    assert_eq!(ud.get::<_, u32>("n")?, 123);
+    ud.set("n", 321)?;
+    assert_eq!(ud.get::<_, u32>("n")?, 321);
+    match ud.get::<_, u32>("non-existent") {
+        Err(Error::RuntimeError(_)) => {}
+        r => panic!("expected RuntimeError, got {r:?}"),
+    }
+    match ud.set::<_, u32>("non-existent", 123) {
+        Err(Error::RuntimeError(_)) => {}
+        r => panic!("expected RuntimeError, got {r:?}"),
+    }
+
+    assert_eq!(ud.call::<_, String>(())?, "called");
+
+    ud.call_method("add", 2)?;
+    assert_eq!(ud.get::<_, u32>("n")?, 323);
+
+    Ok(())
+}
+
+#[test]
+fn test_userdata_method_errors() -> Result<()> {
+    struct MyUserData(i64);
+
+    impl UserData for MyUserData {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_method("get_value", |_, data, ()| Ok(data.0));
+        }
+    }
+
+    let lua = Lua::new();
+
+    let ud = lua.create_userdata(MyUserData(123))?;
+    let res = ud.call_function::<_, ()>("get_value", ());
+    let Err(Error::CallbackError { cause, .. }) = res else {
+        panic!("expected CallbackError, got {res:?}");
+    };
+    assert!(matches!(
+        &*cause,
+        Error::BadArgument {
+            to,
+            name,
+            ..
+        } if to.as_deref() == Some("MyUserData.get_value") && name.as_deref() == Some("self")
+    ));
+
+    Ok(())
+}

tests/value.rs

@@ -1,4 +1,6 @@
-use mlua::{Lua, Result, Value};
+use std::ptr;
+
+use mlua::{Lua, MultiValue, Result, Value};
 
 #[test]
 fn test_value_eq() -> Result<()> {
@@ -41,17 +43,41 @@ fn test_value_eq() -> Result<()> {
     let thread2: Value = globals.get("thread2")?;
 
     assert!(table1 != table2);
-    assert!(table1.equals(table2)?);
+    assert!(table1.equals(&table2)?);
     assert!(string1 == string2);
-    assert!(string1.equals(string2)?);
+    assert!(string1.equals(&string2)?);
     assert!(num1 == num2);
     assert!(num1.equals(num2)?);
     assert!(num1 != num3);
     assert!(func1 == func2);
     assert!(func1 != func3);
-    assert!(!func1.equals(func3)?);
+    assert!(!func1.equals(&func3)?);
     assert!(thread1 == thread2);
-    assert!(thread1.equals(thread2)?);
+    assert!(thread1.equals(&thread2)?);
+
+    assert!(!table1.to_pointer().is_null());
+    assert!(!ptr::eq(table1.to_pointer(), table2.to_pointer()));
+    assert!(ptr::eq(string1.to_pointer(), string2.to_pointer()));
+    assert!(ptr::eq(func1.to_pointer(), func2.to_pointer()));
+    assert!(num1.to_pointer().is_null());
 
     Ok(())
 }
+
+#[test]
+fn test_multi_value() {
+    let mut multi_value = MultiValue::new();
+    assert_eq!(multi_value.len(), 0);
+    assert_eq!(multi_value.get(0), None);
+
+    multi_value.push_front(Value::Number(2.));
+    multi_value.push_front(Value::Number(1.));
+    assert_eq!(multi_value.get(0), Some(&Value::Number(1.)));
+    assert_eq!(multi_value.get(1), Some(&Value::Number(2.)));
+
+    assert_eq!(multi_value.pop_front(), Some(Value::Number(1.)));
+    assert_eq!(multi_value[0], Value::Number(2.));
+
+    multi_value.clear();
+    assert!(multi_value.is_empty());
+}