v0.11.4

This option would allow detecting mixed tables (with array-like and map-like entries or several borders)
to encoding them chosing the best method (as a map or as a table).

.github/workflows/coverage.yml

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

.github/workflows/main.yml

@@ -7,35 +7,35 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
         include:
-        - os: ubuntu-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-latest
+            target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
     steps:
-    - uses: actions/checkout@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,parking_lot"
-      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@main
+      - 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,serde,macros,anyhow,userdata-wrappers"
+          cargo build --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers,send"
+        shell: bash
+      - name: Build ${{ matrix.lua }} pkg-config
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends liblua5.4-dev liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
+          cargo build --features "${{ matrix.lua }}"
 
   build_aarch64_cross_macos:
     name: Cross-compile to aarch64-apple-darwin
@@ -45,60 +45,57 @@ jobs:
       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,parking_lot"
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: aarch64-apple-darwin
+      - name: Cross-compile
+        run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serde,macros,anyhow,userdata-wrappers"
 
   build_aarch64_cross_ubuntu:
     name: Cross-compile to aarch64-unknown-linux-gnu
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-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-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,parking_lot"
-      shell: bash
+      - uses: actions/checkout@main
+      - 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,serde,macros,anyhow,userdata-wrappers"
+        shell: bash
 
   build_armv7_cross_ubuntu:
     name: Cross-compile to armv7-unknown-linux-gnueabihf
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     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,parking_lot"
-      shell: bash
+      - uses: actions/checkout@main
+      - 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,serde,macros,anyhow,userdata-wrappers"
+        shell: bash
 
   test:
     name: Test
@@ -106,35 +103,35 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau, luau-jit, luau-vector4]
         include:
-        - os: ubuntu-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-latest
+            target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
     steps:
-    - uses: actions/checkout@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,parking_lot"
-      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" -- --ignored
-      shell: bash
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Run ${{ matrix.lua }} tests
+        run: |
+          cargo test --features "${{ matrix.lua }},vendored"
+          cargo test --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers"
+          cargo test --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers,send"
+        shell: bash
+      - name: Run compile tests (macos lua54)
+        if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua54' }}
+        run: |
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored" --tests -- --ignored
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serde,macros" --tests -- --ignored
+        shell: bash
 
   test_with_sanitizer:
     name: Test with address sanitizer
@@ -142,25 +139,52 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-20.04]
+        os: [ubuntu-latest]
         rust: [nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
         include:
-        - os: ubuntu-20.04
-          target: x86_64-unknown-linux-gnu
+          - os: ubuntu-latest
+            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,parking_lot" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
-      shell: bash
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Run ${{ matrix.lua }} tests with address sanitizer
+        run: |
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers,send" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+        shell: bash
+        env:
+          RUSTFLAGS: -Z sanitizer=address
+
+  test_with_memory_limit:
+    name: Test with memory limit
+    runs-on: ${{ matrix.os }}
+    needs: build
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        rust: [nightly]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+    steps:
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Run ${{ matrix.lua }} tests with forced memory limit
+        run: |
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serde,macros,anyhow,userdata-wrappers"
+        shell: bash
+        env:
+          RUSTFLAGS: --cfg=force_memory_limit
 
   test_modules:
     name: Test modules
@@ -168,27 +192,26 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-latest]
+        os: [ubuntu-latest, 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-latest
+            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 tests/module && cargo build --release --features "${{ matrix.lua }}")
-        (cd tests/module/loader && cargo test --release --features "${{ matrix.lua }},vendored")
-      shell: bash
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Run ${{ matrix.lua }} 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 +224,61 @@ 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 tests/module && cargo build --release --features "${{ matrix.lua }}")
-        (cd tests/module/loader && cargo test --release --features "${{ matrix.lua }}")
+      - uses: msys2/setup-msys2@v2
+      - uses: actions/checkout@main
+      - name: Install Rust & Lua
+        run: |
+          pacman -S --noconfirm mingw-w64-x86_64-rust mingw-w64-x86_64-lua mingw-w64-x86_64-luajit mingw-w64-x86_64-pkg-config
+      - 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 }}")
+
+  test_wasm32_emscripten:
+    name: Test on wasm32-unknown-emscripten
+    runs-on: ubuntu-latest
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua54, lua53, lua52, lua51, luau]
+    steps:
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: wasm32-unknown-emscripten
+      - name: Install Emscripten
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends emscripten
+      - name: Run ${{ matrix.lua }} tests
+        run: |
+          cargo test --tests --features "${{ matrix.lua }},vendored"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers"
 
   rustfmt:
     name: Rustfmt
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        components: rustfmt
-        override: true
-    - run: cargo fmt -- --check
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt
+      - run: cargo fmt -- --check
 
   clippy:
-    name: Clippy check
-    runs-on: ubuntu-20.04
+    name: Clippy
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@main
+      - uses: dtolnay/rust-toolchain@stable
         with:
-            toolchain: nightly
-            components: clippy
-            override: true
-      - uses: actions-rs/clippy-check@v1
+          toolchain: nightly
+          components: clippy
+      - uses: giraffate/clippy-action@v1
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+          reporter: 'github-pr-review'
+          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serde,macros,anyhow,userdata-wrappers"

.github/workflows/typos.yml

@@ -0,0 +1,17 @@
+name: Typos Check
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  run:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout Actions Repository
+      uses: actions/checkout@v4
+
+    - name: Check spelling
+      uses: crate-ci/typos@master
+      with:
+        config: ./typos.toml

.gitignore

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

CHANGELOG.md

@@ -1,3 +1,393 @@
+## v0.11.4 (Sep 29, 2025)
+
+- Make `Value::to_serializable` public
+- Add new serde option `detect_mixed_tables` (to encode mixed array+map tables)
+- Add `ObjectLike::get_path` helper (for tables and userdata)
+
+## v0.11.3 (Aug 30, 2025)
+
+- Add `Lua::yield_with` to use as `coroutine.yield` functional replacement in async functions for any Lua
+- Do not try to yield at non-yielable points in Luau interrupt (#632)
+- Add `Buffer::cursor` method (Luau)
+- Add `Lua::create_buffer_with_capacity` method (Luau)
+- Make Lua reference values cheap to clone (only increments ref count)
+- Fix panic on large (>67M entries) table creation
+
+## v0.11.2 (Aug 10, 2025)
+
+- Faster stack push for `Variadic<T>`
+- Fix handling Windows paths with drive letter in Luau require (#623)
+- Make Luau registered aliases ascii case-insensitive (#620)
+- Fix deserializing negative zeros `-0.0` (#618)
+
+## v0.11.1 (Jul 15, 2025)
+
+- Fixed bug exhausting Lua auxiliary stack and leaving it without reserve (#615)
+- `Lua::push_c_function` now correctly handles OOM for Lua 5.1 and Luau
+
+## v0.11.0 (Jul 14, 2025)
+
+Changes since v0.11.0-beta.3
+
+- Allow linking external Lua libraries in a build script (e.g. pluto) using `external` mlua-sys feature flag
+- `Lua::inspect_stack` takes a callback with `&Debug` argument, instead of returning `Debug` directly
+- Added `Debug::function` method to get function running at a given level
+- `Debug::curr_line` is deprecated in favour of `Debug::current_line` that returns `Option<usize>`
+- Added `Lua::set_globals` method to replace global environment
+- `Table::set_metatable` now returns `Result<()>` (this operation can fail in sandboxed Luau mode)
+- `impl ToString` replaced with `Into<StdString>`  in `UserData` registration
+- `Value::as_str` and `Value::as_string_lossy` methods are deprecated (as they are non-idiomatic)
+- Bugfixes and improvements
+
+## v0.11.0-beta.3 (Jun 23, 2025)
+
+- Luau in sandboxed mode has reduced options in `collectgarbage` function (to follow the official doc)
+- `Function::deep_clone` now returns `Result<Function>` as this operation can trigger memory errors
+- Luau "Require" resolves included Lua files relative to the current directory (#605)
+- Fixed bug when finalizing `AsyncThread` on drop (`call_async` methods family)
+
+## v0.11.0-beta.2 (Jun 12, 2025)
+
+- Lua 5.4 updated to 5.4.8
+- Terminate Rust `Future` when `AsyncThread` is dropped (without relying on Lua GC)
+- Added `loadstring` function to Luau
+- Make `AsChunk` trait dyn-friendly
+- Luau `Require` trait synced with Luau 0.674
+- Luau `Require` trait methods now can return `Error` variant (in `NavigateError` enum)
+- Added `__type` to `Error`'s userdata metatable (for `typeof` function)
+- `parking_log/send_guard` is moved to `userdata-wrappers` feature flag
+- New `serde` feature flag to replace `serialize` (the old one is still available)
+
+## v0.11.0-beta.1 (May 7th, 2025)
+
+- New "require-by-string" for Luau (with `Require` trait and async support)
+- Added `Thread::resume_error` support for Luau
+- 52 bit integers support for Luau (this is a breaking change)
+- New features for Luau compiler (constants, disabled builtins, known members)
+- `AsyncThread<A, R>` changed to `AsyncThread<R>` (`A` pushed to stack immediately)
+- Lifetime `'a` moved from `AsChunk<'a>` to `AsChunk::source where Self: 'a`
+- `Lua::scope` pass `&Scope` instead of `&mut Scope` to closure
+- Added global hooks support (Lua 5.1+)
+- Added per-thread hooks support (Lua 5.1+)
+- `Lua::init_from_ptr` renamed to `Lua::get_or_init_from_ptr` and returns `&Lua`
+- `Lua:load_from_function` is deprecated (this is `register_module` now)
+- Added `Lua::register_module` and `Lua::preload_module`
+
+## v0.10.4 (May 5th, 2025)
+
+- Luau updated to 0.672
+- New serde option `encode_empty_tables_as_array` to serialize empty tables as arrays
+- Added `WeakLua` and `Lua::weak()` to create weak references to Lua state
+- Trigger abort when Luau userdata destructors are panic (Luau GC does not support it)
+- Added `AnyUserData::type_id()` method to get the type id of the userdata
+- Added `Chunk::name()`, `Chunk::environment()` and `Chunk::mode()` functions
+- Support borrowing underlying wrapped types for `UserDataRef` and `UserDataRefMut` (under `userdata-wrappers` feature)
+- Added large (52bit) integers support for Luau
+- Enable `serde` for `bstr` if `serialize` feature flag is enabled
+- Recursive warnings (Lua 5.4) are no longer allowed
+- Implemented `IntoLua`/`FromLua` for `BorrowedString` and `BorrowedBytes`
+- Implemented `IntoLua`/`FromLua` for `char`
+- Enable `Thread::reset()` for all Lua versions (limited support for 5.1-5.3)
+- Bugfixes and improvements
+
+## v0.10.3 (Jan 27th, 2025)
+
+- Set `Default` for `Value` to be `Nil`
+- Allow exhaustive match on `Value` (#502)
+- Add `Table::set_safeenv` method (Luau)
+
+## v0.10.2 (Dec 1st, 2024)
+
+- Switch proc-macro-error to proc-macro-error2 (#493)
+- Do not allow Lua to run GC finalizers on ref thread (#491)
+- Fix chunks loading in Luau when memory limit is enforced (#488)
+- Added `String::wrap` method to wrap arbitrary `AsRef<[u8]>` into `impl IntoLua`
+- Better FreeBSD/OpenBSD support (thanks to cos)
+- Delay "any" userdata metatable creation until first instance is created (#482)
+- Reduce amount of generated code for `UserData` (less generics)
+
+## v0.10.1 (Nov 9th, 2024)
+
+- Minimal Luau updated to 0.650
+- Added Luau native vector library support (this can change behavior if you use `vector` function!)
+- Added Lua `String::display` method
+- Improved pretty-printing for Lua tables (#478)
+- Added `Scope::create_any_userdata` to create Lua objects from any non-`'static` Rust types
+- Added `AnyUserData::destroy` method
+- New `userdata-wrappers` feature to `impl UserData` for `Rc<T>`/`Arc<T>`/`Rc<RefCell<T>>`/`Arc<Mutex<T>>` (similar to v0.9)
+- `UserDataRef` in `send` mode now uses shared lock if `T: Sync` (and exclusive lock otherwise)
+- Added `Scope::add_destructor` to attach custom destructors
+- Added `Lua::try_app_data_ref` and `Lua::try_app_data_mut` methods
+- Added `From<Vec>` and `Into<Vec>` support to `MultiValue` and `Variadic` types
+- Bug fixes and improvements (#477 #479)
+
+## v0.10.0 (Oct 25th, 2024)
+
+Changes since v0.10.0-rc.1
+
+- Added `error-send` feature flag (disabled by default) to require `Send + Sync` for `Error`
+- Some performance improvements
+
+## v0.10.0-rc.1
+
+- `Lua::scope` is back
+- Support yielding from hooks for Lua 5.3+
+- Support setting metatable for Lua builtin types (number/string/function/etc)
+- Added `LuaNativeFn`/`LuaNativeFnMut`/`LuaNativeAsyncFn` traits for using in `Function::wrap`
+- Added `Error::chain` method to return iterator over nested errors
+- Added `Lua::exec_raw` helper to execute low-level Lua C API code
+- Added `Either<L, R>` enum to combine two types into a single one
+- Added a new `Buffer` type for Luau
+- Added `Value::is_error` and `Value::as_error` helpers
+- Added `Value::Other` variant to represent unknown Lua types (eg LuaJIT CDATA)
+- Added (optional) `anyhow` feature to implement `IntoLua` for `anyhow::Error`
+- Added `IntoLua`/`FromLua` for `OsString`/`OsStr` and `PathBuf`/`Path`
+
+## v0.10.0-beta.2
+
+- Updated `ThreadStatus` enum to include `Running` and `Finished` variants.
+- `Error::CoroutineInactive` renamed to `Error::CoroutineUnresumable`.
+- `IntoLua`/`IntoLuaMulti` now uses `impl trait` syntax for args (shorten from `a.get::<_, T>` to `a.get::<T>`).
+- Removed undocumented `Lua::into_static`/`from_static` methods.
+- Futures now require `Send` bound if `send` feature is enabled.
+- Dropped lifetime from `UserDataMethods` and `UserDataFields` traits.
+- `Compiler::compile()` now returns `Result` (Luau).
+- Removed `Clone` requirement from `UserDataFields::add_field()`.
+- `TableExt` and `AnyUserDataExt` traits were combined into `ObjectLike` trait.
+- Disabled `send` feature in module mode (since we don't have exclusive access to Lua).
+- `Chunk::set_environment()` takes `Table` instead of `IntoLua` type.
+- Reduced the compile time contribution of `next_key_seed` and `next_value_seed`.
+- Reduced the compile time contribution of `serde_userdata`.
+- Performance improvements.
+
+## v0.10.0-beta.1
+
+- Dropped `'lua` lifetime (subtypes now store a weak reference to Lua)
+- Removed (experimental) owned types (they no longer needed)
+- Make Lua types truly `Send` and `Sync` (when enabling `send` feature flag)
+- Removed `UserData` impl for Rc/Arc types ("any" userdata functions can be used instead)
+- `Lua::replace_registry_value` takes `&mut RegistryKey`
+- `Lua::scope` temporary disabled (will be re-added in the next release)
+
+## v0.9.9
+
+- Minimal Luau updated to 0.629
+- Fixed bug when attempting to reset or resume already running coroutines (#416).
+- Added `RegistryKey::id()` method to get the underlying Lua registry key id.
+
+## v0.9.8
+
+- Fixed serializing same table multiple times (#408)
+- Use `mlua-sys` v0.6 (to support Luau 0.624+)
+- Fixed cross compilation of windows dlls from unix (#394)
+
+## v0.9.7
+
+- Implemented `IntoLua` for `RegistryKey`
+- Mark `__idiv` metamethod as available for luau
+- Added `Function::deep_clone()` method (Luau)
+- Added `SerializeOptions::detect_serde_json_arbitrary_precision` option
+- Added `Lua::create_buffer()` method (Luau)
+- Support serializing buffer type as a byte slice (Luau)
+- Perf: Implemented `push_into_stack`/`from_stack` for `Option<T>`
+- Added `Lua::create_ser_any_userdata()` method
+
+## v0.9.6
+
+- Added `to_pointer` function to `Function`/`Table`/`Thread`
+- Implemented `IntoLua` for `&Value`
+- Implemented `FromLua` for `RegistryKey`
+- Faster (~5%) table array traversal during serialization
+- Some performance improvements for bool/int types
+
+## v0.9.5
+
+- Minimal Luau updated to 0.609
+- Luau max stack size increased to 1M (from 100K)
+- Implemented `IntoLua` for refs to `String`/`Table`/`Function`/`AnyUserData`/`Thread` + `RegistryKey`
+- Implemented `IntoLua` and `FromLua` for `OwnedThread`/`OwnedString`
+- Fixed `FromLua` derive proc macro to cover more cases
+
+## v0.9.4
+
+- Fixed loading all-in-one modules under mixed states (eg. main state and coroutines)
+
+## v0.9.3
+
+- WebAssembly support (`wasm32-unknown-emscripten` target)
+- Performance improvements (faster Lua function calls for lua51/jit/luau)
+
+## v0.9.2
+
+- Added binary modules support to Luau
+- Added Luau package module (uses `StdLib::PACKAGE`) with loaders (follows lua5.1 interface)
+- Added support of Luau 0.601+ buffer type (represented as userdata in Rust)
+- LuaJIT `cdata` type is also represented as userdata in Rust (instead of panic)
+- Vendored LuaJIT switched to rolling vanilla (from openresty)
+- Added `Table::for_each` method for fast table pairs traversal (faster than `pairs`)
+- Performance improvements around table traversal (and faster serialization)
+- Bug fixes and improvements
+
+## v0.9.1
+
+- impl Default for Lua
+- impl IntoLuaMulti for `std::result::Result<(), E>`
+- Fix using wrong userdata index after processing Variadic args (#311)
+
+## v0.9.0
+
+Changes since v0.9.0-rc.3
+
+- Improved non-static (scoped) userdata support
+- Added `Scope::create_any_userdata()` method
+- Added `Lua::set_vector_metatable()` method (`unstable` feature flag)
+- Added `OwnedThread` type (`unstable` feature flag)
+- Minimal Luau updated to 0.590
+- Added new option `sort_keys` to `DeserializeOptions` (`Lua::from_value()` method)
+- Changed `Table::raw_len()` output type to `usize`
+- Helper functions for `Value` (eg: `Value::as_number()`/`Value::as_string`/etc)
+- Performance improvements
+
+## v0.9.0-rc.3
+
+- Minimal Luau updated to 0.588
+
+## v0.9.0-rc.2
+
+- Added `#[derive(FromLua)]` macro to opt-in into `FromLua<T> where T: 'static + Clone` (userdata type).
+- Support vendored module mode for windows (raw-dylib linking, Rust 1.71+)
+- `module` and `vendored` features are now mutually exclusive
+- Use `C-unwind` ABI (Rust 1.71+)
+- Changed `AsChunk` trait to support capturing wrapped Lua types
+
+## v0.9.0-rc.1
+
+- `UserDataMethods::add_async_method()` takes `&T` instead of cloning `T`
+- Implemented `PartialEq<[T]>` for tables
+- Added Luau 4-dimensional vectors support (`luau-vector4` feature)
+- `Table::sequence_values()` iterator no longer uses any metamethods (`Table::raw_sequence_values()` is deprecated)
+- Added `Table:is_empty()` function that checks both hash and array parts
+- Refactored Debug interface
+- Re-exported `ffi` (`mlua-sys`) crate for easier writing of unsafe code
+- Refactored Lua 5.4 warnings interface
+- Take `&str` as function name in `TableExt` and `AnyUserDataExt` traits
+- Added module attribule `skip_memory_check` to improve performance
+- Added `AnyUserData::wrap()` to provide more easy way of creating _any_ userdata in Lua
+
+## v0.9.0-beta.3
+
+- Added `OwnedAnyUserData::take()`
+- Switch to `DeserializeOwned`
+- Overwrite error context when called multiple times
+- New feature flag `luau-jit` to enable (experimental) Luau codegen backend
+- Set `__name` field in userdata metatable
+- Added `Value::to_string()` method similar to `luaL_tolstring`
+- Lua 5.4.6
+- Application data container now allows to mutably and immutably borrow different types at the same time
+- Performance optimizations
+- Support getting and setting environment for Lua functions.
+- Added `UserDataFields::add_field()` method to add static fields to UserData
+
+Breaking changes:
+- Require environment to be a `Table` instead of `Value` in Chunks.
+- `AsChunk::env()` renamed to `AsChunk::environment()`
+
+## v0.9.0-beta.2
+
+New features:
+- Added `Thread::set_hook()` function to set hook on threads
+- Added pretty print to the Debug formatting to Lua `Value` and `Table`
+- ffi layer moved to `mlua-sys` crate
+- Added OwnedString (unstable)
+
+Breaking changes:
+- Refactor `HookTriggers` (make it const)
+
+## 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.10
+
+- Update to Luau 0.590 (luau0-src to 0.7.x)
+- Fix loading luau code starting with \t
+- Pin lua-src and luajit-src versions
+
+## v0.8.9
+
+- Update minimal (vendored) Lua 5.4 to 5.4.6
+- Use `lua_closethread` instead of `lua_resetthread` in vendored mode (Lua 5.4.6)
+- Allow deserializing Lua null into unit (`()`) or unit struct.
+
+## 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
@@ -6,7 +396,7 @@
 
 ## v0.8.0
 Changes since 0.7.4
-- Roblox Luau support
+- Luau support
 - Removed C glue
 - Added async support to `__index` and `__newindex` metamethods
 - Added `Function::info()` to get information about functions (#149).
@@ -56,7 +446,7 @@ Breaking changes:
 
 ## v0.8.0-beta.1
 
-- Roblox Luau support
+- Luau support
 - Refactored ffi module. C glue is no longer required
 - Added async support to `__index` and `__newindex` metamethods
 
@@ -169,7 +559,7 @@ Breaking changes:
 - [**Breaking**] Removed `AnyUserData::has_metamethod()`
 - Added `Thread::reset()` for luajit/lua54 to recycle threads.
   It's possible to attach a new function to a thread (coroutine).
-- Added `chunk!` macro support to load chunks of Lua code using the Rust tokenizer and optinally capturing Rust variables.
+- Added `chunk!` macro support to load chunks of Lua code using the Rust tokenizer and optionally capturing Rust variables.
 - Improved error reporting (`Error`'s `__tostring` method formats full stacktraces). This is useful in the module mode.
 
 ## v0.6.0-beta.1
@@ -225,7 +615,7 @@ Breaking changes:
 
 - Lua 5.4 support with `MetaMethod::Close`.
 - `lua53` feature is disabled by default. Now preferred Lua version have to be chosen explicitly.
-- Provide safety guaraness for Lua state, which means that potenially unsafe operations, like loading C modules (using `require` or `package.loadlib`) are disabled. Equalient for the previous `Lua::new()` function is `Lua::unsafe_new()`.
+- Provide safety guarantees for Lua state, which means that potentially unsafe operations, like loading C modules (using `require` or `package.loadlib`) are disabled. Equivalent to the previous `Lua::new()` function is `Lua::unsafe_new()`.
 - New `send` feature to require `Send`.
 - New `module` feature, that disables linking to Lua Core Libraries. Required for modules.
 - Don't allow `'callback` outlive `'lua` in `Lua::create_function()` to fix [the unsoundness](tests/compile/static_callback_args.rs).

Cargo.toml

@@ -1,107 +1,123 @@
 [package]
 name = "mlua"
-version = "0.8.1" # remember to update html_root_url and mlua_derive
-authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
+version = "0.11.4" # remember to update mlua_derive
+authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
+rust-version = "1.79.0"
 edition = "2021"
-repository = "https://github.com/khvzak/mlua"
+repository = "https://github.com/mlua-rs/mlua"
 documentation = "https://docs.rs/mlua"
 readme = "README.md"
 keywords = ["lua", "luajit", "luau", "async", "scripting"]
 categories = ["api-bindings", "asynchronous"]
 license = "MIT"
-links = "lua"
-build = "build/main.rs"
 description = """
-High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau
 with async/await features and support of writing native Lua modules in Rust.
 """
 
 [package.metadata.docs.rs]
-features = ["lua54", "vendored", "async", "send", "serialize", "macros", "parking_lot"]
+features = ["lua54", "vendored", "async", "send", "serde", "macros"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [workspace]
 members = [
     "mlua_derive",
+    "mlua-sys",
 ]
 
 [features]
-lua54 = []
-lua53 = []
-lua52 = []
-lua51 = []
-luajit = []
-luajit52 = ["luajit"]
-luau = ["luau0-src"]
-vendored = ["lua-src", "luajit-src"]
-module = ["mlua_derive"]
-async = ["futures-core", "futures-task", "futures-util"]
-send = []
-serialize = ["serde", "erased-serde"]
+lua54 = ["ffi/lua54"]
+lua53 = ["ffi/lua53"]
+lua52 = ["ffi/lua52"]
+lua51 = ["ffi/lua51"]
+luajit = ["ffi/luajit"]
+luajit52 = ["luajit", "ffi/luajit52"]
+luau = ["ffi/luau"]
+luau-jit = ["luau", "ffi/luau-codegen"]
+luau-vector4 = ["luau", "ffi/luau-vector4"]
+vendored = ["ffi/vendored"]
+module = ["mlua_derive", "ffi/module"]
+async = ["dep:futures-util"]
+send = ["error-send"]
+error-send = []
+serde = ["dep:serde", "dep:erased-serde", "dep:serde-value", "bstr/serde"]
 macros = ["mlua_derive/macros"]
+anyhow = ["dep:anyhow", "error-send"]
+userdata-wrappers = ["parking_lot/send_guard"]
+
+# deprecated features
+serialize = ["serde"]
 
 [dependencies]
-mlua_derive = { version = "=0.8.0", optional = true, path = "mlua_derive" }
-bstr = { version = "0.2", features = ["std"], default_features = false }
-once_cell = { version = "1.0" }
+mlua_derive = { version = "=0.11.0", optional = true, path = "mlua_derive" }
+bstr = { version = "1.0", features = ["std"], default-features = false }
+either = "1.0"
 num-traits = { version = "0.2.14" }
-rustc-hash = "1.0"
-futures-core = { version = "0.3.5", optional = true }
-futures-task = { version = "0.3.5", optional = true }
-futures-util = { version = "0.3.5", optional = true }
+rustc-hash = "2.0"
+futures-util = { version = "0.3", optional = true, default-features = false, features = ["std"] }
 serde = { version = "1.0", optional = true }
-erased-serde = { version = "0.3", optional = true }
-parking_lot = { version = "0.12", optional = true }
+erased-serde = { version = "0.4", optional = true }
+serde-value = { version = "0.7", optional = true }
+parking_lot = { version = "0.12", features = ["arc_lock"] }
+anyhow = { version = "1.0", optional = true }
+rustversion = "1.0"
 
-[build-dependencies]
-cc = { version = "1.0" }
-pkg-config = { version = "0.3.17" }
-lua-src = { version = ">= 544.0.0, < 550.0.0", optional = true }
-luajit-src = { version = ">= 210.4.0, < 220.0.0", optional = true }
-luau0-src = { version = "0.3.2", optional = true }
+ffi = { package = "mlua-sys", version = "0.8.3", path = "mlua-sys" }
 
 [dev-dependencies]
-rustyline = "9.0"
-criterion = { version = "0.3.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"
+hyper = { version = "1.2", features = ["full"] }
+hyper-util = { version = "0.1.3", features = ["full"] }
+http-body-util = "0.1.1"
+reqwest = { version = "0.12", features = ["json"] }
+tokio = { version = "1.0", features = ["macros", "rt", "time"] }
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+serde_json = { version = "1.0", features = ["arbitrary_precision"] }
 maplit = "1.0"
 tempfile = "3"
+static_assertions = "1.0"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+criterion = { version = "0.7", features = ["async_tokio"] }
+rustyline = "17.0"
+tokio = { version = "1.0", features = ["full"] }
+
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(tarpaulin_include)'] }
 
 [[bench]]
 name = "benchmark"
 harness = false
 required-features = ["async"]
 
+[[bench]]
+name = "serde"
+harness = false
+required-features = ["serde"]
+
 [[example]]
 name = "async_http_client"
 required-features = ["async", "macros"]
 
 [[example]]
 name = "async_http_reqwest"
-required-features = ["async", "serialize", "macros"]
+required-features = ["async", "serde", "macros"]
 
 [[example]]
 name = "async_http_server"
-required-features = ["async", "macros"]
+required-features = ["async", "macros", "send"]
 
 [[example]]
 name = "async_tcp_server"
-required-features = ["async", "macros"]
+required-features = ["async", "macros", "send"]
 
 [[example]]
 name = "guided_tour"
 required-features = ["macros"]
 
 [[example]]
-name = "serialize"
-required-features = ["serialize"]
+name = "serde"
+required-features = ["serde"]
 
 [[example]]
 name = "userdata"

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

@@ -1,69 +1,78 @@
 # mlua
 [![Build Status]][github-actions] [![Latest Version]][crates.io] [![API Documentation]][docs.rs] [![Coverage Status]][codecov.io] ![MSRV]
 
-[Build Status]: https://github.com/khvzak/mlua/workflows/CI/badge.svg
-[github-actions]: https://github.com/khvzak/mlua/actions
+[Build Status]: https://github.com/mlua-rs/mlua/workflows/CI/badge.svg
+[github-actions]: https://github.com/mlua-rs/mlua/actions
 [Latest Version]: https://img.shields.io/crates/v/mlua.svg
 [crates.io]: https://crates.io/crates/mlua
 [API Documentation]: https://docs.rs/mlua/badge.svg
 [docs.rs]: https://docs.rs/mlua
-[Coverage Status]: https://codecov.io/gh/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.56+-brightgreen.svg?&logo=rust
+[Coverage Status]: https://codecov.io/gh/mlua-rs/mlua/branch/main/graph/badge.svg?token=99339FS1CG
+[codecov.io]: https://codecov.io/gh/mlua-rs/mlua
+[MSRV]: https://img.shields.io/badge/rust-1.79+-brightgreen.svg?&logo=rust
 
-[Guided Tour](examples/guided_tour.rs)
+[Guided Tour] | [Benchmarks] | [FAQ]
 
-`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.
+[Guided Tour]: examples/guided_tour.rs
+[Benchmarks]: https://github.com/khvzak/script-bench-rs
+[FAQ]: FAQ.md
 
-Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Roblox Luau] and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.
+`mlua` is a set of bindings to the [Lua](https://www.lua.org) programming language for Rust with a goal of providing a
+_safe_ (as much as possible), high level, easy to use, practical and flexible API.
 
-`mlua` tested on Windows/macOS/Linux including module mode in [GitHub Actions] on `x86_64` platform and cross-compilation to `aarch64` (other targets are also supported).
+Started as an `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Luau] and allows writing native Lua modules in Rust as well as using Lua in a standalone mode.
 
-[GitHub Actions]: https://github.com/khvzak/mlua/actions
-[Roblox Luau]: https://luau-lang.org
+`mlua` is tested on Windows/macOS/Linux including module mode in [GitHub Actions] on `x86_64` platforms and cross-compilation to `aarch64` (other targets are also supported).
+
+WebAssembly (WASM) is supported through the `wasm32-unknown-emscripten` target for all Lua/Luau versions excluding JIT.
+
+[GitHub Actions]: https://github.com/mlua-rs/mlua/actions
+[Luau]: https://luau.org
 
 ## Usage
 
 ### Feature flags
 
-`mlua` uses feature flags to reduce the amount of dependencies, compiled code and allow to choose only required set of features.
+`mlua` uses feature flags to reduce the number of dependencies and compiled code, and allow choosing only the required set of features.
 Below is a list of the available feature flags. By default `mlua` does not enable any features.
 
-* `lua54`: activate Lua [5.4] support
-* `lua53`: activate Lua [5.3] support
-* `lua52`: activate Lua [5.2] support
-* `lua51`: activate Lua [5.1] support
-* `luajit`: activate [LuaJIT] support
-* `luajit52`: activate [LuaJIT] support with partial compatibility with Lua 5.2
-* `luau`: activate [Luau] support (auto vendored mode)
-* `vendored`: build static Lua(JIT) library from sources during `mlua` compilation using [lua-src] or [luajit-src] crates
+* `lua54`: enable Lua [5.4] support
+* `lua53`: enable Lua [5.3] support
+* `lua52`: enable Lua [5.2] support
+* `lua51`: enable Lua [5.1] support
+* `luajit`: enable [LuaJIT] support
+* `luajit52`: enable [LuaJIT] support with partial compatibility with Lua 5.2
+* `luau`: enable [Luau] support (auto vendored mode)
+* `luau-jit`: enable [Luau] support with JIT backend.
+* `luau-vector4`: enable [Luau] support with 4-dimensional vector.
+* `vendored`: build static Lua(JIT) libraries from sources during `mlua` compilation using [lua-src] or [luajit-src]
 * `module`: enable module mode (building loadable `cdylib` library for Lua)
 * `async`: enable async/await support (any executor can be used, eg. [tokio] or [async-std])
-* `send`: make `mlua::Lua` transferable across thread boundaries (adds [`Send`] requirement to `mlua::Function` and `mlua::UserData`)
-* `serialize`: add serialization and deserialization support to `mlua` types using [serde] framework
+* `send`: make `mlua::Lua: Send + Sync` (adds [`Send`] requirement to `mlua::Function` and `mlua::UserData`)
+* `error-send`: make `mlua:Error: Send + Sync`
+* `serde`: add serialization and deserialization support to `mlua` types using [serde]
 * `macros`: enable procedural macros (such as `chunk!`)
-* `parking_lot`: support UserData types wrapped in [parking_lot]'s primitives (`Arc<Mutex>` and `Arc<RwLock>`)
+* `anyhow`: enable `anyhow::Error` conversion into Lua
+* `userdata-wrappers`: opt into `impl UserData` for `Rc<T>`/`Arc<T>`/`Rc<RefCell<T>>`/`Arc<Mutex<T>>` where `T: UserData`
 
 [5.4]: https://www.lua.org/manual/5.4/manual.html
 [5.3]: https://www.lua.org/manual/5.3/manual.html
 [5.2]: https://www.lua.org/manual/5.2/manual.html
 [5.1]: https://www.lua.org/manual/5.1/manual.html
 [LuaJIT]: https://luajit.org/
-[Luau]: https://github.com/Roblox/luau
-[lua-src]: https://github.com/khvzak/lua-src-rs
-[luajit-src]: https://github.com/khvzak/luajit-src-rs
+[Luau]: https://github.com/luau-lang/luau
+[lua-src]: https://github.com/mlua-rs/lua-src-rs
+[luajit-src]: https://github.com/mlua-rs/luajit-src-rs
 [tokio]: https://github.com/tokio-rs/tokio
 [async-std]: https://github.com/async-rs/async-std
 [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
 [serde]: https://github.com/serde-rs/serde
-[parking_lot]: https://github.com/Amanieu/parking_lot
 
 ### Async/await support
 
 `mlua` supports async/await for all Lua versions including Luau.
 
-This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6) and require running [Thread](https://docs.rs/mlua/latest/mlua/struct.Thread.html) along with enabling `feature = "async"` in `Cargo.toml`.
+This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6) and requires running [Thread](https://docs.rs/mlua/latest/mlua/struct.Thread.html) along with enabling `feature = "async"` in `Cargo.toml`.
 
 **Examples**:
 - [HTTP Client](examples/async_http_client.rs)
@@ -71,11 +80,25 @@ This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6
 - [HTTP Server](examples/async_http_server.rs)
 - [TCP Server](examples/async_tcp_server.rs)
 
-### Serialization (serde) support
 
-With `serialize` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition `mlua` provides [`serde::Serialize`] trait implementation for it (including `UserData` support).
+**shell command examples**:
+```shell
+# async http client (hyper)
+cargo run --example async_http_client --features=lua54,async,macros
 
-[Example](examples/serialize.rs)
+# async http client (reqwest)
+cargo run --example async_http_reqwest --features=lua54,async,macros,serde
+
+# async http server
+cargo run --example async_http_server --features=lua54,async,macros,send
+curl -v http://localhost:3000
+```
+
+### Serde support
+
+With the `serde` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition, `mlua` provides the [`serde::Serialize`] trait implementation for `mlua::Value` (including `UserData` support).
+
+[Example](examples/serde.rs)
 
 [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
@@ -85,28 +108,28 @@ With `serialize` feature flag enabled, `mlua` allows you to serialize/deserializ
 
 You have to enable one of the features: `lua54`, `lua53`, `lua52`, `lua51`, `luajit(52)` or `luau`, according to the chosen Lua version.
 
-By default `mlua` uses `pkg-config` tool to find lua includes and libraries for the chosen Lua version.
-In most cases it works as desired, although sometimes could be more preferable to use a custom lua library.
-To achieve this, mlua supports `LUA_INC`, `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
+By default `mlua` uses `pkg-config` to find Lua includes and libraries for the chosen Lua version.
+In most cases it works as desired, although sometimes it may be preferable to use a custom Lua library.
+To achieve this, mlua supports the `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
 `LUA_LINK` is optional and may be `dylib` (a dynamic library) or `static` (a static library, `.a` archive).
 
-An example how to use them:
+An example of how to use them:
 ``` sh
-my_project $ LUA_INC=$HOME/tmp/lua-5.2.4/src LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
+my_project $ LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
 ```
 
-`mlua` also supports vendored lua/luajit using the auxiliary crates [lua-src](https://crates.io/crates/lua-src) and
+`mlua` also supports vendored Lua/LuaJIT using the auxiliary crates [lua-src](https://crates.io/crates/lua-src) and
 [luajit-src](https://crates.io/crates/luajit-src).
-Just enable the `vendored` feature and cargo will automatically build and link specified lua/luajit version. This is the easiest way to get started with `mlua`.
+Just enable the `vendored` feature and cargo will automatically build and link the specified Lua/LuaJIT version. This is the easiest way to get started with `mlua`.
 
 ### Standalone mode
-In a standalone mode `mlua` allows to add to your application scripting support with a gently configured Lua runtime to ensure  safety and soundness.
+In standalone mode, `mlua` allows adding scripting support to your application with a gently configured Lua runtime to ensure safety and soundness.
 
-Add to `Cargo.toml` :
+Add to `Cargo.toml`:
 
 ``` toml
 [dependencies]
-mlua = { version = "0.8", features = ["lua54", "vendored"] }
+mlua = { version = "0.11", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -130,21 +153,21 @@ fn main() -> LuaResult<()> {
 ```
 
 ### Module mode
-In a module mode `mlua` allows to create a compiled Lua module that can be loaded from Lua code using [`require`](https://www.lua.org/manual/5.4/manual.html#pdf-require). In this case `mlua` uses an external Lua runtime which could lead to potential unsafety due to unpredictability of the Lua environment and usage of libraries such as [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10).
+In module mode, `mlua` allows creating a compiled Lua module that can be loaded from Lua code using [`require`](https://www.lua.org/manual/5.4/manual.html#pdf-require). In this case `mlua` uses an external Lua runtime which could lead to potential unsafety due to the unpredictability of the Lua environment and usage of libraries such as [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10).
 
 [Example](examples/module)
 
-Add to `Cargo.toml` :
+Add to `Cargo.toml`:
 
 ``` toml
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.8", features = ["lua54", "vendored", "module"] }
+mlua = { version = "0.11", features = ["lua54", "module"] }
 ```
 
-`lib.rs` :
+`lib.rs`:
 
 ``` rust
 use mlua::prelude::*;
@@ -171,7 +194,7 @@ $ lua5.4 -e 'require("my_module").hello("world")'
 hello, world!
 ```
 
-On macOS, you need to set additional linker arguments. One option is to compile with `cargo rustc --release -- -C link-arg=-undefined -C link-arg=dynamic_lookup`, the other is to create a `.cargo/config` with the following content:
+On macOS, you need to set additional linker arguments. One option is to compile with `cargo rustc --release -- -C link-arg=-undefined -C link-arg=dynamic_lookup`, the other is to create a `.cargo/config.toml` with the following content:
 ``` toml
 [target.x86_64-apple-darwin]
 rustflags = [
@@ -186,29 +209,31 @@ rustflags = [
 ]
 ```
 On Linux you can build modules normally with `cargo build --release`.
-Vendored and non-vendored builds are supported for these OS.
 
-On Windows `vendored` mode for modules is not supported since you need to link to a Lua dll.
-Easiest way is to use either MinGW64 (as part of [MSYS2](https://github.com/msys2/msys2) package) with `pkg-config` or
-MSVC with `LUA_INC` / `LUA_LIB` / `LUA_LIB_NAME` environment variables.
+On Windows the target module will be linked with the `lua5x.dll` library (depending on your feature flags).
+Your main application should provide this library.
 
-More details about compiling and linking Lua modules can be found on the [Building Modules](http://lua-users.org/wiki/BuildingModules) page.
+Module builds don't require Lua binaries or headers to be installed on the system.
 
 ### Publishing to luarocks.org
 
-There is a LuaRocks build backend for mlua modules [`luarocks-build-rust-mlua`].
+There is a LuaRocks build backend for mlua modules: [`luarocks-build-rust-mlua`].
 
 Modules written in Rust and published to luarocks:
+- [`decasify`](https://github.com/alerque/decasify)
 - [`lua-ryaml`](https://github.com/khvzak/lua-ryaml)
+- [`tiktoken_core`](https://github.com/gptlang/lua-tiktoken)
+- [`toml-edit`](https://github.com/vhyrro/toml-edit.lua)
+- [`typst-lua`](https://github.com/rousbound/typst-lua)
 
 [`luarocks-build-rust-mlua`]: https://luarocks.org/modules/khvzak/luarocks-build-rust-mlua
 
 ## Safety
 
-One of the `mlua` goals is to provide *safe* API between Rust and Lua.
-Every place where the Lua C API may trigger an error longjmp in any way is protected by `lua_pcall`,
-and the user of the library is protected from directly interacting with unsafe things like the Lua stack,
-and there is overhead associated with this safety.
+One of `mlua`'s goals is to provide a *safe* API between Rust and Lua.
+Every place where the Lua C API may trigger an error longjmp is protected by `lua_pcall`,
+and the user of the library is protected from directly interacting with unsafe things like the Lua stack.
+There is overhead associated with this safety.
 
 Unfortunately, `mlua` does not provide absolute safety even without using `unsafe` .
 This library contains a huge amount of unsafe code. There are almost certainly bugs still lurking in this library!
@@ -216,8 +241,8 @@ It is surprisingly, fiendishly difficult to use the Lua C API without the potent
 
 ## Panic handling
 
-`mlua` wraps panics that are generated inside Rust callbacks in a regular Lua error. Panics could be
-resumed then by returning or propagating the Lua error to Rust code.
+`mlua` wraps panics that are generated inside Rust callbacks in a regular Lua error. Panics can then be
+resumed by returning or propagating the Lua error to Rust code.
 
 For example:
 ``` rust
@@ -236,16 +261,16 @@ let _ = lua.load(r#"
 unreachable!()
 ```
 
-Optionally `mlua` can disable Rust panics catching in Lua via `pcall`/`xpcall` and automatically resume
+Optionally, `mlua` can disable Rust panic catching in Lua via `pcall`/`xpcall` and automatically resume
 them across the Lua API boundary. This is controlled via `LuaOptions` and done by wrapping the Lua `pcall`/`xpcall`
-functions on a way to prevent catching errors that are wrapped Rust panics.
+functions to prevent catching errors that are wrapped Rust panics.
 
 `mlua` should also be panic safe in another way as well, which is that any `Lua` instances or handles
-remains usable after a user generated panic, and such panics should not break internal invariants or
+remain usable after a user generated panic, and such panics should not break internal invariants or
 leak Lua stack space. This is mostly important to safely use `mlua` types in Drop impls, as you should not be
 using panics for general error handling.
 
-Below is a list of `mlua` behaviors that should be considered a bug.
+Below is a list of `mlua` behaviors that should be considered bugs.
 If you encounter them, a bug report would be very welcome:
 
   + If you can cause UB with `mlua` without typing the word "unsafe", this is a bug.
@@ -258,12 +283,12 @@ If you encounter them, a bug report would be very welcome:
 
 ## Sandboxing
 
-Please check the [Luau Sandboxing] page if you are interested in running untrusted Lua scripts in controlled environment.
+Please check the [Luau Sandboxing] page if you are interested in running untrusted Lua scripts in a controlled environment.
 
-`mlua` provides `Lua::sandbox` method for enabling sandbox mode (Luau only).
+`mlua` provides the `Lua::sandbox` method for enabling sandbox mode (Luau only).
 
-[Luau Sandboxing]: https://luau-lang.org/sandbox
+[Luau Sandboxing]: https://luau.org/sandbox
 
 ## License
 
-This project is licensed under the [MIT license](LICENSE)
+This project is licensed under the [MIT license](LICENSE).

benches/benchmark.rs

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

benches/serde.rs

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

build/find_dummy.rs

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

build/find_normal.rs

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

build/main.rs

@@ -1,115 +0,0 @@
-#[cfg_attr(
-    any(
-        feature = "luau",
-        all(
-            feature = "vendored",
-            any(
-                feature = "lua54",
-                feature = "lua53",
-                feature = "lua52",
-                feature = "lua51",
-                feature = "luajit"
-            )
-        )
-    ),
-    path = "find_vendored.rs"
-)]
-#[cfg_attr(
-    all(
-        not(feature = "vendored"),
-        any(
-            feature = "lua54",
-            feature = "lua53",
-            feature = "lua52",
-            feature = "lua51",
-            feature = "luajit"
-        )
-    ),
-    path = "find_normal.rs"
-)]
-#[cfg_attr(
-    not(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit",
-        feature = "luau"
-    )),
-    path = "find_dummy.rs"
-)]
-mod find;
-
-fn main() {
-    #[cfg(not(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit",
-        feature = "luau"
-    )))]
-    compile_error!(
-        "You must enable one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
-    );
-
-    #[cfg(all(
-        feature = "lua54",
-        any(
-            feature = "lua53",
-            feature = "lua52",
-            feature = "lua51",
-            feature = "luajit",
-            feature = "luau"
-        )
-    ))]
-    compile_error!(
-        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
-    );
-
-    #[cfg(all(
-        feature = "lua53",
-        any(
-            feature = "lua52",
-            feature = "lua51",
-            feature = "luajit",
-            feature = "luau"
-        )
-    ))]
-    compile_error!(
-        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
-    );
-
-    #[cfg(all(
-        feature = "lua52",
-        any(feature = "lua51", feature = "luajit", feature = "luau")
-    ))]
-    compile_error!(
-        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
-    );
-
-    #[cfg(all(feature = "lua51", any(feature = "luajit", feature = "luau")))]
-    compile_error!(
-        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
-    );
-
-    #[cfg(all(feature = "luajit", feature = "luau"))]
-    compile_error!(
-        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
-    );
-
-    // We don't support "vendored module" mode on windows
-    #[cfg(all(feature = "vendored", feature = "module", target_os = "windows"))]
-    compile_error!(
-        "Vendored (static) builds are not supported for modules on Windows.\n"
-            + "Please, use `pkg-config` or custom mode to link to a Lua dll."
-    );
-
-    #[cfg(all(feature = "luau", feature = "module"))]
-    compile_error!("Luau does not support module mode");
-
-    #[cfg(any(not(feature = "module"), target_os = "windows"))]
-    find::probe_lua();
-
-    println!("cargo:rerun-if-changed=build");
-}

docs/release_notes/v0.10.md

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

docs/release_notes/v0.9.md

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

examples/async_http_client.rs

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

examples/async_http_reqwest.rs

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

examples/async_http_server.rs

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

examples/async_tcp_server.rs

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

examples/guided_tour.rs

@@ -1,7 +1,7 @@
 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
@@ -17,12 +17,12 @@ fn main() -> Result<()> {
     globals.set("string_var", "hello")?;
     globals.set("int_var", 42)?;
 
-    assert_eq!(globals.get::<_, String>("string_var")?, "hello");
-    assert_eq!(globals.get::<_, i64>("int_var")?, 42);
+    assert_eq!(globals.get::<String>("string_var")?, "hello");
+    assert_eq!(globals.get::<i64>("int_var")?, 42);
 
     // You can load and evaluate Lua code. The returned type of `Lua::load` is a builder
     // that allows you to change settings before running Lua code. Here, we are using it to set
-    // the name of the laoded chunk to "example code", which will be used when Lua error
+    // the name of the loaded chunk to "example code", which will be used when Lua error
     // messages are printed.
 
     lua.load(
@@ -30,9 +30,9 @@ fn main() -> Result<()> {
             global = 'foo'..'bar'
         "#,
     )
-    .set_name("example code")?
+    .set_name("example code")
     .exec()?;
-    assert_eq!(globals.get::<_, String>("global")?, "foobar");
+    assert_eq!(globals.get::<String>("global")?, "foobar");
 
     assert_eq!(lua.load("1 + 1").eval::<i32>()?, 2);
     assert_eq!(lua.load("false == false").eval::<bool>()?, true);
@@ -85,20 +85,20 @@ fn main() -> Result<()> {
     // You can load Lua functions
 
     let print: Function = globals.get("print")?;
-    print.call::<_, ()>("hello from rust")?;
+    print.call::<()>("hello from rust")?;
 
-    // This API generally handles variadics using tuples. This is one way to call a function with
+    // This API generally handles variadic using tuples. This is one way to call a function with
     // multiple parameters:
 
-    print.call::<_, ()>(("hello", "again", "from", "rust"))?;
+    print.call::<()>(("hello", "again", "from", "rust"))?;
 
     // But, you can also pass variadic arguments with the `Variadic` type.
 
-    print.call::<_, ()>(Variadic::from_iter(
+    print.call::<()>(Variadic::from_iter(
         ["hello", "yet", "again", "from", "rust"].iter().cloned(),
     ))?;
 
-    // You can bind rust functions to Lua as well. Callbacks receive the Lua state inself as their
+    // You can bind rust functions to Lua as well. Callbacks receive the Lua state itself as their
     // first parameter, and the arguments given to the function as the second parameter. The type
     // of the arguments can be anything that is convertible from the parameters given by Lua, in
     // this case, the function expects two string sequences.
@@ -151,8 +151,18 @@ fn main() -> Result<()> {
     #[derive(Copy, Clone)]
     struct Vec2(f32, f32);
 
+    // We can implement `FromLua` trait for our `Vec2` to return a copy
+    impl FromLua for Vec2 {
+        fn from_lua(value: Value, _: &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) {
+        fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
             methods.add_method("magnitude", |_, vec, ()| {
                 let mag_squared = vec.0 * vec.0 + vec.1 * vec.1;
                 Ok(mag_squared.sqrt())
@@ -167,19 +177,15 @@ fn main() -> Result<()> {
     let vec2_constructor = lua.create_function(|_, (x, y): (f32, f32)| Ok(Vec2(x, y)))?;
     globals.set("vec2", vec2_constructor)?;
 
-    assert!(
-        (lua.load("(vec2(1, 2) + vec2(2, 2)):magnitude()")
-            .eval::<f32>()?
-            - 5.0)
-            .abs()
-            < f32::EPSILON
-    );
+    assert!((lua.load("(vec2(1, 2) + vec2(2, 2)):magnitude()").eval::<f32>()? - 5.0).abs() < f32::EPSILON);
 
     // Normally, Rust types passed to `Lua` must be `'static`, because there is no way to be
     // sure of their lifetime inside the Lua state. There is, however, a limited way to lift this
     // requirement. You can call `Lua::scope` to create userdata and callbacks types that only live
     // for as long as the call to scope, but do not have to be `'static` (and `Send`).
 
+    // TODO: Re-enable this
+    /*
     {
         let mut rust_val = 0;
 
@@ -201,6 +207,7 @@ fn main() -> Result<()> {
 
         assert_eq!(rust_val, 42);
     }
+    */
 
     // We were able to run our 'sketchy' function inside the scope just fine. However, if we
     // try to run our 'sketchy' function outside of the scope, the function we created will have

examples/module/Cargo.toml

@@ -2,7 +2,7 @@
 name = "rust_module"
 version = "0.0.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-edition = "2018"
+edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]

examples/repl.rs

@@ -1,11 +1,11 @@
 //! This example shows a simple read-evaluate-print-loop (REPL).
 
 use mlua::{Error, Lua, MultiValue};
-use rustyline::Editor;
+use rustyline::DefaultEditor;
 
 fn main() {
     let lua = Lua::new();
-    let mut editor = Editor::<()>::new();
+    let mut editor = DefaultEditor::new().expect("Failed to create editor");
 
     loop {
         let mut prompt = "> ";
@@ -19,15 +19,17 @@ fn main() {
 
             match lua.load(&line).eval::<MultiValue>() {
                 Ok(values) => {
-                    editor.add_history_entry(line);
-                    println!(
-                        "{}",
-                        values
-                            .iter()
-                            .map(|value| format!("{:?}", value))
-                            .collect::<Vec<_>>()
-                            .join("\t")
-                    );
+                    editor.add_history_entry(line).unwrap();
+                    if values.len() > 0 {
+                        println!(
+                            "{}",
+                            values
+                                .iter()
+                                .map(|value| format!("{:#?}", value))
+                                .collect::<Vec<_>>()
+                                .join("\t")
+                        );
+                    }
                     break;
                 }
                 Err(Error::SyntaxError {

examples/serde.rs

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

examples/userdata.rs

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

mlua-sys/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "mlua-sys"
+version = "0.8.3"
+authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
+rust-version = "1.71"
+edition = "2021"
+repository = "https://github.com/mlua-rs/mlua"
+documentation = "https://docs.rs/mlua-sys"
+readme = "README.md"
+categories = ["external-ffi-bindings"]
+license = "MIT"
+links = "lua"
+build = "build/main.rs"
+description = """
+Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau
+"""
+
+[package.metadata.docs.rs]
+features = ["lua54", "vendored"]
+rustdoc-args = ["--cfg", "docsrs"]
+
+[features]
+lua54 = []
+lua53 = []
+lua52 = []
+lua51 = []
+luajit = []
+luajit52 = ["luajit"]
+luau = ["luau0-src"]
+luau-codegen = ["luau"]
+luau-vector4 = ["luau"]
+vendored = ["lua-src", "luajit-src"]
+external = []
+module = []
+
+[dependencies]
+
+[build-dependencies]
+cc = "1.0"
+cfg-if = "1.0"
+pkg-config = "0.3.17"
+lua-src = { version = ">= 548.1.0, < 548.2.0", optional = true }
+luajit-src = { version = ">= 210.6.0, < 210.7.0", optional = true }
+luau0-src = { version = "0.15.6", optional = true }
+
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(raw_dylib)'] }

mlua-sys/README.md

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

mlua-sys/build/find_normal.rs

@@ -0,0 +1,68 @@
+#![allow(dead_code)]
+
+use std::env;
+use std::ops::Bound;
+
+pub fn probe_lua() {
+    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+
+    if target_arch == "wasm32" && cfg!(not(feature = "vendored")) {
+        panic!("Please enable `vendored` feature to build for wasm32");
+    }
+
+    let lib_dir = env::var("LUA_LIB").unwrap_or_default();
+    let lua_lib = env::var("LUA_LIB_NAME").unwrap_or_default();
+
+    println!("cargo:rerun-if-env-changed=LUA_LIB");
+    println!("cargo:rerun-if-env-changed=LUA_LIB_NAME");
+    println!("cargo:rerun-if-env-changed=LUA_LINK");
+
+    if !lua_lib.is_empty() {
+        if !lib_dir.is_empty() {
+            println!("cargo:rustc-link-search=native={lib_dir}");
+        }
+        let mut link_lib = "";
+        if env::var("LUA_LINK").as_deref() == Ok("static") {
+            link_lib = "static=";
+        };
+        println!("cargo:rustc-link-lib={link_lib}{lua_lib}");
+        return;
+    }
+
+    // Find using `pkg-config`
+
+    #[cfg(feature = "lua54")]
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.4", "5.5", ["lua5.4", "lua-5.4", "lua54"], "5.4");
+    #[cfg(feature = "lua53")]
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.3", "5.4", ["lua5.3", "lua-5.3", "lua53"], "5.3");
+    #[cfg(feature = "lua52")]
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.2", "5.3", ["lua5.2", "lua-5.2", "lua52"], "5.2");
+    #[cfg(feature = "lua51")]
+    let (incl_bound, excl_bound, alt_probe, ver) =
+        ("5.1", "5.2", ["lua5.1", "lua-5.1", "lua51"], "5.1");
+    #[cfg(feature = "luajit")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("2.0.4", "2.2", [], "JIT");
+
+    #[rustfmt::skip]
+    let mut lua = pkg_config::Config::new()
+        .range_version((Bound::Included(incl_bound), Bound::Excluded(excl_bound)))
+        .cargo_metadata(true)
+        .probe(if cfg!(feature = "luajit") { "luajit" } else { "lua" });
+
+    if lua.is_err() {
+        for pkg in alt_probe {
+            lua = pkg_config::Config::new()
+                .cargo_metadata(true)
+                .probe(pkg);
+
+            if lua.is_ok() {
+                break;
+            }
+        }
+    }
+
+    lua.unwrap_or_else(|err| panic!("cannot find Lua{ver} using `pkg-config`: {err}"));
+}

mlua-sys/build/find_vendored.rs

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

mlua-sys/build/main.rs

@@ -0,0 +1,19 @@
+cfg_if::cfg_if! {
+    if #[cfg(all(feature = "lua54", not(any(feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "lua53", not(any(feature = "lua54", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "lua52", not(any(feature = "lua54", feature = "lua53", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "lua51", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "luajit", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "luau", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit"))))] {
+        include!("main_inner.rs");
+    } else {
+        fn main() {
+            compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau");
+        }
+    }
+}

mlua-sys/build/main_inner.rs

@@ -0,0 +1,42 @@
+use std::env;
+
+cfg_if::cfg_if! {
+    if #[cfg(any(feature = "luau", feature = "vendored"))] {
+        #[path = "find_vendored.rs"]
+        mod find;
+    } else {
+        #[path = "find_normal.rs"]
+        mod find;
+    }
+}
+
+fn main() {
+    #[cfg(all(feature = "luau", feature = "module", windows))]
+    compile_error!("Luau does not support `module` mode on Windows");
+
+    #[cfg(any(
+        all(feature = "vendored", any(feature = "external", feature = "module")),
+        all(feature = "external", any(feature = "vendored", feature = "module")),
+        all(feature = "module", any(feature = "vendored", feature = "external"))
+    ))]
+    compile_error!("`vendored`, `external` and `module` features are mutually exclusive");
+
+    println!("cargo:rerun-if-changed=build");
+
+    // Check if compilation and linking is handled by external crate
+    if cfg!(not(feature = "external")) {
+        let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+        if target_os == "windows" && cfg!(feature = "module") {
+            if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
+                // Don't use raw-dylib linking
+                find::probe_lua();
+                return;
+            }
+
+            println!("cargo:rustc-cfg=raw_dylib");
+        }
+
+        #[cfg(not(feature = "module"))]
+        find::probe_lua();
+    }
+}

mlua-sys/src/lib.rs

@@ -0,0 +1,106 @@
+//! Low level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau.
+
+#![allow(non_camel_case_types, non_snake_case)]
+#![allow(clippy::missing_safety_doc)]
+#![allow(unsafe_op_in_unsafe_fn)]
+#![doc(test(attr(deny(warnings))))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+use std::os::raw::c_int;
+
+#[cfg(any(feature = "lua54", doc))]
+pub use lua54::*;
+
+#[cfg(any(feature = "lua53", doc))]
+pub use lua53::*;
+
+#[cfg(any(feature = "lua52", doc))]
+pub use lua52::*;
+
+#[cfg(any(feature = "lua51", feature = "luajit", doc))]
+pub use lua51::*;
+
+#[cfg(any(feature = "luau", doc))]
+pub use luau::*;
+
+#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+#[doc(hidden)]
+pub const LUA_MAX_UPVALUES: c_int = 255;
+
+#[cfg(any(feature = "lua51", feature = "luajit"))]
+#[doc(hidden)]
+pub const LUA_MAX_UPVALUES: c_int = 60;
+
+#[cfg(feature = "luau")]
+#[doc(hidden)]
+pub const LUA_MAX_UPVALUES: c_int = 200;
+
+// I believe `luaL_traceback` < 5.4 requires this much free stack to not error.
+// 5.4 uses `luaL_Buffer`
+#[doc(hidden)]
+pub const LUA_TRACEBACK_STACK: c_int = 11;
+
+// Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/pal/common/alloc.rs
+// The minimum alignment guaranteed by the architecture. This value is used to
+// add fast paths for low alignment values.
+#[cfg(any(
+    target_arch = "x86",
+    target_arch = "arm",
+    target_arch = "m68k",
+    target_arch = "csky",
+    target_arch = "mips",
+    target_arch = "mips32r6",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "sparc",
+    target_arch = "wasm32",
+    target_arch = "hexagon",
+    all(target_arch = "riscv32", not(any(target_os = "espidf", target_os = "zkvm"))),
+    all(target_arch = "xtensa", not(target_os = "espidf")),
+))]
+#[doc(hidden)]
+pub const SYS_MIN_ALIGN: usize = 8;
+#[cfg(any(
+    target_arch = "x86_64",
+    target_arch = "aarch64",
+    target_arch = "arm64ec",
+    target_arch = "loongarch64",
+    target_arch = "mips64",
+    target_arch = "mips64r6",
+    target_arch = "s390x",
+    target_arch = "sparc64",
+    target_arch = "riscv64",
+    target_arch = "wasm64",
+))]
+#[doc(hidden)]
+pub const SYS_MIN_ALIGN: usize = 16;
+// The allocator on the esp-idf and zkvm platforms guarantee 4 byte alignment.
+#[cfg(any(
+    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
+    all(target_arch = "xtensa", target_os = "espidf"),
+))]
+#[doc(hidden)]
+pub const SYS_MIN_ALIGN: usize = 4;
+
+#[macro_use]
+mod macros;
+
+#[cfg(any(feature = "lua54", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "lua54")))]
+pub mod lua54;
+
+#[cfg(any(feature = "lua53", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "lua53")))]
+pub mod lua53;
+
+#[cfg(any(feature = "lua52", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "lua52")))]
+pub mod lua52;
+
+#[cfg(any(feature = "lua51", feature = "luajit", doc))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "lua51", feature = "luajit"))))]
+pub mod lua51;
+
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub mod luau;

mlua-sys/src/lua51/compat.rs

@@ -2,10 +2,8 @@
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3
 
-use std::convert::TryInto;
-use std::mem;
 use std::os::raw::{c_char, c_int, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 use super::lauxlib::*;
 use super::lua::*;
@@ -92,7 +90,7 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
             } else if compat53_findfield(L, objidx, level - 1) != 0 {
                 // try recursively
                 lua_remove(L, -2); // remove table (but keep name)
-                lua_pushliteral(L, ".");
+                lua_pushliteral(L, c".");
                 lua_insert(L, -2); // place '.' between the two names
                 lua_concat(L, 3);
                 return 1;
@@ -123,13 +121,13 @@ unsafe fn compat53_pushfuncname(L: *mut lua_State, ar: *mut lua_Debug) {
         lua_pushfstring(L, cstr!("function '%s'"), (*ar).name);
     } else if *(*ar).what == b'm' as c_char {
         // main?
-        lua_pushliteral(L, "main chunk");
+        lua_pushliteral(L, c"main chunk");
     } else if *(*ar).what == b'C' as c_char {
         if compat53_pushglobalfuncname(L, ar) != 0 {
             lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
             lua_remove(L, -2); // remove name
         } else {
-            lua_pushliteral(L, "?");
+            lua_pushliteral(L, c"?");
         }
     } else {
         lua_pushfstring(
@@ -178,7 +176,7 @@ pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
 #[inline(always)]
 pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {
     let abs_to = lua_absindex(L, toidx);
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_pushvalue(L, fromidx);
     lua_replace(L, abs_to);
 }
@@ -188,7 +186,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
     if lua_type(L, idx) == LUA_TNUMBER {
         let n = lua_tonumber(L, idx);
         let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
             return 1;
         }
     }
@@ -316,7 +315,7 @@ pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
 #[inline(always)]
 pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
     let abs_i = lua_absindex(L, idx);
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_pushlightuserdata(L, p as *mut c_void);
     lua_insert(L, -2);
     lua_rawset(L, abs_i);
@@ -329,12 +328,7 @@ pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) {
 }
 
 #[inline(always)]
-pub unsafe fn lua_dump(
-    L: *mut lua_State,
-    writer: lua_Writer,
-    data: *mut c_void,
-    _strip: c_int,
-) -> c_int {
+pub unsafe fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, _strip: c_int) -> c_int {
     lua_dump_(L, writer, data)
 }
 
@@ -366,12 +360,7 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
 }
 
 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    _from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+pub unsafe fn lua_resume(L: *mut lua_State, _from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
     let ret = lua_resume_(L, narg);
     if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
         *nres = lua_gettop(L);
@@ -389,7 +378,7 @@ pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char)
         if !msg.is_null() {
             luaL_error(L, cstr!("stack overflow (%s)"), msg);
         } else {
-            lua_pushliteral(L, "stack overflow");
+            lua_pushliteral(L, c"stack overflow");
             lua_error(L);
         }
     }
@@ -415,6 +404,25 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
     }
 }
 
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == LUA_OK && env != 0 {
+        lua_pushvalue(L, env);
+        lua_setfenv(L, -2);
+    }
+    status
+}
+
 #[inline(always)]
 pub unsafe fn luaL_loadbufferx(
     L: *mut lua_State,
@@ -437,7 +445,7 @@ pub unsafe fn luaL_loadbufferx(
 #[inline(always)]
 pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
     let mut isnum = 0;
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     lua_len(L, idx);
     let res = lua_tointegerx(L, -1, &mut isnum);
     lua_pop(L, 1);
@@ -447,12 +455,7 @@ pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
     res
 }
 
-pub unsafe fn luaL_traceback(
-    L: *mut lua_State,
-    L1: *mut lua_State,
-    msg: *const c_char,
-    mut level: c_int,
-) {
+pub unsafe fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, mut level: c_int) {
     let mut ar: lua_Debug = mem::zeroed();
     let top = lua_gettop(L);
     let numlevels = compat53_countlevels(L1);
@@ -465,12 +468,12 @@ pub unsafe fn luaL_traceback(
     if !msg.is_null() {
         lua_pushfstring(L, cstr!("%s\n"), msg);
     }
-    lua_pushliteral(L, "stack traceback:");
+    lua_pushliteral(L, c"stack traceback:");
     while lua_getstack(L1, level, &mut ar) != 0 {
         level += 1;
         if level == mark {
             // too many levels?
-            lua_pushliteral(L, "\n\t..."); // add a '...'
+            lua_pushliteral(L, c"\n\t..."); // add a '...'
             level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
         } else {
             lua_getinfo(L1, cstr!("Slnt"), &mut ar);
@@ -478,7 +481,7 @@ pub unsafe fn luaL_traceback(
             if ar.currentline > 0 {
                 lua_pushfstring(L, cstr!("%d:"), ar.currentline);
             }
-            lua_pushliteral(L, " in ");
+            lua_pushliteral(L, c" in ");
             compat53_pushfuncname(L, &mut ar);
             lua_concat(L, lua_gettop(L) - top);
         }
@@ -486,24 +489,24 @@ pub unsafe fn luaL_traceback(
     lua_concat(L, lua_gettop(L) - top);
 }
 
-pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
             LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
             }
             LUA_TSTRING | LUA_TNUMBER => {
                 lua_pushvalue(L, idx);
             }
             LUA_TBOOLEAN => {
                 if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                 } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                 }
             }
-            _ => {
+            t => {
                 let tt = luaL_getmetafield(L, idx, cstr!("__name"));
                 let name = if tt == LUA_TSTRING {
                     lua_tostring(L, -1)
@@ -512,7 +515,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                 };
                 lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                 if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__name'
                 }
             }
         };
@@ -524,14 +527,14 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
 
 #[inline(always)]
 pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
-    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
     luaL_getmetatable(L, tname);
     lua_setmetatable(L, -2);
 }
 
 pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int {
     let abs_i = lua_absindex(L, idx);
-    luaL_checkstack(L, 3, cstr!("not enough stack slots"));
+    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
     lua_pushstring_(L, fname);
     if lua_gettable(L, abs_i) == LUA_TTABLE {
         return 1;
@@ -544,14 +547,9 @@ pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_ch
     0
 }
 
-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
     luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
     if lua_getfield(L, -1, modname) == LUA_TNIL {
         lua_pop(L, 1);
         lua_pushcfunction(L, openf);

mlua-sys/src/lua51/lauxlib.rs

@@ -8,13 +8,17 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 // Extra error code for 'luaL_load'
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
+
 #[repr(C)]
 pub struct luaL_Reg {
     pub name: *const c_char,
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
     #[link_name = "luaL_getmetafield"]
     pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -42,7 +46,7 @@ extern "C" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,
@@ -56,17 +60,13 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
     pub fn luaL_loadfile(L: *mut lua_State, filename: *const c_char) -> c_int;
-    pub fn luaL_loadbuffer(
-        L: *mut lua_State,
-        buff: *const c_char,
-        sz: usize,
-        name: *const c_char,
-    ) -> c_int;
+    pub fn luaL_loadbuffer(L: *mut lua_State, buff: *const c_char, sz: usize, name: *const c_char) -> c_int;
     pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
 
     pub fn luaL_newstate() -> *mut lua_State;

mlua-sys/src/lua51/lua.rs

@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_void};
 use std::ptr;
@@ -73,23 +74,23 @@ pub type lua_Integer = i32;
 pub type lua_Integer = i64;
 
 /// Type for native C functions that can be passed to Lua.
-pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+/// Type for memory-allocation functions (no unwinding)
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // State manipulation
     //
@@ -97,9 +98,6 @@ extern "C" {
     pub fn lua_close(L: *mut lua_State);
     pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
 
-    #[cfg(all(feature = "luajit", feature = "vendored"))]
-    pub fn lua_resetthread(L: *mut lua_State, th: *mut lua_State);
-
     pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
 
     //
@@ -221,21 +219,33 @@ pub const LUA_GCSTEP: c_int = 5;
 pub const LUA_GCSETPAUSE: c_int = 6;
 pub const LUA_GCSETSTEPMUL: c_int = 7;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
 //
 // Miscellaneous functions
 //
-extern "C" {
-    pub fn lua_error(L: *mut lua_State) -> !;
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
     pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -303,10 +313,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring_(L, s.as_ptr());
 }
 
 #[inline(always)]
@@ -319,11 +327,25 @@ pub unsafe fn lua_getglobal_(L: *mut lua_State, var: *const c_char) {
     lua_getfield_(L, LUA_GLOBALSINDEX, var)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
 }
 
+#[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
 //
@@ -345,9 +367,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
@@ -355,12 +378,7 @@ extern "C" {
     pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
     pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
 
-    pub fn lua_sethook(
-        L: *mut lua_State,
-        func: Option<lua_Hook>,
-        mask: c_int,
-        count: c_int,
-    ) -> c_int;
+    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int) -> c_int;
     pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
     pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
     pub fn lua_gethookcount(L: *mut lua_State) -> c_int;

mlua-sys/src/lua51/lualib.rs

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

mlua-sys/src/lua52/compat.rs

@@ -2,7 +2,6 @@
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3
 
-use std::convert::TryInto;
 use std::os::raw::{c_char, c_int, c_void};
 use std::ptr;
 
@@ -52,7 +51,8 @@ pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
     if lua_type(L, idx) == LUA_TNUMBER {
         let n = lua_tonumber(L, idx);
         let i = lua_tointeger(L, idx);
-        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+        // Lua 5.3+ returns "false" for `-0.0`
+        if n.to_bits() == (i as lua_Number).to_bits() {
             return 1;
         }
     }
@@ -158,22 +158,12 @@ pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
 }
 
 #[inline(always)]
-pub unsafe fn lua_dump(
-    L: *mut lua_State,
-    writer: lua_Writer,
-    data: *mut c_void,
-    _strip: c_int,
-) -> c_int {
+pub unsafe fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, _strip: c_int) -> c_int {
     lua_dump_(L, writer, data)
 }
 
 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+pub unsafe fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int {
     let ret = lua_resume_(L, from, narg);
     if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
         *nres = lua_gettop(L);
@@ -205,24 +195,24 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
     }
 }
 
-pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
     if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
             LUA_TNIL => {
-                lua_pushliteral(L, "nil");
+                lua_pushliteral(L, c"nil");
             }
             LUA_TSTRING | LUA_TNUMBER => {
                 lua_pushvalue(L, idx);
             }
             LUA_TBOOLEAN => {
                 if lua_toboolean(L, idx) == 0 {
-                    lua_pushliteral(L, "false");
+                    lua_pushliteral(L, c"false");
                 } else {
-                    lua_pushliteral(L, "true");
+                    lua_pushliteral(L, c"true");
                 }
             }
-            _ => {
+            t => {
                 let tt = luaL_getmetafield(L, idx, cstr!("__name"));
                 let name = if tt == LUA_TSTRING {
                     lua_tostring(L, -1)
@@ -231,7 +221,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                 };
                 lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                 if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__name'
                 }
             }
         };
@@ -241,14 +231,9 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
     lua_tolstring(L, -1, len)
 }
 
-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+pub unsafe fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int) {
     luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
     if lua_getfield(L, -1, modname) == LUA_TNIL {
         lua_pop(L, 1);
         lua_pushcfunction(L, openf);
@@ -263,3 +248,22 @@ pub unsafe fn luaL_requiref(
     }
     lua_replace(L, -2);
 }
+
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == LUA_OK && env != 0 {
+        lua_pushvalue(L, env);
+        lua_setupvalue(L, -2, 1);
+    }
+    status
+}

mlua-sys/src/lua52/lauxlib.rs

@@ -8,13 +8,20 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Un
 // Extra error code for 'luaL_load'
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
+
 #[repr(C)]
 pub struct luaL_Reg {
     pub name: *const c_char,
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);
 
     #[link_name = "luaL_getmetafield"]
@@ -24,12 +31,8 @@ extern "C" {
     pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
     pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
     pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
-    pub fn luaL_optlstring(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        l: *mut usize,
-    ) -> *const c_char;
+    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
+        -> *const c_char;
     pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
     pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
     pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -48,7 +51,7 @@ extern "C" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,
@@ -65,12 +68,12 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }
 
 #[inline(always)]
@@ -78,7 +81,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
     luaL_loadfilex(L, f, ptr::null())
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_loadbufferx(
         L: *mut lua_State,
         buff: *const c_char,
@@ -106,12 +110,7 @@ extern "C" {
     pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
 
     #[link_name = "luaL_requiref"]
-    pub fn luaL_requiref_(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
+    pub fn luaL_requiref_(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }
 
 //
@@ -170,12 +169,7 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
 // luaL_opt would be implemented here but it is undocumented, so it's omitted
 
 #[inline(always)]
-pub unsafe fn luaL_loadbuffer(
-    L: *mut lua_State,
-    s: *const c_char,
-    sz: usize,
-    n: *const c_char,
-) -> c_int {
+pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
     luaL_loadbufferx(L, s, sz, n, ptr::null())
 }
 

mlua-sys/src/lua52/lua.rs

@@ -1,5 +1,6 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_uint, c_void};
 use std::ptr;
@@ -78,23 +79,23 @@ pub type lua_Integer = i64;
 pub type lua_Unsigned = c_uint;
 
 /// Type for native C functions that can be passed to Lua
-pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+/// Type for memory-allocation functions (no unwinding)
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // State manipulation
     //
@@ -155,20 +156,19 @@ pub const LUA_OPMOD: c_int = 4;
 pub const LUA_OPPOW: c_int = 5;
 pub const LUA_OPUNM: c_int = 6;
 
-extern "C" {
-    pub fn lua_arith(L: *mut lua_State, op: c_int);
-}
-
 pub const LUA_OPEQ: c_int = 0;
 pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
     pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
     pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Push functions (C -> stack)
     //
@@ -223,13 +223,7 @@ extern "C" {
     //
     // 'load' and 'call' functions (load and run Lua code)
     //
-    pub fn lua_callk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    );
+    pub fn lua_callk(L: *mut lua_State, nargs: c_int, nresults: c_int, ctx: c_int, k: Option<lua_CFunction>);
     pub fn lua_pcallk(
         L: *mut lua_State,
         nargs: c_int,
@@ -262,16 +256,12 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
     lua_pcallk(L, n, r, f, 0, None)
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Coroutine functions
     //
-    pub fn lua_yieldk(
-        L: *mut lua_State,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    ) -> c_int;
+    pub fn lua_yieldk(L: *mut lua_State, nresults: c_int, ctx: c_int, k: Option<lua_CFunction>) -> c_int;
     #[link_name = "lua_resume"]
     pub fn lua_resume_(L: *mut lua_State, from: *mut lua_State, narg: c_int) -> c_int;
     pub fn lua_status(L: *mut lua_State) -> c_int;
@@ -298,15 +288,18 @@ pub const LUA_GCISRUNNING: c_int = 9;
 pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Miscellaneous functions
     //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_len(L: *mut lua_State, idx: c_int);
@@ -314,6 +307,15 @@ extern "C" {
     pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -394,10 +396,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }
 
 #[inline(always)]
@@ -405,11 +405,25 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
     lua_rawgeti_(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS as _)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
 }
 
+#[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
 //
@@ -431,9 +445,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
@@ -444,7 +459,7 @@ extern "C" {
     pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
     pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
 
-    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int);
+    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int) -> c_int;
     pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
     pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
     pub fn lua_gethookcount(L: *mut lua_State) -> c_int;

mlua-sys/src/lua52/lualib.rs

@@ -1,28 +1,27 @@
 //! Contains definitions from `lualib.h`.
 
-use std::os::raw::c_int;
+use std::os::raw::{c_char, c_int};
 
 use super::lua::lua_State;
 
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaopen_base(L: *mut lua_State) -> c_int;
     pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
     pub fn luaopen_table(L: *mut lua_State) -> c_int;
     pub fn luaopen_io(L: *mut lua_State) -> c_int;
     pub fn luaopen_os(L: *mut lua_State) -> c_int;
     pub fn luaopen_string(L: *mut lua_State) -> c_int;
-    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
     pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
     pub fn luaopen_math(L: *mut lua_State) -> c_int;
     pub fn luaopen_debug(L: *mut lua_State) -> c_int;

mlua-sys/src/lua53/compat.rs

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

mlua-sys/src/lua53/lauxlib.rs

@@ -9,10 +9,10 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
 // Key, in the registry, for table of loaded modules
-pub const LUA_LOADED_TABLE: &str = "_LOADED";
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
 
 // Key, in the registry, for table of preloaded loaders
-pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
 
 #[repr(C)]
 pub struct luaL_Reg {
@@ -20,20 +20,18 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
 
     pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
     pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
-    pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    #[link_name = "luaL_tolstring"]
+    pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
     pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
     pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
-    pub fn luaL_optlstring(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        l: *mut usize,
-    ) -> *const c_char;
+    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
+        -> *const c_char;
     pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
     pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
     pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -49,7 +47,7 @@ extern "C" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,
@@ -66,12 +64,12 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }
 
 #[inline(always)]
@@ -79,7 +77,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
     luaL_loadfilex(L, f, ptr::null())
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_loadbufferx(
         L: *mut lua_State,
         buff: *const c_char,
@@ -93,8 +92,6 @@ extern "C" {
 
     pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
 
-    // TODO: luaL_addgsub
-
     pub fn luaL_gsub(
         L: *mut lua_State,
         s: *const c_char,
@@ -108,12 +105,7 @@ extern "C" {
 
     pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
 
-    pub fn luaL_requiref(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
+    pub fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }
 
 //
@@ -169,15 +161,15 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
     lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
 }
 
+#[inline(always)]
+pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+    luaL_tolstring_(L, lua::lua_absindex(L, idx), len)
+}
+
 // luaL_opt would be implemented here but it is undocumented, so it's omitted
 
 #[inline(always)]
-pub unsafe fn luaL_loadbuffer(
-    L: *mut lua_State,
-    s: *const c_char,
-    sz: usize,
-    n: *const c_char,
-) -> c_int {
+pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
     luaL_loadbufferx(L, s, sz, n, ptr::null())
 }
 

mlua-sys/src/lua53/lua.rs

@@ -1,9 +1,9 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
-use std::mem;
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 // Mark for precompiled code (`<esc>Lua`)
 pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
@@ -82,27 +82,27 @@ pub type lua_Unsigned = u64;
 pub type lua_KContext = isize;
 
 /// Type for native C functions that can be passed to Lua
-pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 /// Type for continuation functions
 pub type lua_KFunction =
-    unsafe extern "C" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+/// Type for memory-allocation functions (no unwinding)
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // State manipulation
     //
@@ -167,20 +167,19 @@ pub const LUA_OPSHR: c_int = 11;
 pub const LUA_OPUNM: c_int = 12;
 pub const LUA_OPBNOT: c_int = 13;
 
-extern "C" {
-    pub fn lua_arith(L: *mut lua_State, op: c_int);
-}
-
 pub const LUA_OPEQ: c_int = 0;
 pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
     pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
     pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Push functions (C -> stack)
     //
@@ -252,12 +251,7 @@ extern "C" {
         mode: *const c_char,
     ) -> c_int;
 
-    pub fn lua_dump(
-        L: *mut lua_State,
-        writer: lua_Writer,
-        data: *mut c_void,
-        strip: c_int,
-    ) -> c_int;
+    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, strip: c_int) -> c_int;
 }
 
 #[inline(always)]
@@ -270,7 +264,8 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
     lua_pcallk(L, n, r, f, 0, None)
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Coroutine functions
     //
@@ -304,15 +299,18 @@ pub const LUA_GCSETPAUSE: c_int = 6;
 pub const LUA_GCSETSTEPMUL: c_int = 7;
 pub const LUA_GCISRUNNING: c_int = 9;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Miscellaneous functions
     //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_len(L: *mut lua_State, idx: c_int);
@@ -321,6 +319,15 @@ extern "C" {
     pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -401,10 +408,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }
 
 #[inline(always)]
@@ -412,6 +417,14 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
     lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
@@ -434,6 +447,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
 //
@@ -455,9 +474,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;

mlua-sys/src/lua53/lualib.rs

@@ -0,0 +1,34 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::{c_char, c_int};
+
+use super::lua::lua_State;
+
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_IOLIBNAME: *const c_char = cstr!("io");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_LOADLIBNAME: *const c_char = cstr!("package");
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_io(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
+    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+    pub fn luaopen_package(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}

mlua-sys/src/lua54/lauxlib.rs

@@ -9,10 +9,10 @@ use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
 pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
 
 // Key, in the registry, for table of loaded modules
-pub const LUA_LOADED_TABLE: &str = "_LOADED";
+pub const LUA_LOADED_TABLE: *const c_char = cstr!("_LOADED");
 
 // Key, in the registry, for table of preloaded loaders
-pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+pub const LUA_PRELOAD_TABLE: *const c_char = cstr!("_PRELOAD");
 
 #[repr(C)]
 pub struct luaL_Reg {
@@ -20,7 +20,8 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
 
     pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -28,12 +29,8 @@ extern "C" {
     pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
     pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
     pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
-    pub fn luaL_optlstring(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        l: *mut usize,
-    ) -> *const c_char;
+    pub fn luaL_optlstring(L: *mut lua_State, arg: c_int, def: *const c_char, l: *mut usize)
+        -> *const c_char;
     pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
     pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
     pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
@@ -49,7 +46,7 @@ extern "C" {
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
 
     pub fn luaL_checkoption(
         L: *mut lua_State,
@@ -66,12 +63,12 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
     pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
 
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }
 
 #[inline(always)]
@@ -79,7 +76,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
     luaL_loadfilex(L, f, ptr::null())
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn luaL_loadbufferx(
         L: *mut lua_State,
         buff: *const c_char,
@@ -93,6 +91,8 @@ extern "C" {
 
     pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
 
+    // TODO: luaL_addgsub
+
     pub fn luaL_gsub(
         L: *mut lua_State,
         s: *const c_char,
@@ -106,12 +106,7 @@ extern "C" {
 
     pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
 
-    pub fn luaL_requiref(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
+    pub fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }
 
 //
@@ -170,15 +165,29 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
 // luaL_opt would be implemented here but it is undocumented, so it's omitted
 
 #[inline(always)]
-pub unsafe fn luaL_loadbuffer(
-    L: *mut lua_State,
-    s: *const c_char,
-    sz: usize,
-    n: *const c_char,
-) -> c_int {
+pub unsafe fn luaL_loadbuffer(L: *mut lua_State, s: *const c_char, sz: usize, n: *const c_char) -> c_int {
     luaL_loadbufferx(L, s, sz, n, ptr::null())
 }
 
+pub unsafe fn luaL_loadbufferenv(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+    mut env: c_int,
+) -> c_int {
+    if env != 0 {
+        env = lua::lua_absindex(L, env);
+    }
+    let status = luaL_loadbufferx(L, data, size, name, mode);
+    if status == lua::LUA_OK && env != 0 {
+        lua::lua_pushvalue(L, env);
+        lua::lua_setupvalue(L, -2, 1);
+    }
+    status
+}
+
 //
 // TODO: Generic Buffer Manipulation
 //

mlua-sys/src/lua54/lua.rs

@@ -1,9 +1,9 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
-use std::mem;
 use std::os::raw::{c_char, c_double, c_int, c_uchar, c_ushort, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 // Mark for precompiled code (`<esc>Lua`)
 pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
@@ -81,38 +81,40 @@ pub type lua_Unsigned = u64;
 pub type lua_KContext = isize;
 
 /// Type for native C functions that can be passed to Lua
-pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
 
 /// Type for continuation functions
 pub type lua_KFunction =
-    unsafe extern "C" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
 
 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
 
-/// Type for memory-allocation functions
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+/// Type for memory-allocation functions (no unwinding)
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
 /// Type for warning functions
-pub type lua_WarnFunction =
-    unsafe extern "C" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
+pub type lua_WarnFunction = unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // State manipulation
     //
     pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
     pub fn lua_close(L: *mut lua_State);
     pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+    // Deprecated in Lua 5.4.6
     pub fn lua_resetthread(L: *mut lua_State) -> c_int;
+    #[cfg(feature = "vendored")]
+    pub fn lua_closethread(L: *mut lua_State, from: *mut lua_State) -> c_int;
 
     pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
 
@@ -146,13 +148,21 @@ extern "C" {
     pub fn lua_tointegerx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
     pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
-    pub fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize;
+    #[link_name = "lua_rawlen"]
+    fn lua_rawlen_(L: *mut lua_State, idx: c_int) -> lua_Unsigned;
     pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
     pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
     pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
 }
 
+// lua_rawlen's return type changed from size_t to lua_Unsigned int in Lua 5.4.
+// This adapts the crate API to the new Lua ABI.
+#[inline(always)]
+pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
+    lua_rawlen_(L, idx) as usize
+}
+
 //
 // Comparison and arithmetic functions
 //
@@ -171,20 +181,19 @@ pub const LUA_OPSHR: c_int = 11;
 pub const LUA_OPUNM: c_int = 12;
 pub const LUA_OPBNOT: c_int = 13;
 
-extern "C" {
-    pub fn lua_arith(L: *mut lua_State, op: c_int);
-}
-
 pub const LUA_OPEQ: c_int = 0;
 pub const LUA_OPLT: c_int = 1;
 pub const LUA_OPLE: c_int = 2;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
     pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
     pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Push functions (C -> stack)
     //
@@ -256,12 +265,7 @@ extern "C" {
         mode: *const c_char,
     ) -> c_int;
 
-    pub fn lua_dump(
-        L: *mut lua_State,
-        writer: lua_Writer,
-        data: *mut c_void,
-        strip: c_int,
-    ) -> c_int;
+    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, strip: c_int) -> c_int;
 }
 
 #[inline(always)]
@@ -274,7 +278,8 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
     lua_pcallk(L, n, r, f, 0, None)
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Coroutine functions
     //
@@ -284,12 +289,7 @@ extern "C" {
         ctx: lua_KContext,
         k: Option<lua_KFunction>,
     ) -> c_int;
-    pub fn lua_resume(
-        L: *mut lua_State,
-        from: *mut lua_State,
-        narg: c_int,
-        nres: *mut c_int,
-    ) -> c_int;
+    pub fn lua_resume(L: *mut lua_State, from: *mut lua_State, narg: c_int, nres: *mut c_int) -> c_int;
     pub fn lua_status(L: *mut lua_State) -> c_int;
     pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
 }
@@ -302,7 +302,8 @@ pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
 //
 // Warning-related functions
 //
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_setwarnf(L: *mut lua_State, f: Option<lua_WarnFunction>, ud: *mut c_void);
     pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
 }
@@ -322,15 +323,18 @@ pub const LUA_GCISRUNNING: c_int = 9;
 pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
 }
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     //
     // Miscellaneous functions
     //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     pub fn lua_len(L: *mut lua_State, idx: c_int);
@@ -342,6 +346,15 @@ extern "C" {
     pub fn lua_closeslot(L: *mut lua_State, idx: c_int);
 }
 
+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -422,10 +435,8 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring(L, s.as_ptr());
 }
 
 #[inline(always)]
@@ -433,6 +444,14 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
     lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
 }
 
+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
@@ -455,6 +474,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)
@@ -491,9 +516,10 @@ pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
 pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+unsafe extern "C-unwind" {
     pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;

mlua-sys/src/lua54/lualib.rs

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

mlua-sys/src/luau/compat.rs

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

mlua-sys/src/luau/lauxlib.rs

@@ -3,9 +3,7 @@
 use std::os::raw::{c_char, c_float, c_int, c_void};
 use std::ptr;
 
-use super::lua::{
-    self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Unsigned, LUA_REGISTRYINDEX,
-};
+use super::lua::{self, lua_CFunction, lua_Number, lua_State, lua_Unsigned, LUA_REGISTRYINDEX};
 
 #[repr(C)]
 pub struct luaL_Reg {
@@ -13,7 +11,7 @@ pub struct luaL_Reg {
     pub func: lua_CFunction,
 }
 
-extern "C" {
+unsafe extern "C-unwind" {
     pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
     #[link_name = "luaL_getmetafield"]
     pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
@@ -35,8 +33,10 @@ extern "C" {
     pub fn luaL_checkboolean(L: *mut lua_State, narg: c_int) -> c_int;
     pub fn luaL_optboolean(L: *mut lua_State, narg: c_int, def: c_int) -> c_int;
 
-    pub fn luaL_checkinteger(L: *mut lua_State, narg: c_int) -> lua_Integer;
-    pub fn luaL_optinteger(L: *mut lua_State, narg: c_int, def: lua_Integer) -> lua_Integer;
+    #[link_name = "luaL_checkinteger"]
+    pub fn luaL_checkinteger_(L: *mut lua_State, narg: c_int) -> c_int;
+    #[link_name = "luaL_optinteger"]
+    pub fn luaL_optinteger_(L: *mut lua_State, narg: c_int, def: c_int) -> c_int;
     pub fn luaL_checkunsigned(L: *mut lua_State, narg: c_int) -> lua_Unsigned;
     pub fn luaL_optunsigned(L: *mut lua_State, narg: c_int, def: lua_Unsigned) -> lua_Unsigned;
 
@@ -52,6 +52,8 @@ extern "C" {
     pub fn luaL_newmetatable_(L: *mut lua_State, tname: *const c_char) -> c_int;
     pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
 
+    pub fn luaL_checkbuffer(L: *mut lua_State, narg: c_int, len: *mut usize) -> *mut c_void;
+
     pub fn luaL_where(L: *mut lua_State, lvl: c_int);
 
     #[link_name = "luaL_errorL"]
@@ -69,10 +71,17 @@ extern "C" {
 
     pub fn luaL_newstate() -> *mut lua_State;
 
-    // TODO: luaL_findtable
+    pub fn luaL_findtable(
+        L: *mut lua_State,
+        idx: c_int,
+        fname: *const c_char,
+        szhint: c_int,
+    ) -> *const c_char;
 
     pub fn luaL_typename(L: *mut lua_State, idx: c_int) -> *const c_char;
 
+    pub fn luaL_callyieldable(L: *mut lua_State, nargs: c_int, nresults: c_int) -> c_int;
+
     // sandbox libraries and globals
     #[link_name = "luaL_sandbox"]
     pub fn luaL_sandbox_(L: *mut lua_State);
@@ -141,10 +150,13 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
     }
 
     // set all builtin metatables to read-only
-    lua_pushliteral(L, "");
-    lua_getmetatable(L, -1);
-    lua_setreadonly(L, -1, enabled);
-    lua_pop(L, 2);
+    lua_pushliteral(L, c"");
+    if lua_getmetatable(L, -1) != 0 {
+        lua_setreadonly(L, -1, enabled);
+        lua_pop(L, 2);
+    } else {
+        lua_pop(L, 1);
+    }
 
     // set globals to readonly and activate safeenv since the env is immutable
     lua_setreadonly(L, LUA_GLOBALSINDEX, enabled);
@@ -152,5 +164,48 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
 }
 
 //
-// TODO: Generic Buffer Manipulation
+// Generic Buffer Manipulation
 //
+
+/// Buffer size used for on-stack string operations. This limit depends on native stack size.
+pub const LUA_BUFFERSIZE: usize = 512;
+
+#[repr(C)]
+pub struct luaL_Strbuf {
+    p: *mut c_char,   // current position in buffer
+    end: *mut c_char, // end of the current buffer
+    L: *mut lua_State,
+    storage: *mut c_void, // TString
+    buffer: [c_char; LUA_BUFFERSIZE],
+}
+
+// For compatibility
+pub type luaL_Buffer = luaL_Strbuf;
+
+unsafe extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Strbuf);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_prepbuffsize(B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Strbuf, s: *const c_char, l: usize);
+    pub fn luaL_addvalue(B: *mut luaL_Strbuf);
+    pub fn luaL_addvalueany(B: *mut luaL_Strbuf, idx: c_int);
+    pub fn luaL_pushresult(B: *mut luaL_Strbuf);
+    pub fn luaL_pushresultsize(B: *mut luaL_Strbuf, size: usize);
+}
+
+pub unsafe fn luaL_addchar(B: *mut luaL_Strbuf, c: c_char) {
+    if (*B).p >= (*B).end {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).p = c;
+    (*B).p = (*B).p.add(1);
+}
+
+pub unsafe fn luaL_addstring(B: *mut luaL_Strbuf, s: *const c_char) {
+    // Calculate length of s
+    let mut len = 0;
+    while *s.add(len) != 0 {
+        len += 1;
+    }
+    luaL_addlstring(B, s, len);
+}

mlua-sys/src/luau/lua.rs

@@ -1,18 +1,28 @@
 //! Contains definitions from `lua.h`.
 
+use std::ffi::CStr;
 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_float, c_int, c_uint, c_void};
-use std::ptr;
+use std::{mem, ptr};
 
 // Option for multiple returns in 'lua_pcall' and 'lua_call'
 pub const LUA_MULTRET: c_int = -1;
 
+// Max number of Lua stack slots
+const LUAI_MAXCSTACK: c_int = 1000000;
+
+// Number of valid Lua userdata tags
+pub const LUA_UTAG_LIMIT: c_int = 128;
+
+// Number of valid Lua lightuserdata tags
+pub const LUA_LUTAG_LIMIT: c_int = 128;
+
 //
 // 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
@@ -52,6 +62,7 @@ pub const LUA_TTABLE: c_int = 6;
 pub const LUA_TFUNCTION: c_int = 7;
 pub const LUA_TUSERDATA: c_int = 8;
 pub const LUA_TTHREAD: c_int = 9;
+pub const LUA_TBUFFER: c_int = 10;
 
 /// Guaranteed number of Lua stack slots available to a C function.
 pub const LUA_MINSTACK: c_int = 20;
@@ -59,28 +70,32 @@ pub const LUA_MINSTACK: c_int = 20;
 /// A Lua number, usually equivalent to `f64`.
 pub type lua_Number = c_double;
 
-/// A Lua integer, equivalent to `i32`.
-pub type lua_Integer = c_int;
+/// A Lua integer, usually equivalent to `i64`
+#[cfg(target_pointer_width = "32")]
+pub type lua_Integer = i32;
+#[cfg(target_pointer_width = "64")]
+pub type lua_Integer = i64;
 
 /// A Lua unsigned integer, equivalent to `u32`.
 pub type lua_Unsigned = c_uint;
 
 /// Type for native C functions that can be passed to Lua.
-pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
-pub type lua_Continuation = unsafe extern "C" fn(L: *mut lua_State, status: c_int) -> c_int;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
+pub type lua_Continuation = unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int) -> c_int;
 
-/// Type for userdata destructor functions.
-pub type lua_Udestructor = unsafe extern "C" fn(*mut c_void);
+/// Type for userdata destructor functions (no unwinding).
+pub type lua_Destructor = unsafe extern "C" fn(L: *mut lua_State, *mut c_void);
 
-/// Type for memory-allocation functions.
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
+/// Type for memory-allocation functions (no unwinding).
+pub type lua_Alloc =
+    unsafe extern "C" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
 
-extern "C" {
+/// Returns Luau release version (eg. `0.xxx`).
+pub const fn luau_version() -> Option<&'static str> {
+    option_env!("LUAU_VERSION")
+}
+
+unsafe extern "C-unwind" {
     //
     // State manipulation
     //
@@ -124,7 +139,7 @@ extern "C" {
 
     pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
     #[link_name = "lua_tointegerx"]
-    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> c_int;
     pub fn lua_tounsignedx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Unsigned;
     pub fn lua_tovector(L: *mut lua_State, idx: c_int) -> *const c_float;
     pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
@@ -134,10 +149,13 @@ extern "C" {
     pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
     pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
     pub fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tolightuserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
     pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
     pub fn lua_touserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
     pub fn lua_userdatatag(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_lightuserdatatag(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_tobuffer(L: *mut lua_State, idx: c_int, len: *mut usize) -> *mut c_void;
     pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
 
     //
@@ -145,9 +163,13 @@ extern "C" {
     //
     pub fn lua_pushnil(L: *mut lua_State);
     pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
-    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    #[link_name = "lua_pushinteger"]
+    pub fn lua_pushinteger_(L: *mut lua_State, n: c_int);
     pub fn lua_pushunsigned(L: *mut lua_State, n: lua_Unsigned);
+    #[cfg(not(feature = "luau-vector4"))]
     pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float);
+    #[cfg(feature = "luau-vector4")]
+    pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float, w: c_float);
     #[link_name = "lua_pushlstring"]
     pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize);
     #[link_name = "lua_pushstring"]
@@ -165,9 +187,12 @@ extern "C" {
     pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
     pub fn lua_pushthread(L: *mut lua_State) -> c_int;
 
-    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushlightuserdatatagged(L: *mut lua_State, p: *mut c_void, tag: c_int);
     pub fn lua_newuserdatatagged(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
-    pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Udestructor) -> *mut c_void;
+    pub fn lua_newuserdatataggedwithmetatable(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
+    pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Destructor) -> *mut c_void;
+
+    pub fn lua_newbuffer(L: *mut lua_State, sz: usize) -> *mut c_void;
 
     //
     // Get functions (Lua -> stack)
@@ -210,6 +235,7 @@ extern "C" {
     ) -> c_int;
     pub fn lua_call(L: *mut lua_State, nargs: c_int, nresults: c_int);
     pub fn lua_pcall(L: *mut lua_State, nargs: c_int, nresults: c_int, errfunc: c_int) -> c_int;
+    pub fn lua_cpcall(L: *mut lua_State, f: lua_CFunction, ud: *mut c_void) -> c_int;
 
     //
     // Coroutine functions
@@ -239,14 +265,14 @@ pub const LUA_GCSETGOAL: c_int = 7;
 pub const LUA_GCSETSTEPMUL: c_int = 8;
 pub const LUA_GCSETSTEPSIZE: c_int = 9;
 
-extern "C" {
+unsafe extern "C-unwind" {
     pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }
 
 //
 // Memory statistics
 //
-extern "C" {
+unsafe extern "C-unwind" {
     pub fn lua_setmemcat(L: *mut lua_State, category: c_int);
     pub fn lua_totalbytes(L: *mut lua_State, category: c_int) -> usize;
 }
@@ -254,18 +280,23 @@ extern "C" {
 //
 // Miscellaneous functions
 //
-extern "C" {
+unsafe extern "C-unwind" {
     pub fn lua_error(L: *mut lua_State) -> !;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawiter(L: *mut lua_State, idx: c_int, iter: c_int) -> c_int;
     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<unsafe extern "C" fn(*mut lua_State, *mut c_void)>,
-    );
+    pub fn lua_setuserdatatag(L: *mut lua_State, idx: c_int, tag: c_int);
+    pub fn lua_setuserdatadtor(L: *mut lua_State, tag: c_int, dtor: Option<lua_Destructor>);
+    pub fn lua_getuserdatadtor(L: *mut lua_State, tag: c_int) -> Option<lua_Destructor>;
+    pub fn lua_setuserdatametatable(L: *mut lua_State, tag: c_int);
+    pub fn lua_getuserdatametatable(L: *mut lua_State, tag: c_int);
+    pub fn lua_setlightuserdataname(L: *mut lua_State, tag: c_int, name: *const c_char);
+    pub fn lua_getlightuserdataname(L: *mut lua_State, tag: c_int) -> *const c_char;
     pub fn lua_clonefunction(L: *mut lua_State, idx: c_int);
+    pub fn lua_cleartable(L: *mut lua_State, idx: c_int);
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
 }
 
 //
@@ -274,7 +305,7 @@ extern "C" {
 pub const LUA_NOREF: c_int = -1;
 pub const LUA_REFNIL: c_int = 0;
 
-extern "C" {
+unsafe extern "C-unwind" {
     pub fn lua_ref(L: *mut lua_State, idx: c_int) -> c_int;
     pub fn lua_unref(L: *mut lua_State, r#ref: c_int);
 }
@@ -284,13 +315,13 @@ extern "C" {
 //
 
 #[inline(always)]
-pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
-    lua_tonumberx(L, i, ptr::null_mut())
+pub unsafe fn lua_tonumber(L: *mut lua_State, idx: c_int) -> lua_Number {
+    lua_tonumberx(L, idx, ptr::null_mut())
 }
 
 #[inline(always)]
-pub unsafe fn lua_tointeger_(L: *mut lua_State, i: c_int) -> lua_Integer {
-    lua_tointegerx_(L, i, ptr::null_mut())
+pub unsafe fn lua_tointeger_(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_tointegerx_(L, idx, ptr::null_mut())
 }
 
 #[inline(always)]
@@ -313,6 +344,17 @@ pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
     lua_newuserdatatagged(L, sz, 0)
 }
 
+#[inline(always)]
+pub unsafe fn lua_newuserdata_t<T>(L: *mut lua_State, data: T) -> *mut T {
+    unsafe extern "C" fn destructor<T>(_: *mut lua_State, ud: *mut c_void) {
+        ptr::drop_in_place(ud as *mut T);
+    }
+
+    let ud_ptr = lua_newuserdatadtor(L, const { mem::size_of::<T>() }, destructor::<T>) as *mut T;
+    ptr::write(ud_ptr, data);
+    ud_ptr
+}
+
 // TODO: lua_strlen
 
 #[inline(always)]
@@ -350,6 +392,11 @@ pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
     (lua_type(L, n) == LUA_TTHREAD) as c_int
 }
 
+#[inline(always)]
+pub unsafe fn lua_isbuffer(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBUFFER) as c_int
+}
+
 #[inline(always)]
 pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
     (lua_type(L, n) == LUA_TNONE) as c_int
@@ -361,33 +408,35 @@ pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
 }
 
 #[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static CStr) {
+    lua_pushstring_(L, s.as_ptr());
 }
 
+#[inline(always)]
 pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
     lua_pushcclosurek(L, f, ptr::null(), 0, None)
 }
 
+#[inline(always)]
 pub unsafe fn lua_pushcfunctiond(L: *mut lua_State, f: lua_CFunction, debugname: *const c_char) {
     lua_pushcclosurek(L, f, debugname, 0, None)
 }
 
+#[inline(always)]
 pub unsafe fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, nup: c_int) {
     lua_pushcclosurek(L, f, ptr::null(), nup, None)
 }
 
-pub unsafe fn lua_pushcclosured(
-    L: *mut lua_State,
-    f: lua_CFunction,
-    debugname: *const c_char,
-    nup: c_int,
-) {
+#[inline(always)]
+pub unsafe fn lua_pushcclosured(L: *mut lua_State, f: lua_CFunction, debugname: *const c_char, nup: c_int) {
     lua_pushcclosurek(L, f, debugname, nup, None)
 }
 
+#[inline(always)]
+pub unsafe fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void) {
+    lua_pushlightuserdatatagged(L, p, 0)
+}
+
 #[inline(always)]
 pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
     lua_setfield(L, LUA_GLOBALSINDEX, var)
@@ -411,9 +460,9 @@ pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
 const LUA_IDSIZE: usize = 256;
 
 /// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
 
-pub type lua_Coverage = unsafe extern "C" fn(
+pub type lua_Coverage = unsafe extern "C-unwind" fn(
     context: *mut c_void,
     function: *const c_char,
     linedefined: c_int,
@@ -422,14 +471,9 @@ pub type lua_Coverage = unsafe extern "C" fn(
     size: usize,
 );
 
-extern "C" {
+unsafe extern "C-unwind" {
     pub fn lua_stackdepth(L: *mut lua_State) -> c_int;
-    pub fn lua_getinfo(
-        L: *mut lua_State,
-        level: c_int,
-        what: *const c_char,
-        ar: *mut lua_Debug,
-    ) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, level: c_int, what: *const c_char, ar: *mut lua_Debug) -> c_int;
     pub fn lua_getargument(L: *mut lua_State, level: c_int, n: c_int) -> c_int;
     pub fn lua_getlocal(L: *mut lua_State, level: c_int, n: c_int) -> *const c_char;
     pub fn lua_setlocal(L: *mut lua_State, level: c_int, n: c_int) -> *const c_char;
@@ -437,14 +481,9 @@ 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,
-        funcindex: c_int,
-        context: *mut c_void,
-        callback: lua_Coverage,
-    );
+    pub fn lua_getcoverage(L: *mut lua_State, funcindex: c_int, context: *mut c_void, callback: lua_Coverage);
 
     pub fn lua_debugtrace(L: *mut lua_State) -> *const c_char;
 }
@@ -454,13 +493,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],
 }
 
 //
@@ -469,30 +509,40 @@ pub struct lua_Debug {
 //
 
 #[repr(C)]
+#[non_exhaustive]
 pub struct lua_Callbacks {
     /// arbitrary userdata pointer that is never overwritten by Luau
     pub userdata: *mut c_void,
 
     /// gets called at safepoints (loop back edges, call/ret, gc) if set
-    pub interrupt: Option<unsafe extern "C" fn(L: *mut lua_State, gc: c_int)>,
+    pub interrupt: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, gc: c_int)>,
     /// gets called when an unprotected error is raised (if longjmp is used)
-    pub panic: Option<unsafe extern "C" fn(L: *mut lua_State, errcode: c_int)>,
+    pub panic: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, errcode: c_int)>,
 
     /// gets called when L is created (LP == parent) or destroyed (LP == NULL)
-    pub userthread: Option<unsafe extern "C" fn(LP: *mut lua_State, L: *mut lua_State)>,
+    pub userthread: Option<unsafe extern "C-unwind" fn(LP: *mut lua_State, L: *mut lua_State)>,
     /// gets called when a string is created; returned atom can be retrieved via tostringatom
-    pub useratom: Option<unsafe extern "C" fn(s: *const c_char, l: usize) -> i16>,
+    pub useratom: Option<unsafe extern "C-unwind" fn(s: *const c_char, l: usize) -> i16>,
 
     /// gets called when BREAK instruction is encountered
-    pub debugbreak: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    pub debugbreak: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
     /// gets called after each instruction in single step mode
-    pub debugstep: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    pub debugstep: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
     /// gets called when thread execution is interrupted by break in another thread
-    pub debuginterrupt: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    pub debuginterrupt: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
     /// gets called when protected call results in an error
-    pub debugprotectederror: Option<unsafe extern "C" fn(L: *mut lua_State)>,
+    pub debugprotectederror: Option<unsafe extern "C-unwind" fn(L: *mut lua_State)>,
+
+    /// gets called when memory is allocated
+    pub onallocate: Option<unsafe extern "C-unwind" fn(L: *mut lua_State, osize: usize, nsize: usize)>,
 }
 
-extern "C" {
+unsafe extern "C" {
     pub fn lua_callbacks(L: *mut lua_State) -> *mut lua_Callbacks;
 }
+
+// Functions from customization lib
+unsafe extern "C" {
+    pub fn luau_setfflag(name: *const c_char, value: c_int) -> c_int;
+    pub fn lua_getmetatablepointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+}

mlua-sys/src/luau/luacode.rs

@@ -0,0 +1,113 @@
+//! Contains definitions from `luacode.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_int, c_void};
+use std::{ptr, slice};
+
+#[repr(C)]
+#[non_exhaustive]
+pub struct lua_CompileOptions {
+    pub optimizationLevel: c_int,
+    pub debugLevel: c_int,
+    pub typeInfoLevel: c_int,
+    pub coverageLevel: c_int,
+    pub vectorLib: *const c_char,
+    pub vectorCtor: *const c_char,
+    pub vectorType: *const c_char,
+    pub mutableGlobals: *const *const c_char,
+    pub userdataTypes: *const *const c_char,
+    pub librariesWithKnownMembers: *const *const c_char,
+    pub libraryMemberTypeCallback: Option<lua_LibraryMemberTypeCallback>,
+    pub libraryMemberConstantCallback: Option<lua_LibraryMemberConstantCallback>,
+    pub disabledBuiltins: *const *const c_char,
+}
+
+impl Default for lua_CompileOptions {
+    fn default() -> Self {
+        Self {
+            optimizationLevel: 1,
+            debugLevel: 1,
+            typeInfoLevel: 0,
+            coverageLevel: 0,
+            vectorLib: ptr::null(),
+            vectorCtor: ptr::null(),
+            vectorType: ptr::null(),
+            mutableGlobals: ptr::null(),
+            userdataTypes: ptr::null(),
+            librariesWithKnownMembers: ptr::null(),
+            libraryMemberTypeCallback: None,
+            libraryMemberConstantCallback: None,
+            disabledBuiltins: ptr::null(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct lua_CompileConstant {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+/// Type table tags
+#[doc(hidden)]
+#[repr(i32)]
+#[non_exhaustive]
+pub enum luau_BytecodeType {
+    Nil = 0,
+    Boolean,
+    Number,
+    String,
+    Table,
+    Function,
+    Thread,
+    UserData,
+    Vector,
+    Buffer,
+
+    Any = 15,
+}
+
+pub type lua_LibraryMemberTypeCallback =
+    unsafe extern "C-unwind" fn(library: *const c_char, member: *const c_char) -> c_int;
+
+pub type lua_LibraryMemberConstantCallback = unsafe extern "C-unwind" fn(
+    library: *const c_char,
+    member: *const c_char,
+    constant: *mut lua_CompileConstant,
+);
+
+unsafe extern "C" {
+    pub fn luau_set_compile_constant_nil(cons: *mut lua_CompileConstant);
+    pub fn luau_set_compile_constant_boolean(cons: *mut lua_CompileConstant, b: c_int);
+    pub fn luau_set_compile_constant_number(cons: *mut lua_CompileConstant, n: f64);
+    pub fn luau_set_compile_constant_vector(cons: *mut lua_CompileConstant, x: f32, y: f32, z: f32, w: f32);
+    pub fn luau_set_compile_constant_string(cons: *mut lua_CompileConstant, s: *const c_char, l: usize);
+}
+
+unsafe extern "C-unwind" {
+    #[link_name = "luau_compile"]
+    pub fn luau_compile_(
+        source: *const c_char,
+        size: usize,
+        options: *mut lua_CompileOptions,
+        outsize: *mut usize,
+    ) -> *mut c_char;
+}
+
+unsafe extern "C" {
+    fn free(p: *mut c_void);
+}
+
+pub unsafe fn luau_compile(source: &[u8], mut options: lua_CompileOptions) -> Vec<u8> {
+    let mut outsize = 0;
+    let data_ptr = luau_compile_(
+        source.as_ptr() as *const c_char,
+        source.len(),
+        &mut options,
+        &mut outsize,
+    );
+    assert!(!data_ptr.is_null(), "luau_compile failed");
+    let data = slice::from_raw_parts(data_ptr as *mut u8, outsize).to_vec();
+    free(data_ptr as *mut c_void);
+    data
+}

mlua-sys/src/luau/luacodegen.rs

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

mlua-sys/src/luau/lualib.rs

@@ -0,0 +1,33 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::{c_char, c_int};
+
+use super::lua::lua_State;
+
+pub const LUA_COLIBNAME: *const c_char = cstr!("coroutine");
+pub const LUA_TABLIBNAME: *const c_char = cstr!("table");
+pub const LUA_OSLIBNAME: *const c_char = cstr!("os");
+pub const LUA_STRLIBNAME: *const c_char = cstr!("string");
+pub const LUA_BITLIBNAME: *const c_char = cstr!("bit32");
+pub const LUA_BUFFERLIBNAME: *const c_char = cstr!("buffer");
+pub const LUA_UTF8LIBNAME: *const c_char = cstr!("utf8");
+pub const LUA_MATHLIBNAME: *const c_char = cstr!("math");
+pub const LUA_DBLIBNAME: *const c_char = cstr!("debug");
+pub const LUA_VECLIBNAME: *const c_char = cstr!("vector");
+
+unsafe extern "C-unwind" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
+    pub fn luaopen_buffer(L: *mut lua_State) -> c_int;
+    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+    pub fn luaopen_vector(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}

mlua-sys/src/luau/luarequire.rs

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

mlua-sys/src/luau/mod.rs

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

mlua-sys/src/macros.rs

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

mlua_derive/Cargo.toml

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

mlua_derive/src/from_lua.rs

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

mlua_derive/src/lib.rs

@@ -1,38 +1,73 @@
 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 {
     crate::chunk::Chunk, proc_macro::TokenTree, proc_macro2::TokenStream as TokenStream2,
-    proc_macro_error::proc_macro_error,
+    proc_macro_error2::proc_macro_error,
 };
 
+#[derive(Default)]
+struct ModuleAttributes {
+    name: Option<Ident>,
+    skip_memory_check: bool,
+}
+
+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 if meta.path.is_ident("skip_memory_check") {
+            if meta.value().is_ok() {
+                return Err(meta.error("`skip_memory_check` attribute have no values"));
+            }
+            self.skip_memory_check = true;
+        } else {
+            return Err(meta.error("unsupported module attribute"));
+        }
+        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_name = func.sig.ident.clone();
-    let ext_entrypoint_name = Ident::new(&format!("luaopen_{}", func_name), Span::call_site());
+    let func = parse_macro_input!(item as ItemFn);
+    let func_name = &func.sig.ident;
+    let module_name = args.name.unwrap_or_else(|| func_name.clone());
+    let ext_entrypoint_name = Ident::new(&format!("luaopen_{module_name}"), Span::call_site());
+    let skip_memory_check = if args.skip_memory_check {
+        quote! { lua.skip_memory_check(true); }
+    } else {
+        quote! {}
+    };
 
     let wrapped = quote! {
-        ::mlua::require_module_feature!();
+        mlua::require_module_feature!();
 
         #func
 
         #[no_mangle]
-        unsafe extern "C" fn #ext_entrypoint_name(state: *mut ::mlua::lua_State) -> ::std::os::raw::c_int {
-            ::mlua::Lua::init_from_ptr(state)
-                .entrypoint1(#func_name)
-                .expect("cannot initialize module")
+        unsafe extern "C-unwind" fn #ext_entrypoint_name(state: *mut mlua::lua_State) -> ::std::os::raw::c_int {
+            mlua::Lua::entrypoint1(state, move |lua| {
+                #skip_memory_check
+                #func_name(lua)
+            })
         }
     };
 
@@ -61,30 +96,21 @@ pub fn chunk(input: TokenStream) -> TokenStream {
     });
 
     let wrapped_code = quote! {{
-        use ::mlua::{AsChunk, ChunkMode, Lua, Result, Value};
+        use mlua::{AsChunk, ChunkMode, Lua, Result, Table};
         use ::std::borrow::Cow;
+        use ::std::cell::Cell;
         use ::std::io::Result as IoResult;
-        use ::std::marker::PhantomData;
-        use ::std::sync::Mutex;
 
-        fn annotate<'a, F: FnOnce(&'a Lua) -> Result<Value<'a>>>(f: F) -> F { f }
+        struct InnerChunk<F: FnOnce(&Lua) -> Result<Table>>(Cell<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 for InnerChunk<F>
         where
-            F: FnOnce(&'lua Lua) -> Result<Value<'lua>>,
+            F: FnOnce(&Lua) -> Result<Table>,
         {
-            fn source(&self) -> IoResult<Cow<[u8]>> {
-                Ok(Cow::Borrowed((#source).as_bytes()))
-            }
-
-            fn env(&self, lua: &'lua Lua) -> Result<Option<Value<'lua>>> {
+            fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
                 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);
-                        }
+                    if let Some(make_env) = self.0.take() {
+                        return make_env(lua).map(Some);
                     }
                 }
                 Ok(None)
@@ -93,29 +119,41 @@ pub fn chunk(input: TokenStream) -> TokenStream {
             fn mode(&self) -> Option<ChunkMode> {
                 Some(ChunkMode::Text)
             }
+
+            fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+                Ok(Cow::Borrowed((#source).as_bytes()))
+            }
         }
 
-        let make_env = annotate(move |lua: &Lua| -> Result<Value> {
+        let make_env = move |lua: &Lua| -> Result<Table> {
             let globals = lua.globals();
             let env = lua.create_table()?;
             let meta = lua.create_table()?;
-            meta.raw_set("__index", globals.clone())?;
-            meta.raw_set("__newindex", globals)?;
+            meta.raw_set("__index", &globals)?;
+            meta.raw_set("__newindex", &globals)?;
 
             // Add captured variables
             #(#caps)*
 
-            env.set_metatable(Some(meta));
-            Ok(Value::Table(env))
-        });
+            env.set_metatable(Some(meta))?;
+            Ok(env)
+        };
 
-        &InnerChunk(Mutex::new(Some(make_env)), PhantomData)
+        InnerChunk(Cell::new(Some(make_env)))
     }};
 
     wrapped_code.into()
 }
 
+#[cfg(feature = "macros")]
+#[proc_macro_derive(FromLua)]
+pub fn from_lua(input: TokenStream) -> TokenStream {
+    from_lua::from_lua(input)
+}
+
 #[cfg(feature = "macros")]
 mod chunk;
 #[cfg(feature = "macros")]
+mod from_lua;
+#[cfg(feature = "macros")]
 mod token;

mlua_derive/src/token.rs

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

rustfmt.toml

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

src/buffer.rs

@@ -0,0 +1,167 @@
+use std::io;
+
+#[cfg(feature = "serde")]
+use serde::ser::{Serialize, Serializer};
+
+use crate::state::RawLua;
+use crate::types::ValueRef;
+
+/// A Luau buffer type.
+///
+/// See the buffer [documentation] for more information.
+///
+/// [documentation]: https://luau.org/library#buffer-library
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Debug, PartialEq)]
+pub struct Buffer(pub(crate) ValueRef);
+
+#[cfg_attr(not(feature = "luau"), allow(unused))]
+impl Buffer {
+    /// Copies the buffer data into a new `Vec<u8>`.
+    pub fn to_vec(&self) -> Vec<u8> {
+        let lua = self.0.lua.lock();
+        self.as_slice(&lua).to_vec()
+    }
+
+    /// Returns the length of the buffer.
+    pub fn len(&self) -> usize {
+        let lua = self.0.lua.lock();
+        self.as_slice(&lua).len()
+    }
+
+    /// Returns `true` if the buffer is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Reads given number of bytes from the buffer at the given offset.
+    ///
+    /// Offset is 0-based.
+    #[track_caller]
+    pub fn read_bytes<const N: usize>(&self, offset: usize) -> [u8; N] {
+        let lua = self.0.lua.lock();
+        let data = self.as_slice(&lua);
+        let mut bytes = [0u8; N];
+        bytes.copy_from_slice(&data[offset..offset + N]);
+        bytes
+    }
+
+    /// Writes given bytes to the buffer at the given offset.
+    ///
+    /// Offset is 0-based.
+    #[track_caller]
+    pub fn write_bytes(&self, offset: usize, bytes: &[u8]) {
+        let lua = self.0.lua.lock();
+        let data = self.as_slice_mut(&lua);
+        data[offset..offset + bytes.len()].copy_from_slice(bytes);
+    }
+
+    /// Returns an adaptor implementing [`io::Read`], [`io::Write`] and [`io::Seek`] over the
+    /// buffer.
+    ///
+    /// Buffer operations are infallible, none of the read/write functions will return a Err.
+    pub fn cursor(self) -> impl io::Read + io::Write + io::Seek {
+        BufferCursor(self, 0)
+    }
+
+    pub(crate) fn as_slice(&self, lua: &RawLua) -> &[u8] {
+        unsafe {
+            let (buf, size) = self.as_raw_parts(lua);
+            std::slice::from_raw_parts(buf, size)
+        }
+    }
+
+    #[allow(clippy::mut_from_ref)]
+    fn as_slice_mut(&self, lua: &RawLua) -> &mut [u8] {
+        unsafe {
+            let (buf, size) = self.as_raw_parts(lua);
+            std::slice::from_raw_parts_mut(buf, size)
+        }
+    }
+
+    #[cfg(feature = "luau")]
+    unsafe fn as_raw_parts(&self, lua: &RawLua) -> (*mut u8, usize) {
+        let mut size = 0usize;
+        let buf = ffi::lua_tobuffer(lua.ref_thread(), self.0.index, &mut size);
+        mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+        (buf as *mut u8, size)
+    }
+
+    #[cfg(not(feature = "luau"))]
+    unsafe fn as_raw_parts(&self, lua: &RawLua) -> (*mut u8, usize) {
+        unreachable!()
+    }
+}
+
+struct BufferCursor(Buffer, usize);
+
+impl io::Read for BufferCursor {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let lua = self.0 .0.lua.lock();
+        let data = self.0.as_slice(&lua);
+        if self.1 == data.len() {
+            return Ok(0);
+        }
+        let len = buf.len().min(data.len() - self.1);
+        buf[..len].copy_from_slice(&data[self.1..self.1 + len]);
+        self.1 += len;
+        Ok(len)
+    }
+}
+
+impl io::Write for BufferCursor {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let lua = self.0 .0.lua.lock();
+        let data = self.0.as_slice_mut(&lua);
+        if self.1 == data.len() {
+            return Ok(0);
+        }
+        let len = buf.len().min(data.len() - self.1);
+        data[self.1..self.1 + len].copy_from_slice(&buf[..len]);
+        self.1 += len;
+        Ok(len)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl io::Seek for BufferCursor {
+    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
+        let lua = self.0 .0.lua.lock();
+        let data = self.0.as_slice(&lua);
+        let new_offset = match pos {
+            io::SeekFrom::Start(offset) => offset as i64,
+            io::SeekFrom::End(offset) => data.len() as i64 + offset,
+            io::SeekFrom::Current(offset) => self.1 as i64 + offset,
+        };
+        if new_offset < 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid seek to a negative position",
+            ));
+        }
+        if new_offset as usize > data.len() {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid seek to a position beyond the end of the buffer",
+            ));
+        }
+        self.1 = new_offset as usize;
+        Ok(self.1 as u64)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Buffer {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        let lua = self.0.lua.lock();
+        serializer.serialize_bytes(self.as_slice(&lua))
+    }
+}
+
+#[cfg(feature = "luau")]
+impl crate::types::LuaType for Buffer {
+    const TYPE_ID: std::os::raw::c_int = ffi::LUA_TBUFFER;
+}

src/chunk.rs

@@ -2,27 +2,24 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::ffi::CString;
 use std::io::Result as IoResult;
+use std::panic::Location;
 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};
-
-#[cfg(feature = "async")]
-use {futures_core::future::LocalBoxFuture, futures_util::future};
+use crate::state::{Lua, WeakLua};
+use crate::table::Table;
+use crate::traits::{FromLuaMulti, IntoLua, IntoLuaMulti};
+use crate::value::Value;
 
 /// Trait for types [loadable by Lua] and convertible to a [`Chunk`]
 ///
 /// [loadable by Lua]: https://www.lua.org/manual/5.4/manual.html#3.3.2
-/// [`Chunk`]: crate::Chunk
-pub trait AsChunk<'lua> {
-    /// Returns chunk data (can be text or binary)
-    fn source(&self) -> IoResult<Cow<[u8]>>;
-
+pub trait AsChunk {
     /// Returns optional chunk name
+    ///
+    /// See [`Chunk::set_name`] for possible name prefixes.
     fn name(&self) -> Option<StdString> {
         None
     }
@@ -30,7 +27,8 @@ pub trait AsChunk<'lua> {
     /// 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>>> {
+    fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
+        let _lua = lua; // suppress warning
         Ok(None)
     }
 
@@ -38,62 +36,110 @@ pub trait AsChunk<'lua> {
     fn mode(&self) -> Option<ChunkMode> {
         None
     }
+
+    /// Returns chunk data (can be text or binary)
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a;
 }
 
-impl<'lua> AsChunk<'lua> for str {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
-        Ok(Cow::Borrowed(self.as_ref()))
+impl AsChunk for &str {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
+        Ok(Cow::Borrowed(self.as_bytes()))
     }
 }
 
-impl<'lua> AsChunk<'lua> for StdString {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
-        Ok(Cow::Borrowed(self.as_ref()))
+impl AsChunk for StdString {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Owned(self.clone().into_bytes()))
     }
 }
 
-impl<'lua> AsChunk<'lua> for [u8] {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
+impl AsChunk for &StdString {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
+        Ok(Cow::Borrowed(self.as_bytes()))
+    }
+}
+
+impl AsChunk for &[u8] {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
         Ok(Cow::Borrowed(self))
     }
 }
 
-impl<'lua> AsChunk<'lua> for Vec<u8> {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
+impl AsChunk for Vec<u8> {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Owned(self.clone()))
+    }
+}
+
+impl AsChunk for &Vec<u8> {
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
         Ok(Cow::Borrowed(self))
     }
 }
 
-impl<'lua> AsChunk<'lua> for Path {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
-        std::fs::read(self).map(Cow::Owned)
-    }
-
+impl AsChunk for &Path {
     fn name(&self) -> Option<StdString> {
         Some(format!("@{}", self.display()))
     }
+
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+        std::fs::read(self).map(Cow::Owned)
+    }
 }
 
-impl<'lua> AsChunk<'lua> for PathBuf {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
-        std::fs::read(self).map(Cow::Owned)
-    }
-
+impl AsChunk for PathBuf {
     fn name(&self) -> Option<StdString> {
         Some(format!("@{}", self.display()))
     }
+
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>> {
+        std::fs::read(self).map(Cow::Owned)
+    }
+}
+
+impl<C: AsChunk + ?Sized> AsChunk for Box<C> {
+    fn name(&self) -> Option<StdString> {
+        (**self).name()
+    }
+
+    fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
+        (**self).environment(lua)
+    }
+
+    fn mode(&self) -> Option<ChunkMode> {
+        (**self).mode()
+    }
+
+    fn source<'a>(&self) -> IoResult<Cow<'a, [u8]>>
+    where
+        Self: 'a,
+    {
+        (**self).source()
+    }
 }
 
 /// Returned from [`Lua::load`] and is used to finalize loading and executing Lua main chunks.
-///
-/// [`Lua::load`]: crate::Lua::load
 #[must_use = "`Chunk`s do nothing unless one of `exec`, `eval`, `call`, or `into_function` are called on them"]
-pub struct Chunk<'lua, 'a> {
-    pub(crate) lua: &'lua Lua,
-    pub(crate) source: IoResult<Cow<'a, [u8]>>,
-    pub(crate) name: Option<StdString>,
-    pub(crate) env: Result<Option<Value<'lua>>>,
+pub struct Chunk<'a> {
+    pub(crate) lua: WeakLua,
+    pub(crate) name: StdString,
+    pub(crate) env: Result<Option<Table>>,
     pub(crate) mode: Option<ChunkMode>,
+    pub(crate) source: IoResult<Cow<'a, [u8]>>,
     #[cfg(feature = "luau")]
     pub(crate) compiler: Option<Compiler>,
 }
@@ -105,6 +151,49 @@ pub enum ChunkMode {
     Binary,
 }
 
+/// Represents a constant value that can be used by Luau compiler.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Debug)]
+pub enum CompileConstant {
+    Nil,
+    Boolean(bool),
+    Number(crate::Number),
+    Vector(crate::Vector),
+    String(StdString),
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<bool> for CompileConstant {
+    fn from(b: bool) -> Self {
+        CompileConstant::Boolean(b)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<crate::Number> for CompileConstant {
+    fn from(n: crate::Number) -> Self {
+        CompileConstant::Number(n)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<crate::Vector> for CompileConstant {
+    fn from(v: crate::Vector) -> Self {
+        CompileConstant::Vector(v)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<&str> for CompileConstant {
+    fn from(s: &str) -> Self {
+        CompileConstant::String(s.to_owned())
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+type LibraryMemberConstantMap = HashMap<(StdString, StdString), CompileConstant>;
+
 /// Luau compiler
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
@@ -112,32 +201,44 @@ pub enum ChunkMode {
 pub struct Compiler {
     optimization_level: u8,
     debug_level: u8,
+    type_info_level: u8,
     coverage_level: u8,
-    vector_lib: Option<String>,
-    vector_ctor: Option<String>,
-    mutable_globals: Vec<String>,
+    vector_lib: Option<StdString>,
+    vector_ctor: Option<StdString>,
+    vector_type: Option<StdString>,
+    mutable_globals: Vec<StdString>,
+    userdata_types: Vec<StdString>,
+    libraries_with_known_members: Vec<StdString>,
+    library_constants: Option<LibraryMemberConstantMap>,
+    disabled_builtins: Vec<StdString>,
 }
 
 #[cfg(any(feature = "luau", doc))]
 impl Default for Compiler {
     fn default() -> Self {
-        // Defaults are taken from luacode.h
-        Compiler {
-            optimization_level: 1,
-            debug_level: 1,
-            coverage_level: 0,
-            vector_lib: None,
-            vector_ctor: None,
-            mutable_globals: Vec::new(),
-        }
+        const { Self::new() }
     }
 }
 
 #[cfg(any(feature = "luau", doc))]
 impl Compiler {
     /// Creates Luau compiler instance with default options
-    pub fn new() -> Self {
-        Compiler::default()
+    pub const fn new() -> Self {
+        // Defaults are taken from luacode.h
+        Compiler {
+            optimization_level: 1,
+            debug_level: 1,
+            type_info_level: 0,
+            coverage_level: 0,
+            vector_lib: None,
+            vector_ctor: None,
+            vector_type: None,
+            mutable_globals: Vec::new(),
+            userdata_types: Vec::new(),
+            libraries_with_known_members: Vec::new(),
+            library_constants: None,
+            disabled_builtins: Vec::new(),
+        }
     }
 
     /// Sets Luau compiler optimization level.
@@ -146,7 +247,8 @@ impl Compiler {
     /// * 0 - no optimization
     /// * 1 - baseline optimization level that doesn't prevent debuggability (default)
     /// * 2 - includes optimizations that harm debuggability such as inlining
-    pub fn set_optimization_level(mut self, level: u8) -> Self {
+    #[must_use]
+    pub const fn set_optimization_level(mut self, level: u8) -> Self {
         self.optimization_level = level;
         self
     }
@@ -157,45 +259,142 @@ impl Compiler {
     /// * 0 - no debugging support
     /// * 1 - line info & function names only; sufficient for backtraces (default)
     /// * 2 - full debug info with local & upvalue names; necessary for debugger
-    pub fn set_debug_level(mut self, level: u8) -> Self {
+    #[must_use]
+    pub const fn set_debug_level(mut self, level: u8) -> Self {
         self.debug_level = level;
         self
     }
 
+    /// Sets Luau type information level used to guide native code generation decisions.
+    ///
+    /// Possible values:
+    /// * 0 - generate for native modules (default)
+    /// * 1 - generate for all modules
+    #[must_use]
+    pub const fn set_type_info_level(mut self, level: u8) -> Self {
+        self.type_info_level = level;
+        self
+    }
+
     /// Sets Luau compiler code coverage level.
     ///
     /// Possible values:
     /// * 0 - no code coverage support (default)
     /// * 1 - statement coverage
     /// * 2 - statement and expression coverage (verbose)
-    pub fn set_coverage_level(mut self, level: u8) -> Self {
+    #[must_use]
+    pub const fn set_coverage_level(mut self, level: u8) -> Self {
         self.coverage_level = level;
         self
     }
 
+    /// Sets alternative global builtin to construct vectors, in addition to default builtin
+    /// `vector.create`.
+    ///
+    /// To set the library and method name, use the `lib.ctor` format.
     #[doc(hidden)]
-    pub fn set_vector_lib(mut self, lib: Option<String>) -> Self {
-        self.vector_lib = lib;
+    #[must_use]
+    pub fn set_vector_ctor(mut self, ctor: impl Into<StdString>) -> Self {
+        let ctor = ctor.into();
+        let lib_ctor = ctor.split_once('.');
+        self.vector_lib = lib_ctor.as_ref().map(|&(lib, _)| lib.to_owned());
+        self.vector_ctor = (lib_ctor.as_ref())
+            .map(|&(_, ctor)| ctor.to_owned())
+            .or(Some(ctor));
         self
     }
 
+    /// Sets alternative vector type name for type tables, in addition to default type `vector`.
     #[doc(hidden)]
-    pub fn set_vector_ctor(mut self, ctor: Option<String>) -> Self {
-        self.vector_ctor = ctor;
+    #[must_use]
+    pub fn set_vector_type(mut self, r#type: impl Into<StdString>) -> Self {
+        self.vector_type = Some(r#type.into());
+        self
+    }
+
+    /// Adds a mutable global.
+    ///
+    /// It disables the import optimization for fields accessed through it.
+    #[must_use]
+    pub fn add_mutable_global(mut self, global: impl Into<StdString>) -> Self {
+        self.mutable_globals.push(global.into());
         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;
+    #[must_use]
+    pub fn set_mutable_globals<S: Into<StdString>>(mut self, globals: impl IntoIterator<Item = S>) -> Self {
+        self.mutable_globals = globals.into_iter().map(|s| s.into()).collect();
+        self
+    }
+
+    /// Adds a userdata type to the list that will be included in the type information.
+    #[must_use]
+    pub fn add_userdata_type(mut self, r#type: impl Into<StdString>) -> Self {
+        self.userdata_types.push(r#type.into());
+        self
+    }
+
+    /// Sets a list of userdata types that will be included in the type information.
+    #[must_use]
+    pub fn set_userdata_types<S: Into<StdString>>(mut self, types: impl IntoIterator<Item = S>) -> Self {
+        self.userdata_types = types.into_iter().map(|s| s.into()).collect();
+        self
+    }
+
+    /// Adds a constant for a known library member.
+    ///
+    /// The constants are used by the compiler to optimize the generated bytecode.
+    /// Optimization level must be at least 2 for this to have any effect.
+    ///
+    /// The `name` is a string in the format `lib.member`, where `lib` is the library name
+    /// and `member` is the member (constant) name.
+    #[must_use]
+    pub fn add_library_constant(
+        mut self,
+        name: impl AsRef<str>,
+        r#const: impl Into<CompileConstant>,
+    ) -> Self {
+        let Some((lib, member)) = name.as_ref().split_once('.') else {
+            return self;
+        };
+        let (lib, member) = (lib.to_owned(), member.to_owned());
+
+        if !self.libraries_with_known_members.contains(&lib) {
+            self.libraries_with_known_members.push(lib.clone());
+        }
+        self.library_constants
+            .get_or_insert_with(HashMap::new)
+            .insert((lib, member), r#const.into());
+        self
+    }
+
+    /// Adds a builtin that should be disabled.
+    #[must_use]
+    pub fn add_disabled_builtin(mut self, builtin: impl Into<StdString>) -> Self {
+        self.disabled_builtins.push(builtin.into());
+        self
+    }
+
+    /// Sets a list of builtins that should be disabled.
+    #[must_use]
+    pub fn set_disabled_builtins<S: Into<StdString>>(
+        mut self,
+        builtins: impl IntoIterator<Item = S>,
+    ) -> Self {
+        self.disabled_builtins = builtins.into_iter().map(|s| s.into()).collect();
         self
     }
 
     /// Compiles the `source` into bytecode.
-    pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
-        use std::os::raw::c_int;
+    ///
+    /// Returns [`Error::SyntaxError`] if the source code is invalid.
+    pub fn compile(&self, source: impl AsRef<[u8]>) -> Result<Vec<u8>> {
+        use std::cell::RefCell;
+        use std::ffi::CStr;
+        use std::os::raw::{c_char, c_int};
         use std::ptr;
 
         let vector_lib = self.vector_lib.clone();
@@ -204,50 +403,130 @@ impl Compiler {
         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 vector_type = self.vector_type.clone();
+        let vector_type = vector_type.and_then(|t| CString::new(t).ok());
+        let vector_type = vector_type.as_ref();
 
-        let mutable_globals = self
-            .mutable_globals
-            .iter()
-            .map(|name| CString::new(name.clone()).ok())
-            .collect::<Option<Vec<_>>>()
-            .unwrap_or_default();
-        let mut mutable_globals = mutable_globals
-            .iter()
-            .map(|s| s.as_ptr())
-            .collect::<Vec<_>>();
-        let mut mutable_globals_ptr = ptr::null_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: 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,
+        macro_rules! vec2cstring_ptr {
+            ($name:ident, $name_ptr:ident) => {
+                let $name = self
+                    .$name
+                    .iter()
+                    .map(|name| CString::new(name.clone()).ok())
+                    .collect::<Option<Vec<_>>>()
+                    .unwrap_or_default();
+                let mut $name = $name.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+                let mut $name_ptr = ptr::null();
+                if !$name.is_empty() {
+                    $name.push(ptr::null());
+                    $name_ptr = $name.as_ptr();
+                }
             };
-            ffi::luau_compile(source.as_ref(), options)
         }
+
+        vec2cstring_ptr!(mutable_globals, mutable_globals_ptr);
+        vec2cstring_ptr!(userdata_types, userdata_types_ptr);
+        vec2cstring_ptr!(libraries_with_known_members, libraries_with_known_members_ptr);
+        vec2cstring_ptr!(disabled_builtins, disabled_builtins_ptr);
+
+        thread_local! {
+            static LIBRARY_MEMBER_CONSTANT_MAP: RefCell<LibraryMemberConstantMap> = Default::default();
+        }
+
+        #[cfg(feature = "luau")]
+        unsafe extern "C-unwind" fn library_member_constant_callback(
+            library: *const c_char,
+            member: *const c_char,
+            constant: *mut ffi::lua_CompileConstant,
+        ) {
+            let library = CStr::from_ptr(library).to_string_lossy();
+            let member = CStr::from_ptr(member).to_string_lossy();
+            LIBRARY_MEMBER_CONSTANT_MAP.with_borrow(|map| {
+                if let Some(cons) = map.get(&(library.to_string(), member.to_string())) {
+                    match cons {
+                        CompileConstant::Nil => ffi::luau_set_compile_constant_nil(constant),
+                        CompileConstant::Boolean(b) => {
+                            ffi::luau_set_compile_constant_boolean(constant, *b as c_int)
+                        }
+                        CompileConstant::Number(n) => ffi::luau_set_compile_constant_number(constant, *n),
+                        CompileConstant::Vector(v) => {
+                            #[cfg(not(feature = "luau-vector4"))]
+                            ffi::luau_set_compile_constant_vector(constant, v.x(), v.y(), v.z(), 0.0);
+                            #[cfg(feature = "luau-vector4")]
+                            ffi::luau_set_compile_constant_vector(constant, v.x(), v.y(), v.z(), v.w());
+                        }
+                        CompileConstant::String(s) => ffi::luau_set_compile_constant_string(
+                            constant,
+                            s.as_ptr() as *const c_char,
+                            s.len(),
+                        ),
+                    }
+                }
+            })
+        }
+
+        let bytecode = unsafe {
+            let mut options = ffi::lua_CompileOptions::default();
+            options.optimizationLevel = self.optimization_level as c_int;
+            options.debugLevel = self.debug_level as c_int;
+            options.typeInfoLevel = self.type_info_level as c_int;
+            options.coverageLevel = self.coverage_level as c_int;
+            options.vectorLib = vector_lib.map_or(ptr::null(), |s| s.as_ptr());
+            options.vectorCtor = vector_ctor.map_or(ptr::null(), |s| s.as_ptr());
+            options.vectorType = vector_type.map_or(ptr::null(), |s| s.as_ptr());
+            options.mutableGlobals = mutable_globals_ptr;
+            options.userdataTypes = userdata_types_ptr;
+            options.librariesWithKnownMembers = libraries_with_known_members_ptr;
+            if let Some(map) = self.library_constants.as_ref() {
+                if !self.libraries_with_known_members.is_empty() {
+                    LIBRARY_MEMBER_CONSTANT_MAP.with_borrow_mut(|gmap| *gmap = map.clone());
+                    options.libraryMemberConstantCallback = Some(library_member_constant_callback);
+                }
+            }
+            options.disabledBuiltins = disabled_builtins_ptr;
+            ffi::luau_compile(source.as_ref(), options)
+        };
+
+        if bytecode.first() == Some(&0) {
+            // The rest of the bytecode is the error message starting with `:`
+            // See https://github.com/luau-lang/luau/blob/0.640/Compiler/src/Compiler.cpp#L4336
+            let message = StdString::from_utf8_lossy(&bytecode[2..]).into_owned();
+            return Err(Error::SyntaxError {
+                incomplete_input: message.ends_with("<eof>"),
+                message,
+            });
+        }
+
+        Ok(bytecode)
     }
 }
 
-impl<'lua, 'a> Chunk<'lua, 'a> {
-    /// Sets the name of this chunk, which results in more informative error traces.
-    pub fn set_name(mut self, name: impl AsRef<str>) -> Result<Self> {
-        self.name = Some(name.as_ref().to_string());
-        // Do extra validation
-        let _ = self.convert_name()?;
-        Ok(self)
+impl Chunk<'_> {
+    /// Returns the name of this chunk.
+    pub fn name(&self) -> &str {
+        &self.name
     }
 
-    /// Sets the first upvalue (`_ENV`) of the loaded chunk to the given value.
+    /// Sets the name of this chunk, which results in more informative error traces.
     ///
-    /// Lua main chunks always have exactly one upvalue, and this upvalue is used as the `_ENV`
-    /// variable inside the chunk. By default this value is set to the global environment.
+    /// Possible name prefixes:
+    /// - `@` - file path (when truncation is needed, the end of the file path is kept, as this is
+    ///   more useful for identifying the file)
+    /// - `=` - custom chunk name (when truncation is needed, the beginning of the name is kept)
+    pub fn set_name(mut self, name: impl Into<StdString>) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    /// Returns the environment of this chunk.
+    pub fn environment(&self) -> Option<&Table> {
+        self.env.as_ref().ok()?.as_ref()
+    }
+
+    /// Sets the environment of the loaded chunk to the given value.
+    ///
+    /// In Lua >=5.2 main chunks always have exactly one upvalue, and this upvalue is used as the
+    /// `_ENV` variable inside the chunk. By default this value is set to the global environment.
     ///
     /// Calling this method changes the `_ENV` upvalue to the value provided, and variables inside
     /// the chunk will refer to the given environment rather than the global one.
@@ -255,10 +534,14 @@ 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<Self> {
-        // Prefer to propagate errors here and wrap to `Ok`
-        self.env = Ok(Some(env.to_lua(self.lua)?));
-        Ok(self)
+    pub fn set_environment(mut self, env: Table) -> Self {
+        self.env = Ok(Some(env));
+        self
+    }
+
+    /// Returns the mode (auto-detected by default) of this chunk.
+    pub fn mode(&self) -> ChunkMode {
+        self.detect_mode()
     }
 
     /// Sets whether the chunk is text or binary (autodetected by default).
@@ -273,8 +556,6 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// Sets or overwrites a Luau compiler used for this chunk.
     ///
     /// See [`Compiler`] for details and possible options.
-    ///
-    /// Requires `feature = "luau"`
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn set_compiler(mut self, compiler: Compiler) -> Self {
@@ -286,24 +567,18 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// This is equivalent to calling the chunk function with no arguments and no return values.
     pub fn exec(self) -> Result<()> {
-        self.call(())?;
-        Ok(())
+        self.call(())
     }
 
     /// Asynchronously execute this chunk of code.
     ///
     /// See [`exec`] for more details.
     ///
-    /// Requires `feature = "async"`
-    ///
-    /// [`exec`]: #method.exec
+    /// [`exec`]: Chunk::exec
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn exec_async<'fut>(self) -> LocalBoxFuture<'fut, Result<()>>
-    where
-        'lua: 'fut,
-    {
-        self.call_async(())
+    pub async fn exec_async(self) -> Result<()> {
+        self.call_async(()).await
     }
 
     /// Evaluate the chunk as either an expression or block.
@@ -311,7 +586,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// If the chunk can be parsed as an expression, this loads and executes the chunk and returns
     /// the value that it evaluates to. Otherwise, the chunk is interpreted as a block as normal,
     /// and this is equivalent to calling `exec`.
-    pub fn eval<R: FromLuaMulti<'lua>>(self) -> Result<R> {
+    pub fn eval<R: FromLuaMulti>(self) -> Result<R> {
         // Bytecode is always interpreted as a statement.
         // For source code, first try interpreting the lua as an expression by adding
         // "return", then as a statement. This is the same thing the
@@ -329,29 +604,26 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// See [`eval`] for more details.
     ///
-    /// Requires `feature = "async"`
-    ///
-    /// [`eval`]: #method.eval
+    /// [`eval`]: Chunk::eval
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn eval_async<'fut, R>(self) -> LocalBoxFuture<'fut, Result<R>>
+    pub async fn eval_async<R>(self) -> Result<R>
     where
-        'lua: 'fut,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti,
     {
         if self.detect_mode() == ChunkMode::Binary {
-            self.call_async(())
+            self.call_async(()).await
         } else if let Ok(function) = self.to_expression() {
-            function.call_async(())
+            function.call_async(()).await
         } else {
-            self.call_async(())
+            self.call_async(()).await
         }
     }
 
     /// 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<R: FromLuaMulti>(self, args: impl IntoLuaMulti) -> Result<R> {
         self.into_function()?.call(args)
     }
 
@@ -359,56 +631,46 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     ///
     /// See [`call`] for more details.
     ///
-    /// Requires `feature = "async"`
-    ///
-    /// [`call`]: #method.call
+    /// [`call`]: Chunk::call
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn call_async<'fut, A, R>(self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    pub async fn call_async<R>(self, args: impl IntoLuaMulti) -> Result<R>
     where
-        'lua: 'fut,
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti,
     {
-        match self.into_function() {
-            Ok(func) => func.call_async(args),
-            Err(e) => Box::pin(future::err(e)),
-        }
+        self.into_function()?.call_async(args).await
     }
 
-    /// Load this chunk into a regular `Function`.
+    /// Load this chunk into a regular [`Function`].
     ///
     /// This simply compiles the chunk without actually executing it.
     #[cfg_attr(not(feature = "luau"), allow(unused_mut))]
-    pub fn into_function(mut self) -> Result<Function<'lua>> {
+    pub fn into_function(mut self) -> Result<Function> {
         #[cfg(feature = "luau")]
         if self.compiler.is_some() {
             // We don't need to compile source if no compiler set
             self.compile();
         }
 
-        let name = self.convert_name()?;
+        let name = Self::convert_name(self.name)?;
         self.lua
-            .load_chunk(self.source?.as_ref(), name.as_deref(), self.env?, self.mode)
+            .lock()
+            .load_chunk(Some(&name), self.env?.as_ref(), self.mode, self.source?.as_ref())
     }
 
     /// Compiles the chunk and changes mode to binary.
     ///
-    /// It does nothing if the chunk is already binary.
+    /// It does nothing if the chunk is already binary or invalid.
     fn compile(&mut self) {
         if let Ok(ref source) = self.source {
             if self.detect_mode() == ChunkMode::Text {
                 #[cfg(feature = "luau")]
-                {
-                    let data = self
-                        .compiler
-                        .get_or_insert_with(Default::default)
-                        .compile(source);
+                if let Ok(data) = self.compiler.get_or_insert_with(Default::default).compile(source) {
                     self.source = Ok(Cow::Owned(data));
                     self.mode = Some(ChunkMode::Binary);
                 }
                 #[cfg(not(feature = "luau"))]
-                if let Ok(func) = self.lua.load_chunk(source.as_ref(), None, None, None) {
+                if let Ok(func) = self.lua.lock().load_chunk(None, None, None, source.as_ref()) {
                     let data = func.dump(false);
                     self.source = Ok(Cow::Owned(data));
                     self.mode = Some(ChunkMode::Binary);
@@ -427,7 +689,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         let mut text_source = None;
         if let Ok(ref source) = self.source {
             if self.detect_mode() == ChunkMode::Text {
-                if let Some(cache) = self.lua.app_data_ref::<ChunksCache>() {
+                let lua = self.lua.lock();
+                if let Some(cache) = lua.priv_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);
@@ -443,13 +706,14 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
             self.compile();
             if let Ok(ref binary_source) = self.source {
                 if self.detect_mode() == ChunkMode::Binary {
-                    if let Some(mut cache) = self.lua.app_data_mut::<ChunksCache>() {
-                        cache.0.insert(text_source, binary_source.as_ref().to_vec());
+                    let lua = self.lua.lock();
+                    if let Some(mut cache) = lua.priv_app_data_mut::<ChunksCache>() {
+                        cache.0.insert(text_source, binary_source.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);
-                    }
+                        cache.0.insert(text_source, binary_source.to_vec());
+                        lua.set_priv_app_data(cache);
+                    };
                 }
             }
         }
@@ -457,10 +721,10 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         self
     }
 
-    fn to_expression(&self) -> Result<Function<'lua>> {
+    fn to_expression(&self) -> Result<Function> {
         // We assume that mode is Text
         let source = self.source.as_ref();
-        let source = source.map_err(|err| Error::RuntimeError(err.to_string()))?;
+        let source = source.map_err(Error::runtime)?;
         let source = Self::expression_source(source);
         // We don't need to compile source if no compiler options set
         #[cfg(feature = "luau")]
@@ -468,37 +732,37 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
             .compiler
             .as_ref()
             .map(|c| c.compile(&source))
+            .transpose()?
             .unwrap_or(source);
 
-        let name = self.convert_name()?;
-        self.lua
-            .load_chunk(&source, name.as_deref(), self.env.clone()?, None)
+        let name = Self::convert_name(self.name.clone())?;
+        let env = match &self.env {
+            Ok(Some(env)) => Some(env),
+            Ok(None) => None,
+            Err(err) => return Err(err.clone()),
+        };
+        self.lua.lock().load_chunk(Some(&name), env, None, &source)
     }
 
     fn detect_mode(&self) -> ChunkMode {
-        match (self.mode, &self.source) {
-            (Some(mode), _) => mode,
-            (None, Ok(source)) => {
-                #[cfg(not(feature = "luau"))]
-                if source.starts_with(ffi::LUA_SIGNATURE) {
-                    return ChunkMode::Binary;
-                }
-                #[cfg(feature = "luau")]
-                if *source.first().unwrap_or(&u8::MAX) < b'\n' {
-                    return ChunkMode::Binary;
-                }
-                ChunkMode::Text
-            }
-            (None, Err(_)) => ChunkMode::Text, // any value is fine
+        if let Some(mode) = self.mode {
+            return mode;
         }
+        if let Ok(source) = &self.source {
+            #[cfg(not(feature = "luau"))]
+            if source.starts_with(ffi::LUA_SIGNATURE) {
+                return ChunkMode::Binary;
+            }
+            #[cfg(feature = "luau")]
+            if *source.first().unwrap_or(&u8::MAX) < b'\n' {
+                return ChunkMode::Binary;
+            }
+        }
+        ChunkMode::Text
     }
 
-    fn convert_name(&self) -> Result<Option<CString>> {
-        self.name
-            .clone()
-            .map(CString::new)
-            .transpose()
-            .map_err(|err| Error::RuntimeError(format!("invalid name: {err}")))
+    fn convert_name(name: StdString) -> Result<CString> {
+        CString::new(name).map_err(|err| Error::runtime(format!("invalid name: {err}")))
     }
 
     fn expression_source(source: &[u8]) -> Vec<u8> {
@@ -508,3 +772,31 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
         buf
     }
 }
+
+struct WrappedChunk<T: AsChunk> {
+    chunk: T,
+    caller: &'static Location<'static>,
+}
+
+impl Chunk<'_> {
+    /// Wraps a chunk of Lua code, returning an opaque type that implements [`IntoLua`] trait.
+    ///
+    /// The resulted `IntoLua` implementation will convert the chunk into a Lua function without
+    /// executing it.
+    #[doc(hidden)]
+    #[track_caller]
+    pub fn wrap(chunk: impl AsChunk) -> impl IntoLua {
+        WrappedChunk {
+            chunk,
+            caller: Location::caller(),
+        }
+    }
+}
+
+impl<T: AsChunk> IntoLua for WrappedChunk<T> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.load_with_location(self.chunk, self.caller)
+            .into_function()
+            .map(Value::Function)
+    }
+}

src/debug.rs

@@ -0,0 +1,387 @@
+use std::borrow::Cow;
+use std::os::raw::c_int;
+
+use ffi::{lua_Debug, lua_State};
+
+use crate::function::Function;
+use crate::state::RawLua;
+use crate::util::{assert_stack, linenumber_to_usize, ptr_to_lossy_str, ptr_to_str, StackGuard};
+
+/// Contains information about currently executing Lua code.
+///
+/// You may call the methods on this structure to retrieve information about the Lua code executing
+/// at the specific level. Further information can be found in the Lua [documentation].
+///
+/// [documentation]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
+pub struct Debug<'a> {
+    state: *mut lua_State,
+    lua: &'a RawLua,
+    #[cfg_attr(not(feature = "luau"), allow(unused))]
+    level: c_int,
+    ar: *mut lua_Debug,
+}
+
+impl<'a> Debug<'a> {
+    pub(crate) fn new(lua: &'a RawLua, level: c_int, ar: *mut lua_Debug) -> Self {
+        Debug {
+            state: lua.state(),
+            lua,
+            ar,
+            level,
+        }
+    }
+
+    /// Returns the specific event that triggered the hook.
+    ///
+    /// For [Lua 5.1] [`DebugEvent::TailCall`] is used for return events to indicate a return
+    /// from a function that did a tail call.
+    ///
+    /// [Lua 5.1]: https://www.lua.org/manual/5.1/manual.html#pdf-LUA_HOOKTAILRET
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn event(&self) -> DebugEvent {
+        unsafe {
+            match (*self.ar).event {
+                ffi::LUA_HOOKCALL => DebugEvent::Call,
+                ffi::LUA_HOOKRET => DebugEvent::Ret,
+                ffi::LUA_HOOKTAILCALL => DebugEvent::TailCall,
+                ffi::LUA_HOOKLINE => DebugEvent::Line,
+                ffi::LUA_HOOKCOUNT => DebugEvent::Count,
+                event => DebugEvent::Unknown(event),
+            }
+        }
+    }
+
+    /// Returns the function that is running at the given level.
+    ///
+    /// Corresponds to the `f` "what" mask.
+    pub fn function(&self) -> Function {
+        unsafe {
+            let _sg = StackGuard::new(self.state);
+            assert_stack(self.state, 1);
+
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("f"), self.ar) != 0,
+                "lua_getinfo failed with `f`"
+            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, self.level, cstr!("f"), self.ar) != 0,
+                "lua_getinfo failed with `f`"
+            );
+
+            ffi::lua_xmove(self.state, self.lua.ref_thread(), 1);
+            Function(self.lua.pop_ref_thread())
+        }
+    }
+
+    /// Corresponds to the `n` "what" mask.
+    pub fn names(&self) -> DebugNames<'_> {
+        unsafe {
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("n"), self.ar) != 0,
+                "lua_getinfo failed with `n`"
+            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, self.level, cstr!("n"), self.ar) != 0,
+                "lua_getinfo failed with `n`"
+            );
+
+            DebugNames {
+                name: ptr_to_lossy_str((*self.ar).name),
+                #[cfg(not(feature = "luau"))]
+                name_what: match ptr_to_str((*self.ar).namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
+                #[cfg(feature = "luau")]
+                name_what: None,
+            }
+        }
+    }
+
+    /// Corresponds to the `S` "what" mask.
+    pub fn source(&self) -> DebugSource<'_> {
+        unsafe {
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("S"), self.ar) != 0,
+                "lua_getinfo failed with `S`"
+            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, self.level, cstr!("s"), self.ar) != 0,
+                "lua_getinfo failed with `s`"
+            );
+
+            DebugSource {
+                source: ptr_to_lossy_str((*self.ar).source),
+                #[cfg(not(feature = "luau"))]
+                short_src: ptr_to_lossy_str((*self.ar).short_src.as_ptr()),
+                #[cfg(feature = "luau")]
+                short_src: ptr_to_lossy_str((*self.ar).short_src),
+                line_defined: linenumber_to_usize((*self.ar).linedefined),
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: linenumber_to_usize((*self.ar).lastlinedefined),
+                #[cfg(feature = "luau")]
+                last_line_defined: None,
+                what: ptr_to_str((*self.ar).what).unwrap_or("main"),
+            }
+        }
+    }
+
+    #[doc(hidden)]
+    #[deprecated(note = "Use `current_line` instead")]
+    pub fn curr_line(&self) -> i32 {
+        self.current_line().map(|n| n as i32).unwrap_or(-1)
+    }
+
+    /// Corresponds to the `l` "what" mask. Returns the current line.
+    pub fn current_line(&self) -> Option<usize> {
+        unsafe {
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("l"), self.ar) != 0,
+                "lua_getinfo failed with `l`"
+            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, self.level, cstr!("l"), self.ar) != 0,
+                "lua_getinfo failed with `l`"
+            );
+
+            linenumber_to_usize((*self.ar).currentline)
+        }
+    }
+
+    /// Corresponds to the `t` "what" mask. Returns true if the hook is in a function tail call,
+    /// false otherwise.
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua54", feature = "lua53", feature = "lua52")))
+    )]
+    pub fn is_tail_call(&self) -> bool {
+        unsafe {
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("t"), self.ar) != 0,
+                "lua_getinfo failed with `t`"
+            );
+            (*self.ar).istailcall != 0
+        }
+    }
+
+    /// Corresponds to the `u` "what" mask.
+    pub fn stack(&self) -> DebugStack {
+        unsafe {
+            #[cfg(not(feature = "luau"))]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, cstr!("u"), self.ar) != 0,
+                "lua_getinfo failed with `u`"
+            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.state, self.level, cstr!("au"), self.ar) != 0,
+                "lua_getinfo failed with `au`"
+            );
+
+            #[cfg(not(feature = "luau"))]
+            let stack = DebugStack {
+                num_ups: (*self.ar).nups as _,
+                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+                num_params: (*self.ar).nparams as _,
+                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+                is_vararg: (*self.ar).isvararg != 0,
+            };
+            #[cfg(feature = "luau")]
+            let stack = DebugStack {
+                num_ups: (*self.ar).nupvals,
+                num_params: (*self.ar).nparams,
+                is_vararg: (*self.ar).isvararg != 0,
+            };
+            stack
+        }
+    }
+}
+
+/// Represents a specific event that triggered the hook.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DebugEvent {
+    Call,
+    Ret,
+    TailCall,
+    Line,
+    Count,
+    Unknown(c_int),
+}
+
+#[derive(Clone, Debug)]
+pub struct DebugNames<'a> {
+    /// A (reasonable) name of the function (`None` if the name cannot be found).
+    pub name: Option<Cow<'a, str>>,
+    /// Explains the `name` field (can be `global`/`local`/`method`/`field`/`upvalue`/etc).
+    ///
+    /// Always `None` for Luau.
+    pub name_what: Option<&'static str>,
+}
+
+#[derive(Clone, Debug)]
+pub struct DebugSource<'a> {
+    /// Source of the chunk that created the function.
+    pub source: Option<Cow<'a, str>>,
+    /// A "printable" version of `source`, to be used in error messages.
+    pub short_src: Option<Cow<'a, str>>,
+    /// The line number where the definition of the function starts.
+    pub line_defined: Option<usize>,
+    /// The line number where the definition of the function ends (not set by Luau).
+    pub last_line_defined: Option<usize>,
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is
+    /// the main part of a chunk.
+    pub what: &'static str,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct DebugStack {
+    /// Number of upvalues.
+    pub num_ups: u8,
+    /// Number of parameters.
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau")))
+    )]
+    pub num_params: u8,
+    /// Whether the function is a vararg function.
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau")))
+    )]
+    pub is_vararg: bool,
+}
+
+/// Determines when a hook function will be called by Lua.
+#[cfg(not(feature = "luau"))]
+#[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct HookTriggers {
+    /// Before a function call.
+    pub on_calls: bool,
+    /// When Lua returns from a function.
+    pub on_returns: bool,
+    /// Before executing a new line, or returning from a function call.
+    pub every_line: bool,
+    /// After a certain number of VM instructions have been executed. When set to `Some(count)`,
+    /// `count` is the number of VM instructions to execute before calling the hook.
+    ///
+    /// # Performance
+    ///
+    /// Setting this option to a low value can incur a very high overhead.
+    pub every_nth_instruction: Option<u32>,
+}
+
+#[cfg(not(feature = "luau"))]
+impl HookTriggers {
+    /// An instance of `HookTriggers` with `on_calls` trigger set.
+    pub const ON_CALLS: Self = HookTriggers::new().on_calls();
+
+    /// An instance of `HookTriggers` with `on_returns` trigger set.
+    pub const ON_RETURNS: Self = HookTriggers::new().on_returns();
+
+    /// An instance of `HookTriggers` with `every_line` trigger set.
+    pub const EVERY_LINE: Self = HookTriggers::new().every_line();
+
+    /// Returns a new instance of `HookTriggers` with all triggers disabled.
+    pub const fn new() -> Self {
+        HookTriggers {
+            on_calls: false,
+            on_returns: false,
+            every_line: false,
+            every_nth_instruction: None,
+        }
+    }
+
+    /// Returns an instance of `HookTriggers` with [`on_calls`] trigger set.
+    ///
+    /// [`on_calls`]: #structfield.on_calls
+    pub const fn on_calls(mut self) -> Self {
+        self.on_calls = true;
+        self
+    }
+
+    /// Returns an instance of `HookTriggers` with [`on_returns`] trigger set.
+    ///
+    /// [`on_returns`]: #structfield.on_returns
+    pub const fn on_returns(mut self) -> Self {
+        self.on_returns = true;
+        self
+    }
+
+    /// Returns an instance of `HookTriggers` with [`every_line`] trigger set.
+    ///
+    /// [`every_line`]: #structfield.every_line
+    pub const fn every_line(mut self) -> Self {
+        self.every_line = true;
+        self
+    }
+
+    /// Returns an instance of `HookTriggers` with [`every_nth_instruction`] trigger set.
+    ///
+    /// [`every_nth_instruction`]: #structfield.every_nth_instruction
+    pub const fn every_nth_instruction(mut self, n: u32) -> Self {
+        self.every_nth_instruction = Some(n);
+        self
+    }
+
+    // Compute the mask to pass to `lua_sethook`.
+    pub(crate) const fn mask(&self) -> c_int {
+        let mut mask: c_int = 0;
+        if self.on_calls {
+            mask |= ffi::LUA_MASKCALL
+        }
+        if self.on_returns {
+            mask |= ffi::LUA_MASKRET
+        }
+        if self.every_line {
+            mask |= ffi::LUA_MASKLINE
+        }
+        if self.every_nth_instruction.is_some() {
+            mask |= ffi::LUA_MASKCOUNT
+        }
+        mask
+    }
+
+    // Returns the `count` parameter to pass to `lua_sethook`, if applicable. Otherwise, zero is
+    // returned.
+    pub(crate) const fn count(&self) -> c_int {
+        match self.every_nth_instruction {
+            Some(n) => n as c_int,
+            None => 0,
+        }
+    }
+}
+
+#[cfg(not(feature = "luau"))]
+impl std::ops::BitOr for HookTriggers {
+    type Output = Self;
+
+    fn bitor(mut self, rhs: Self) -> Self::Output {
+        self.on_calls |= rhs.on_calls;
+        self.on_returns |= rhs.on_returns;
+        self.every_line |= rhs.every_line;
+        if self.every_nth_instruction.is_none() && rhs.every_nth_instruction.is_some() {
+            self.every_nth_instruction = rhs.every_nth_instruction;
+        }
+        self
+    }
+}
+
+#[cfg(not(feature = "luau"))]
+impl std::ops::BitOrAssign for HookTriggers {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
+    }
+}

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,14 @@ use std::str::Utf8Error;
 use std::string::String as StdString;
 use std::sync::Arc;
 
+use crate::private::Sealed;
+
+#[cfg(feature = "error-send")]
+type DynStdError = dyn StdError + Send + Sync;
+
+#[cfg(not(feature = "error-send"))]
+type DynStdError = dyn StdError;
+
 /// Error type returned by `mlua` methods.
 #[derive(Debug, Clone)]
 #[non_exhaustive]
@@ -42,16 +48,11 @@ pub enum Error {
     GarbageCollectorError(StdString),
     /// Potentially unsafe action in safe mode.
     SafetyError(StdString),
-    /// Setting memory limit is not available.
+    /// Memory control is not available.
     ///
     /// This error can only happen when Lua state was not created by us and does not have the
     /// custom allocator attached.
-    MemoryLimitNotAvailable,
-    /// Main thread is not available.
-    ///
-    /// This error can only happen in Lua5.1/LuaJIT module mode, when module loaded within a coroutine.
-    /// These Lua versions does not have `LUA_RIDX_MAINTHREAD` registry key.
-    MainThreadNotAvailable,
+    MemoryControlNotAvailable,
     /// A mutable callback has triggered Lua code that has called the same mutable callback again.
     ///
     /// This is an error because a mutable callback can only be borrowed mutably once.
@@ -66,15 +67,31 @@ pub enum Error {
     ///
     /// Due to the way `mlua` works, it should not be directly possible to run out of stack space
     /// during normal use. The only way that this error can be triggered is if a `Function` is
-    /// called with a huge number of arguments, or a rust callback returns a huge number of return
+    /// called with a huge number of arguments, or a Rust callback returns a huge number of return
     /// values.
     StackError,
-    /// Too many arguments to `Function::bind`
+    /// Too many arguments to [`Function::bind`].
+    ///
+    /// [`Function::bind`]: crate::Function::bind
     BindError,
+    /// Bad argument received from Lua (usually when calling a function).
+    ///
+    /// 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.
-        from: &'static str,
+        from: String,
         /// Name of the Lua type that could not be created.
         to: &'static str,
         /// A message indicating why the conversion failed in more detail.
@@ -85,21 +102,21 @@ pub enum Error {
         /// Name of the Lua type that could not be converted.
         from: &'static str,
         /// Name of the Rust type that could not be created.
-        to: &'static str,
+        to: String,
         /// A string containing more detailed error information.
         message: Option<StdString>,
     },
-    /// [`Thread::resume`] was called on an inactive coroutine.
+    /// [`Thread::resume`] was called on an unresumable coroutine.
     ///
-    /// A coroutine is inactive if its main function has returned or if an error has occurred inside
-    /// the coroutine.
+    /// A coroutine is unresumable if its main function has returned or if an error has occurred
+    /// inside the coroutine. Already running coroutines are also marked as unresumable.
     ///
     /// [`Thread::status`] can be used to check if the coroutine can be resumed without causing this
     /// error.
     ///
     /// [`Thread::resume`]: crate::Thread::resume
     /// [`Thread::status`]: crate::Thread::status
-    CoroutineInactive,
+    CoroutineUnresumable,
     /// An [`AnyUserData`] is not the expected type in a borrow.
     ///
     /// This error can only happen when manually using [`AnyUserData`], or when implementing
@@ -116,7 +133,7 @@ pub enum Error {
     ///
     /// [`AnyUserData`]: crate::AnyUserData
     UserDataDestructed,
-    /// An [`AnyUserData`] immutable borrow failed because it is already borrowed mutably.
+    /// An [`AnyUserData`] immutable borrow failed.
     ///
     /// This error can occur when a method on a [`UserData`] type calls back into Lua, which then
     /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
@@ -125,7 +142,7 @@ pub enum Error {
     /// [`AnyUserData`]: crate::AnyUserData
     /// [`UserData`]: crate::UserData
     UserDataBorrowError,
-    /// An [`AnyUserData`] mutable borrow failed because it is already borrowed.
+    /// An [`AnyUserData`] mutable borrow failed.
     ///
     /// This error can occur when a method on a [`UserData`] type calls back into Lua, which then
     /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
@@ -142,8 +159,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.
@@ -163,12 +183,12 @@ pub enum Error {
     /// and returned again.
     PreviouslyResumedPanic,
     /// Serialization error.
-    #[cfg(feature = "serialize")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+    #[cfg(feature = "serde")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
     SerializeError(StdString),
     /// Deserialization error.
-    #[cfg(feature = "serialize")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+    #[cfg(feature = "serde")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
     DeserializeError(StdString),
     /// A custom error.
     ///
@@ -177,7 +197,14 @@ pub enum Error {
     /// Returning `Err(ExternalError(...))` from a Rust callback will raise the error as a Lua
     /// error. The Rust code that originally invoked the Lua code then receives a `CallbackError`,
     /// from which the original error (and a stack traceback) can be recovered.
-    ExternalError(Arc<dyn StdError + Send + Sync>),
+    ExternalError(Arc<DynStdError>),
+    /// An error with additional context.
+    WithContext {
+        /// A string containing additional context.
+        context: StdString,
+        /// Underlying error.
+        cause: Arc<Error>,
+    },
 }
 
 /// A specialized `Result` type used by `mlua`'s API.
@@ -186,24 +213,21 @@ pub type Result<T> = StdResult<T, Error>;
 #[cfg(not(tarpaulin_include))]
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {}", message),
-            Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {}", msg),
-            Error::MemoryError(ref msg) => {
-                write!(fmt, "memory error: {}", msg)
+        match self {
+            Error::SyntaxError { message, .. } => write!(fmt, "syntax error: {message}"),
+            Error::RuntimeError(msg) => write!(fmt, "runtime error: {msg}"),
+            Error::MemoryError(msg) => {
+                write!(fmt, "memory error: {msg}")
             }
             #[cfg(any(feature = "lua53", feature = "lua52"))]
-            Error::GarbageCollectorError(ref msg) => {
-                write!(fmt, "garbage collector error: {}", msg)
+            Error::GarbageCollectorError(msg) => {
+                write!(fmt, "garbage collector error: {msg}")
             }
-            Error::SafetyError(ref msg) => {
-                write!(fmt, "safety error: {}", msg)
+            Error::SafetyError(msg) => {
+                write!(fmt, "safety error: {msg}")
             },
-            Error::MemoryLimitNotAvailable => {
-                write!(fmt, "setting memory limit is not available")
-            }
-            Error::MainThreadNotAvailable => {
-                write!(fmt, "main thread is not available in Lua 5.1")
+            Error::MemoryControlNotAvailable => {
+                write!(fmt, "memory control is not available")
             }
             Error::RecursiveMutCallback => write!(fmt, "mutable callback called recursively"),
             Error::CallbackDestructed => write!(
@@ -218,44 +242,55 @@ impl fmt::Display for Error {
                 fmt,
                 "too many arguments to Function::bind"
             ),
-            Error::ToLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting {} to Lua {}", from, to)?;
-                match *message {
+            Error::BadArgument { to, pos, name, 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, message } => {
+                write!(fmt, "error converting {from} to Lua {to}")?;
+                match message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(message) => write!(fmt, " ({message})"),
                 }
             }
-            Error::FromLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting Lua {} to {}", from, to)?;
-                match *message {
+            Error::FromLuaConversionError { from, to, message } => {
+                write!(fmt, "error converting Lua {from} to {to}")?;
+                match message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(message) => write!(fmt, " ({message})"),
                 }
             }
-            Error::CoroutineInactive => write!(fmt, "cannot resume inactive coroutine"),
+            Error::CoroutineUnresumable => write!(fmt, "coroutine is non-resumable"),
             Error::UserDataTypeMismatch => write!(fmt, "userdata is not expected type"),
             Error::UserDataDestructed => write!(fmt, "userdata has been destructed"),
-            Error::UserDataBorrowError => write!(fmt, "userdata already mutably borrowed"),
-            Error::UserDataBorrowMutError => write!(fmt, "userdata already borrowed"),
-            Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {} is restricted", method),
-            Error::MetaMethodTypeError { ref method, type_name, ref message } => {
-                write!(fmt, "metamethod {} has unsupported type {}", method, type_name)?;
-                match *message {
+            Error::UserDataBorrowError => write!(fmt, "error borrowing userdata"),
+            Error::UserDataBorrowMutError => write!(fmt, "error mutably borrowing userdata"),
+            Error::MetaMethodRestricted(method) => write!(fmt, "metamethod {method} is restricted"),
+            Error::MetaMethodTypeError { method, type_name, message } => {
+                write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
+                match message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(message) => write!(fmt, " ({message})"),
                 }
             }
             Error::MismatchedRegistryKey => {
                 write!(fmt, "RegistryKey used from different Lua state")
             }
-            Error::CallbackError { ref cause, ref traceback } => {
-                writeln!(fmt, "callback error")?;
+            Error::CallbackError { cause, traceback } => {
                 // Trace errors down to the root
                 let (mut cause, mut full_traceback) = (cause, None);
-                while let Error::CallbackError { cause: ref cause2, traceback: ref traceback2 } = **cause {
+                while let Error::CallbackError { cause: cause2, traceback: traceback2 } = &**cause {
                     cause = cause2;
                     full_traceback = Some(traceback2);
                 }
+                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,95 +304,267 @@ 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)
+            #[cfg(feature = "serde")]
+            Error::SerializeError(err) => {
+                write!(fmt, "serialize error: {err}")
             },
-            #[cfg(feature = "serialize")]
-            Error::DeserializeError(ref err) => {
-                write!(fmt, "deserialize error: {}", err)
+            #[cfg(feature = "serde")]
+            Error::DeserializeError(err) => {
+                write!(fmt, "deserialize error: {err}")
             },
-            Error::ExternalError(ref err) => write!(fmt, "{}", err),
+            Error::ExternalError(err) => err.fmt(fmt),
+            Error::WithContext { context, cause } => {
+                writeln!(fmt, "{context}")?;
+                write!(fmt, "{cause}")
+            }
         }
     }
 }
 
 impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        match *self {
+        match self {
             // An error type with a source error should either return that error via source or
             // include that source's error message in its own Display output, but never both.
             // https://blog.rust-lang.org/inside-rust/2021/07/01/What-the-error-handling-project-group-is-working-towards.html
-            // Given that we include source to fmt::Display implementation for `CallbackError`, this call returns nothing.
+            // Given that we include source to fmt::Display implementation for `CallbackError`, this call
+            // returns nothing.
             Error::CallbackError { .. } => None,
-            Error::ExternalError(ref err) => err.source(),
+            Error::ExternalError(err) => err.source(),
+            Error::WithContext { cause, .. } => Self::source(cause),
             _ => None,
         }
     }
 }
 
 impl Error {
-    pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Error {
+    /// Creates a new `RuntimeError` with the given message.
+    #[inline]
+    pub fn runtime<S: fmt::Display>(message: S) -> Self {
+        Error::RuntimeError(message.to_string())
+    }
+
+    /// Wraps an external error object.
+    #[inline]
+    pub fn external<T: Into<Box<DynStdError>>>(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(),
+            Error::WithContext { cause, .. } => Self::downcast_ref(cause),
+            _ => None,
+        }
+    }
+
+    /// An iterator over the chain of nested errors wrapped by this Error.
+    pub fn chain(&self) -> impl Iterator<Item = &(dyn StdError + 'static)> {
+        Chain {
+            root: self,
+            current: None,
+        }
+    }
+
+    /// Returns the parent of this error.
+    #[doc(hidden)]
+    pub fn parent(&self) -> Option<&Error> {
+        match self {
+            Error::CallbackError { cause, .. } => Some(cause.as_ref()),
+            Error::WithContext { cause, .. } => Some(cause.as_ref()),
+            _ => None,
+        }
+    }
+
+    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(
+        from: &'static str,
+        to: impl ToString,
+        message: impl Into<Option<String>>,
+    ) -> Self {
+        Error::FromLuaConversionError {
+            from,
+            to: to.to_string(),
+            message: message.into(),
+        }
+    }
 }
 
+/// Trait for converting [`std::error::Error`] into Lua [`Error`].
 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 {
+impl<E: Into<Box<DynStdError>>> ExternalError for E {
+    fn into_lua_err(self) -> Error {
         Error::external(self)
     }
 }
 
+/// Trait for converting [`std::result::Result`] into Lua [`Result`].
 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 {
+        let context = context.to_string();
+        match self {
+            Error::WithContext { cause, .. } => Error::WithContext { context, cause },
+            _ => Error::WithContext {
+                context,
+                cause: Arc::new(self),
+            },
+        }
+    }
+
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
+        let context = f(&self).to_string();
+        match self {
+            Error::WithContext { cause, .. } => Error::WithContext { context, cause },
+            _ => Error::WithContext {
+                context,
+                cause: Arc::new(self),
+            },
+        }
+    }
+}
+
+impl<T> ErrorContext for Result<T> {
+    fn context<C: fmt::Display>(self, context: C) -> Self {
+        self.map_err(|err| err.context(context))
+    }
+
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
+        self.map_err(|err| err.with_context(f))
+    }
+}
+
+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)
     }
 }
 
-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl serde::ser::Error for Error {
     fn custom<T: fmt::Display>(msg: T) -> Self {
         Self::SerializeError(msg.to_string())
     }
 }
 
-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 impl serde::de::Error for Error {
     fn custom<T: fmt::Display>(msg: T) -> Self {
         Self::DeserializeError(msg.to_string())
     }
 }
+
+#[cfg(feature = "anyhow")]
+impl From<anyhow::Error> for Error {
+    fn from(err: anyhow::Error) -> Self {
+        match err.downcast::<Self>() {
+            Ok(err) => err,
+            Err(err) => Error::external(err),
+        }
+    }
+}
+
+struct Chain<'a> {
+    root: &'a Error,
+    current: Option<&'a (dyn StdError + 'static)>,
+}
+
+impl<'a> Iterator for Chain<'a> {
+    type Item = &'a (dyn StdError + 'static);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let error: Option<&dyn StdError> = match self.current {
+                None => {
+                    self.current = Some(self.root);
+                    self.current
+                }
+                Some(current) => match current.downcast_ref::<Error>()? {
+                    Error::BadArgument { cause, .. }
+                    | Error::CallbackError { cause, .. }
+                    | Error::WithContext { cause, .. } => {
+                        self.current = Some(&**cause);
+                        self.current
+                    }
+                    Error::ExternalError(err) => {
+                        self.current = Some(&**err);
+                        self.current
+                    }
+                    _ => None,
+                },
+            };
+
+            // Skip `ExternalError` as it only wraps the underlying error
+            // without meaningful context
+            if let Some(Error::ExternalError(_)) = error?.downcast_ref::<Error>() {
+                continue;
+            }
+
+            return self.current;
+        }
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "error-send"))]
+    static_assertions::assert_not_impl_any!(Error: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Error: Send, Sync);
+}

src/ffi/lua52/lualib.rs

@@ -1,31 +0,0 @@
-//! Contains definitions from `lualib.h`.
-
-use std::os::raw::c_int;
-
-use super::lua::lua_State;
-
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_LOADLIBNAME: &str = "package";
-
-extern "C" {
-    pub fn luaopen_base(L: *mut lua_State) -> c_int;
-    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
-    pub fn luaopen_table(L: *mut lua_State) -> c_int;
-    pub fn luaopen_io(L: *mut lua_State) -> c_int;
-    pub fn luaopen_os(L: *mut lua_State) -> c_int;
-    pub fn luaopen_string(L: *mut lua_State) -> c_int;
-    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
-    pub fn luaopen_math(L: *mut lua_State) -> c_int;
-    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
-    pub fn luaopen_package(L: *mut lua_State) -> c_int;
-
-    // open all builtin libraries
-    pub fn luaL_openlibs(L: *mut lua_State);
-}

src/ffi/lua53/compat.rs

@@ -1,19 +0,0 @@
-//! MLua compatibility layer for Lua 5.2
-
-use std::os::raw::c_int;
-
-use super::lua::*;
-
-#[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
-    let ret = lua_resume_(L, from, narg);
-    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
-        *nres = lua_gettop(L);
-    }
-    ret
-}

src/ffi/luau/luacode.rs

@@ -1,39 +0,0 @@
-//! Contains definitions from `luacode.h`.
-
-use std::os::raw::{c_char, c_int, c_void};
-use std::slice;
-
-#[repr(C)]
-pub struct lua_CompileOptions {
-    pub optimizationLevel: c_int,
-    pub debugLevel: c_int,
-    pub coverageLevel: c_int,
-    pub vectorLib: *const c_char,
-    pub vectorCtor: *const c_char,
-    pub mutableGlobals: *mut *const c_char,
-}
-
-extern "C" {
-    #[link_name = "luau_compile"]
-    pub fn luau_compile_(
-        source: *const c_char,
-        size: usize,
-        options: *mut lua_CompileOptions,
-        outsize: *mut usize,
-    ) -> *mut c_char;
-
-    fn free(p: *mut c_void);
-}
-
-pub unsafe fn luau_compile(source: &[u8], mut options: lua_CompileOptions) -> Vec<u8> {
-    let mut outsize = 0;
-    let data_ptr = luau_compile_(
-        source.as_ptr() as *const c_char,
-        source.len(),
-        &mut options,
-        &mut outsize,
-    );
-    let data = slice::from_raw_parts(data_ptr as *mut u8, outsize).to_vec();
-    free(data_ptr as *mut c_void);
-    data
-}

src/ffi/luau/lualib.rs

@@ -1,29 +0,0 @@
-//! Contains definitions from `lualib.h`.
-
-use std::os::raw::c_int;
-
-use super::lua::lua_State;
-
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_BITLIBNAME: &str = "bit32";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_DBLIBNAME: &str = "debug";
-
-extern "C" {
-    pub fn luaopen_base(L: *mut lua_State) -> c_int;
-    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
-    pub fn luaopen_table(L: *mut lua_State) -> c_int;
-    pub fn luaopen_os(L: *mut lua_State) -> c_int;
-    pub fn luaopen_string(L: *mut lua_State) -> c_int;
-    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
-    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
-    pub fn luaopen_math(L: *mut lua_State) -> c_int;
-    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
-
-    // open all builtin libraries
-    pub fn luaL_openlibs(L: *mut lua_State);
-}

src/ffi/mod.rs

@@ -1,101 +0,0 @@
-//! Low level bindings to Lua 5.4/5.3/5.2/5.1 including LuaJIT.
-
-#![allow(non_camel_case_types, non_snake_case, dead_code)]
-
-use std::os::raw::c_int;
-
-#[cfg(feature = "lua54")]
-pub use lua54::*;
-
-#[cfg(feature = "lua53")]
-pub use lua53::*;
-
-#[cfg(feature = "lua52")]
-pub use lua52::*;
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use lua51::*;
-
-#[cfg(feature = "luau")]
-pub use luau::*;
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_MAX_UPVALUES: c_int = 255;
-
-#[cfg(any(feature = "lua51", all(feature = "luajit", not(feature = "vendored"))))]
-pub const LUA_MAX_UPVALUES: c_int = 60;
-
-#[cfg(all(feature = "luajit", feature = "vendored"))]
-pub const LUA_MAX_UPVALUES: c_int = 120;
-
-#[cfg(feature = "luau")]
-pub const LUA_MAX_UPVALUES: c_int = 200;
-
-// I believe `luaL_traceback` < 5.4 requires this much free stack to not error.
-// 5.4 uses `luaL_Buffer`
-pub const LUA_TRACEBACK_STACK: c_int = 11;
-
-// The minimum alignment guaranteed by the architecture. This value is used to
-// add fast paths for low alignment values.
-// Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/common/alloc.rs
-#[cfg(all(any(
-    target_arch = "x86",
-    target_arch = "arm",
-    target_arch = "mips",
-    target_arch = "powerpc",
-    target_arch = "powerpc64",
-    target_arch = "sparc",
-    target_arch = "asmjs",
-    target_arch = "wasm32",
-    target_arch = "hexagon",
-    all(target_arch = "riscv32", not(target_os = "espidf")),
-    all(target_arch = "xtensa", not(target_os = "espidf")),
-)))]
-pub const SYS_MIN_ALIGN: usize = 8;
-#[cfg(all(any(
-    target_arch = "x86_64",
-    target_arch = "aarch64",
-    target_arch = "mips64",
-    target_arch = "s390x",
-    target_arch = "sparc64",
-    target_arch = "riscv64",
-    target_arch = "wasm64",
-)))]
-pub const SYS_MIN_ALIGN: usize = 16;
-// The allocator on the esp-idf platform guarentees 4 byte alignment.
-#[cfg(all(any(
-    all(target_arch = "riscv32", target_os = "espidf"),
-    all(target_arch = "xtensa", target_os = "espidf"),
-)))]
-pub const SYS_MIN_ALIGN: usize = 4;
-
-// Hack to avoid stripping a few unused Lua symbols that could be imported
-// 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 _);
-    }
-}
-
-#[cfg(feature = "lua54")]
-pub mod lua54;
-
-#[cfg(feature = "lua53")]
-pub mod lua53;
-
-#[cfg(feature = "lua52")]
-pub mod lua52;
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub mod lua51;
-
-#[cfg(feature = "luau")]
-pub mod luau;

src/function.rs

@@ -1,33 +1,55 @@
-use std::mem;
+use std::cell::RefCell;
 use std::os::raw::{c_int, c_void};
-use std::ptr;
-use std::slice;
+use std::{mem, ptr, slice};
 
 use crate::error::{Error, Result};
-use crate::ffi;
-use crate::types::LuaRef;
+use crate::state::Lua;
+use crate::table::Table;
+use crate::traits::{FromLuaMulti, IntoLua, IntoLuaMulti, LuaNativeFn, LuaNativeFnMut};
+use crate::types::{Callback, LuaType, MaybeSend, ValueRef};
 use crate::util::{
-    assert_stack, check_stack, error_traceback, pop_error, ptr_to_cstr_bytes, StackGuard,
+    assert_stack, check_stack, linenumber_to_usize, pop_error, ptr_to_lossy_str, ptr_to_str, StackGuard,
 };
-use crate::value::{FromLuaMulti, ToLuaMulti};
+use crate::value::Value;
 
 #[cfg(feature = "async")]
-use {futures_core::future::LocalBoxFuture, futures_util::future};
+use {
+    crate::thread::AsyncThread,
+    crate::traits::LuaNativeAsyncFn,
+    crate::types::AsyncCallback,
+    std::future::{self, Future},
+    std::pin::{pin, Pin},
+    std::task::{Context, Poll},
+};
 
 /// Handle to an internal Lua function.
-#[derive(Clone, Debug)]
-pub struct Function<'lua>(pub(crate) LuaRef<'lua>);
+#[derive(Clone, Debug, PartialEq)]
+pub struct Function(pub(crate) ValueRef);
 
+/// Contains information about a function.
+///
+/// Please refer to the [`Lua Debug Interface`] for more information.
+///
+/// [`Lua Debug Interface`]: https://www.lua.org/manual/5.4/manual.html#4.7
 #[derive(Clone, Debug)]
 pub struct FunctionInfo {
-    pub name: Option<Vec<u8>>,
-    pub name_what: Option<Vec<u8>>,
-    pub what: Option<Vec<u8>>,
-    pub source: Option<Vec<u8>>,
-    pub short_src: Option<Vec<u8>>,
-    pub line_defined: i32,
-    #[cfg(not(feature = "luau"))]
-    pub last_line_defined: i32,
+    /// A (reasonable) name of the function (`None` if the name cannot be found).
+    pub name: Option<String>,
+    /// Explains the `name` field (can be `global`/`local`/`method`/`field`/`upvalue`/etc).
+    ///
+    /// Always `None` for Luau.
+    pub name_what: Option<&'static str>,
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is
+    /// the main part of a chunk.
+    pub what: &'static str,
+    /// Source of the chunk that created the function.
+    pub source: Option<String>,
+    /// A "printable" version of `source`, to be used in error messages.
+    pub short_src: Option<String>,
+    /// The line number where the definition of the function starts.
+    pub line_defined: Option<usize>,
+    /// The line number where the definition of the function ends (not set by Luau).
+    pub last_line_defined: Option<usize>,
 }
 
 /// Luau function coverage snapshot.
@@ -35,13 +57,13 @@ pub struct FunctionInfo {
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CoverageInfo {
-    pub function: Option<std::string::String>,
+    pub function: Option<String>,
     pub line_defined: i32,
     pub depth: i32,
     pub hits: Vec<i32>,
 }
 
-impl<'lua> Function<'lua> {
+impl Function {
     /// Calls the function, passing `args` as function arguments.
     ///
     /// The function's return values are converted to the generic type `R`.
@@ -58,7 +80,7 @@ impl<'lua> Function<'lua> {
     ///
     /// let tostring: Function = globals.get("tostring")?;
     ///
-    /// assert_eq!(tostring.call::<_, String>(123)?, "123");
+    /// assert_eq!(tostring.call::<String>(123)?, "123");
     ///
     /// # Ok(())
     /// # }
@@ -77,66 +99,56 @@ impl<'lua> Function<'lua> {
     ///         end
     /// "#).eval()?;
     ///
-    /// assert_eq!(sum.call::<_, u32>((3, 4))?, 3 + 4);
+    /// assert_eq!(sum.call::<u32>((3, 4))?, 3 + 4);
     ///
     /// # Ok(())
     /// # }
     /// ```
-    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
-        let lua = self.0.lua;
+    pub fn call<R: FromLuaMulti>(&self, args: impl IntoLuaMulti) -> Result<R> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
 
-        let mut args = args.to_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)?;
-
-            ffi::lua_pushcfunction(lua.state, error_traceback);
-            let stack_start = ffi::lua_gettop(lua.state);
+            // Push error handler
+            lua.push_error_traceback();
+            let stack_start = ffi::lua_gettop(state);
+            // Push function and the arguments
             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 nargs = args.push_into_stack_multi(&lua)?;
+            // Call the function
+            let ret = ffi::lua_pcall(state, nargs, ffi::LUA_MULTRET, stack_start);
             if ret != ffi::LUA_OK {
-                return Err(pop_error(lua.state, ret));
+                return Err(pop_error(state, ret));
             }
-            let nresults = ffi::lua_gettop(lua.state) - stack_start;
-            let mut results = args; // Reuse MultiValue container
-            assert_stack(lua.state, 2);
-            for _ in 0..nresults {
-                results.push_front(lua.pop_value());
-            }
-            ffi::lua_pop(lua.state, 1);
-            results
-        };
-        R::from_lua_multi(results, lua)
+            // Get the results
+            let nresults = ffi::lua_gettop(state) - stack_start;
+            R::from_stack_multi(nresults, &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`].
-    ///
-    /// Requires `feature = "async"`
+    /// Internally it wraps the function to an [`AsyncThread`]. The returned type implements
+    /// `Future<Output = Result<R>>` and can be awaited.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::time::Duration;
-    /// use futures_timer::Delay;
     /// # use mlua::{Lua, Result};
     /// # #[tokio::main]
     /// # async fn main() -> Result<()> {
     /// # let lua = Lua::new();
     ///
     /// let sleep = lua.create_async_function(move |_lua, n: u64| async move {
-    ///     Delay::new(Duration::from_millis(n)).await;
+    ///     tokio::time::sleep(Duration::from_millis(n)).await;
     ///     Ok(())
     /// })?;
     ///
-    /// sleep.call_async(10).await?;
+    /// sleep.call_async::<()>(10).await?;
     ///
     /// # Ok(())
     /// # }
@@ -145,21 +157,18 @@ impl<'lua> Function<'lua> {
     /// [`AsyncThread`]: crate::AsyncThread
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    pub fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        'lua: 'fut,
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti,
     {
-        let lua = self.0.lua;
-        match lua.create_recycled_thread(self.clone()) {
-            Ok(t) => {
-                let mut t = t.into_async(args);
-                t.set_recyclable(true);
-                Box::pin(t)
-            }
-            Err(e) => Box::pin(future::err(e)),
-        }
+        let lua = self.0.lua.lock();
+        AsyncCallFuture(unsafe {
+            lua.create_recycled_thread(self).and_then(|th| {
+                let mut th = th.into_async(args)?;
+                th.set_recyclable(true);
+                Ok(th)
+            })
+        })
     }
 
     /// Returns a function that, when called, calls `self`, passing `args` as the first set of
@@ -181,16 +190,16 @@ impl<'lua> Function<'lua> {
     /// "#).eval()?;
     ///
     /// let bound_a = sum.bind(1)?;
-    /// assert_eq!(bound_a.call::<_, u32>(2)?, 1 + 2);
+    /// assert_eq!(bound_a.call::<u32>(2)?, 1 + 2);
     ///
     /// let bound_a_and_b = sum.bind(13)?.bind(57)?;
-    /// assert_eq!(bound_a_and_b.call::<_, u32>(())?, 13 + 57);
+    /// assert_eq!(bound_a_and_b.call::<u32>(())?, 13 + 57);
     ///
     /// # Ok(())
     /// # }
     /// ```
-    pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
-        unsafe extern "C" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
+    pub fn bind(&self, args: impl IntoLuaMulti) -> Result<Function> {
+        unsafe extern "C-unwind" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
             let nargs = ffi::lua_gettop(state);
             let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(1)) as c_int;
             ffi::luaL_checkstack(state, nbinds, ptr::null());
@@ -198,35 +207,43 @@ impl<'lua> Function<'lua> {
             for i in 0..nbinds {
                 ffi::lua_pushvalue(state, ffi::lua_upvalueindex(i + 2));
             }
-            ffi::lua_rotate(state, 1, nbinds);
+            if nargs > 0 {
+                ffi::lua_rotate(state, 1, nbinds);
+            }
 
             nargs + nbinds
         }
 
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
 
-        let args = args.to_lua_multi(lua)?;
+        let args = args.into_lua_multi(lua.lua())?;
         let nargs = args.len() as c_int;
 
+        if nargs == 0 {
+            return Ok(self.clone());
+        }
+
         if nargs + 1 > ffi::LUA_MAX_UPVALUES {
             return Err(Error::BindError);
         }
 
         let args_wrapper = 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_pushinteger(lua.state, nargs as ffi::lua_Integer);
-            for arg in args {
+            ffi::lua_pushinteger(state, nargs as ffi::lua_Integer);
+            for arg in &args {
                 lua.push_value(arg)?;
             }
-            protect_lua!(lua.state, nargs + 1, 1, fn(state) {
+            protect_lua!(state, nargs + 1, 1, fn(state) {
                 ffi::lua_pushcclosure(state, args_wrapper_impl, ffi::lua_gettop(state));
             })?;
 
             Function(lua.pop_ref())
         };
 
+        let lua = lua.lua();
         lua.load(
             r#"
             local func, args_wrapper = ...
@@ -236,8 +253,92 @@ impl<'lua> Function<'lua> {
             "#,
         )
         .try_cache()
-        .set_name("_mlua_bind")?
-        .call((self.clone(), args_wrapper))
+        .set_name("=__mlua_bind")
+        .call((self, args_wrapper))
+    }
+
+    /// Returns the environment of the Lua function.
+    ///
+    /// By default Lua functions shares a global environment.
+    ///
+    /// This function always returns `None` for Rust/C functions.
+    pub fn environment(&self) -> Option<Table> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return None;
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            ffi::lua_getfenv(state, -1);
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                // Traverse upvalues until we find the _ENV one
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => break,
+                    s if std::ffi::CStr::from_ptr(s as _) == c"_ENV" => break,
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            if ffi::lua_type(state, -1) != ffi::LUA_TTABLE {
+                return None;
+            }
+            Some(Table(lua.pop_ref()))
+        }
+    }
+
+    /// Sets the environment of the Lua function.
+    ///
+    /// The environment is a table that is used as the global environment for the function.
+    /// Returns `true` if environment successfully changed, `false` otherwise.
+    ///
+    /// This function does nothing for Rust/C functions.
+    pub fn set_environment(&self, env: Table) -> Result<bool> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return Ok(false);
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            {
+                lua.push_ref(&env.0);
+                ffi::lua_setfenv(state, -2);
+            }
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => return Ok(false),
+                    s if std::ffi::CStr::from_ptr(s as _) == c"_ENV" => {
+                        ffi::lua_pop(state, 1);
+                        // Create an anonymous function with the new environment
+                        let f_with_env = lua
+                            .lua()
+                            .load("return _ENV")
+                            .set_environment(env)
+                            .try_cache()
+                            .into_function()?;
+                        lua.push_ref(&f_with_env.0);
+                        ffi::lua_upvaluejoin(state, -2, i, -1, 1);
+                        break;
+                    }
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            Ok(true)
+        }
     }
 
     /// Returns information about the function.
@@ -246,31 +347,40 @@ impl<'lua> Function<'lua> {
     ///
     /// [`lua_getinfo`]: https://www.lua.org/manual/5.4/manual.html#lua_getinfo
     pub fn info(&self) -> FunctionInfo {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
+            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(lua.state, cstr!(">Sn"), &mut ar);
+            let res = ffi::lua_getinfo(state, cstr!(">Sn"), &mut ar);
             #[cfg(feature = "luau")]
-            let res = ffi::lua_getinfo(lua.state, -1, cstr!("sn"), &mut ar);
+            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()),
+                name: ptr_to_lossy_str(ar.name).map(|s| s.into_owned()),
                 #[cfg(not(feature = "luau"))]
-                name_what: ptr_to_cstr_bytes(ar.namewhat).map(|s| s.to_vec()),
+                name_what: match ptr_to_str(ar.namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
                 #[cfg(feature = "luau")]
                 name_what: None,
-                what: ptr_to_cstr_bytes(ar.what).map(|s| s.to_vec()),
-                source: ptr_to_cstr_bytes(ar.source).map(|s| s.to_vec()),
-                short_src: ptr_to_cstr_bytes(&ar.short_src as *const _).map(|s| s.to_vec()),
-                line_defined: ar.linedefined as i32,
+                what: ptr_to_str(ar.what).unwrap_or("main"),
+                source: ptr_to_lossy_str(ar.source).map(|s| s.into_owned()),
                 #[cfg(not(feature = "luau"))]
-                last_line_defined: ar.lastlinedefined as i32,
+                short_src: ptr_to_lossy_str(ar.short_src.as_ptr()).map(|s| s.into_owned()),
+                #[cfg(feature = "luau")]
+                short_src: ptr_to_lossy_str(ar.short_src).map(|s| s.into_owned()),
+                line_defined: linenumber_to_usize(ar.linedefined),
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: linenumber_to_usize(ar.lastlinedefined),
+                #[cfg(feature = "luau")]
+                last_line_defined: None,
             }
         }
     }
@@ -280,13 +390,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.
+    /// For Luau a [`Compiler`] can be used to compile Lua chunks to bytecode.
     ///
-    /// [Compiler]: crate::chunk::Compiler
+    /// [`Compiler`]: crate::chunk::Compiler
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn dump(&self, strip: bool) -> Vec<u8> {
-        unsafe extern "C" fn writer(
+        unsafe extern "C-unwind" fn writer(
             _state: *mut ffi::lua_State,
             buf: *const c_void,
             buf_len: usize,
@@ -298,17 +408,17 @@ impl<'lua> Function<'lua> {
             0
         }
 
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
         let mut data: Vec<u8> = Vec::new();
         unsafe {
-            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
@@ -316,24 +426,22 @@ impl<'lua> Function<'lua> {
 
     /// Retrieves recorded coverage information about this Lua function including inner calls.
     ///
-    /// This function takes a callback as an argument and calls it providing [`CoverageInfo`] snapshot
-    /// per each executed inner function.
+    /// This function takes a callback as an argument and calls it providing [`CoverageInfo`]
+    /// snapshot per each executed inner function.
     ///
     /// Recording of coverage information is controlled by [`Compiler::set_coverage_level`] option.
     ///
-    /// Requires `feature = "luau"`
-    ///
     /// [`Compiler::set_coverage_level`]: crate::chunk::Compiler::set_coverage_level
-    #[cfg(any(feature = "luau", docsrs))]
+    #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    pub fn coverage<F>(&self, mut func: F)
+    pub fn coverage<F>(&self, func: F)
     where
         F: FnMut(CoverageInfo),
     {
         use std::ffi::CStr;
         use std::os::raw::c_char;
 
-        unsafe extern "C" fn callback<F: FnMut(CoverageInfo)>(
+        unsafe extern "C-unwind" fn callback<F: FnMut(CoverageInfo)>(
             data: *mut c_void,
             function: *const c_char,
             line_defined: c_int,
@@ -346,29 +454,238 @@ impl<'lua> Function<'lua> {
             } 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 rust_callback = &*(data as *const RefCell<F>);
+            if let Ok(mut rust_callback) = rust_callback.try_borrow_mut() {
+                // Call the Rust callback with CoverageInfo
+                rust_callback(CoverageInfo {
+                    function,
+                    line_defined,
+                    depth,
+                    hits: slice::from_raw_parts(hits, size).to_vec(),
+                });
+            }
         }
 
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
         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 func_ptr = &mut func as *mut F as *mut c_void;
-            ffi::lua_getcoverage(lua.state, -1, func_ptr, callback::<F>);
+            let func = RefCell::new(func);
+            let func_ptr = &func as *const RefCell<F> as *mut c_void;
+            ffi::lua_getcoverage(state, -1, func_ptr, callback::<F>);
+        }
+    }
+
+    /// Converts this function to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
+
+    /// Creates a deep clone of the Lua function.
+    ///
+    /// Copies the function prototype and all its upvalues to the
+    /// newly created function.
+    /// This function returns shallow clone (same handle) for Rust/C functions.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn deep_clone(&self) -> Result<Self> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return Ok(self.clone());
+            }
+
+            if lua.unlikely_memory_error() {
+                ffi::lua_clonefunction(state, -1);
+            } else {
+                protect_lua!(state, 1, 1, fn(state) ffi::lua_clonefunction(state, -1))?;
+            }
+            Ok(Function(lua.pop_ref()))
         }
     }
 }
 
-impl<'lua> PartialEq for Function<'lua> {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
+struct WrappedFunction(pub(crate) Callback);
+
+#[cfg(feature = "async")]
+struct WrappedAsyncFunction(pub(crate) AsyncCallback);
+
+impl Function {
+    /// 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
+    where
+        F: LuaNativeFn<A, Output = Result<R>> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func.call(args)?.push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
+    pub fn wrap_mut<F, A, R>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeFnMut<A, Output = Result<R>> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let func = RefCell::new(func);
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let mut func = func.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func.call(args)?.push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
+    ///
+    /// This function is similar to [`Function::wrap`] but any returned `Result` will be converted
+    /// to a `ok, err` tuple without throwing an exception.
+    #[inline]
+    pub fn wrap_raw<F, A>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeFn<A> + MaybeSend + 'static,
+        A: FromLuaMulti,
+    {
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func.call(args).push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
+    ///
+    /// This function is similar to [`Function::wrap_mut`] but any returned `Result` will be
+    /// converted to a `ok, err` tuple without throwing an exception.
+    #[inline]
+    pub fn wrap_raw_mut<F, A>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeFnMut<A> + MaybeSend + 'static,
+        A: FromLuaMulti,
+    {
+        let func = RefCell::new(func);
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let mut func = func.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func.call(args).push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust async function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn wrap_async<F, A, R>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeAsyncFn<A, Output = Result<R>> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        WrappedAsyncFunction(Box::new(move |rawlua, nargs| unsafe {
+            let args = match A::from_stack_args(nargs, 1, None, rawlua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let lua = rawlua.lua();
+            let fut = func.call(args);
+            Box::pin(async move { fut.await?.push_into_stack_multi(lua.raw_lua()) })
+        }))
+    }
+
+    /// Wraps a Rust async function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
+    ///
+    /// This function is similar to [`Function::wrap_async`] but any returned `Result` will be
+    /// converted to a `ok, err` tuple without throwing an exception.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn wrap_raw_async<F, A>(func: F) -> impl IntoLua
+    where
+        F: LuaNativeAsyncFn<A> + MaybeSend + 'static,
+        A: FromLuaMulti,
+    {
+        WrappedAsyncFunction(Box::new(move |rawlua, nargs| unsafe {
+            let args = match A::from_stack_args(nargs, 1, None, rawlua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let lua = rawlua.lua();
+            let fut = func.call(args);
+            Box::pin(async move { fut.await.push_into_stack_multi(lua.raw_lua()) })
+        }))
     }
 }
+
+impl IntoLua for WrappedFunction {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.lock().create_callback(self.0).map(Value::Function)
+    }
+}
+
+#[cfg(feature = "async")]
+impl IntoLua for WrappedAsyncFunction {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.lock().create_async_callback(self.0).map(Value::Function)
+    }
+}
+
+impl LuaType for Function {
+    const TYPE_ID: c_int = ffi::LUA_TFUNCTION;
+}
+
+#[cfg(feature = "async")]
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct AsyncCallFuture<R: FromLuaMulti>(Result<AsyncThread<R>>);
+
+#[cfg(feature = "async")]
+impl<R: FromLuaMulti> AsyncCallFuture<R> {
+    pub(crate) fn error(err: Error) -> Self {
+        AsyncCallFuture(Err(err))
+    }
+}
+
+#[cfg(feature = "async")]
+impl<R: FromLuaMulti> Future for AsyncCallFuture<R> {
+    type Output = Result<R>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+        match &mut this.0 {
+            Ok(thread) => pin!(thread).poll(cx),
+            Err(err) => Poll::Ready(Err(err.clone())),
+        }
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(Function: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Function: Send, Sync);
+
+    #[cfg(all(feature = "async", feature = "send"))]
+    static_assertions::assert_impl_all!(AsyncCallFuture<()>: Send);
+}

src/hook.rs

@@ -1,351 +0,0 @@
-use std::cell::UnsafeCell;
-#[cfg(not(feature = "luau"))]
-use std::ops::{BitOr, BitOrAssign};
-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.
-///
-/// The `Debug` structure is provided as a parameter to the hook function set with
-/// [`Lua::set_hook`]. You may call the methods on this structure to retrieve information about the
-/// Lua code executing at the time that the hook function was called. Further information can be
-/// found in the Lua [documentation][lua_doc].
-///
-/// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
-/// [`Lua::set_hook`]: crate::Lua::set_hook
-pub struct Debug<'lua> {
-    lua: &'lua Lua,
-    ar: ActivationRecord,
-    #[cfg(feature = "luau")]
-    level: c_int,
-}
-
-impl<'lua> Debug<'lua> {
-    #[cfg(not(feature = "luau"))]
-    pub(crate) fn new(lua: &'lua Lua, ar: *mut lua_Debug) -> Self {
-        Debug {
-            lua,
-            ar: ActivationRecord::Borrowed(ar),
-        }
-    }
-
-    pub(crate) fn new_owned(lua: &'lua Lua, _level: c_int, ar: lua_Debug) -> Self {
-        Debug {
-            lua,
-            ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
-            #[cfg(feature = "luau")]
-            level: _level,
-        }
-    }
-
-    /// Returns the specific event that triggered the hook.
-    ///
-    /// For [Lua 5.1] `DebugEvent::TailCall` is used for return events to indicate a return
-    /// from a function that did a tail call.
-    ///
-    /// [Lua 5.1]: https://www.lua.org/manual/5.1/manual.html#pdf-LUA_HOOKTAILRET
-    #[cfg(not(feature = "luau"))]
-    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
-    pub fn event(&self) -> DebugEvent {
-        unsafe {
-            match (*self.ar.get()).event {
-                ffi::LUA_HOOKCALL => DebugEvent::Call,
-                ffi::LUA_HOOKRET => DebugEvent::Ret,
-                ffi::LUA_HOOKTAILCALL => DebugEvent::TailCall,
-                ffi::LUA_HOOKLINE => DebugEvent::Line,
-                ffi::LUA_HOOKCOUNT => DebugEvent::Count,
-                event => DebugEvent::Unknown(event),
-            }
-        }
-    }
-
-    /// Corresponds to the `n` what mask.
-    pub fn names(&self) -> DebugNames<'lua> {
-        unsafe {
-            #[cfg(not(feature = "luau"))]
-            mlua_assert!(
-                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,
-                "lua_getinfo failed with `n`"
-            );
-
-            DebugNames {
-                name: ptr_to_cstr_bytes((*self.ar.get()).name),
-                #[cfg(not(feature = "luau"))]
-                name_what: ptr_to_cstr_bytes((*self.ar.get()).namewhat),
-                #[cfg(feature = "luau")]
-                name_what: None,
-            }
-        }
-    }
-
-    /// Corresponds to the `S` what mask.
-    pub fn source(&self) -> DebugSource<'lua> {
-        unsafe {
-            #[cfg(not(feature = "luau"))]
-            mlua_assert!(
-                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,
-                "lua_getinfo failed with `s`"
-            );
-
-            DebugSource {
-                source: ptr_to_cstr_bytes((*self.ar.get()).source),
-                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src.as_ptr()),
-                line_defined: (*self.ar.get()).linedefined as i32,
-                #[cfg(not(feature = "luau"))]
-                last_line_defined: (*self.ar.get()).lastlinedefined as i32,
-                what: ptr_to_cstr_bytes((*self.ar.get()).what),
-            }
-        }
-    }
-
-    /// Corresponds to the `l` what mask. Returns the current line.
-    pub fn curr_line(&self) -> i32 {
-        unsafe {
-            #[cfg(not(feature = "luau"))]
-            mlua_assert!(
-                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,
-                "lua_getinfo failed with `l`"
-            );
-
-            (*self.ar.get()).currentline as i32
-        }
-    }
-
-    /// Corresponds to the `t` what mask. Returns true if the hook is in a function tail call, false
-    /// otherwise.
-    #[cfg(not(feature = "luau"))]
-    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
-    pub fn is_tail_call(&self) -> bool {
-        unsafe {
-            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("t"), self.ar.get()) != 0,
-                "lua_getinfo failed with `t`"
-            );
-            (*self.ar.get()).currentline != 0
-        }
-    }
-
-    /// Corresponds to the `u` what mask.
-    pub fn stack(&self) -> DebugStack {
-        unsafe {
-            #[cfg(not(feature = "luau"))]
-            mlua_assert!(
-                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,
-                "lua_getinfo failed with `a`"
-            );
-
-            #[cfg(not(feature = "luau"))]
-            let stack = DebugStack {
-                num_ups: (*self.ar.get()).nups as i32,
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar.get()).nparams as i32,
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                is_vararg: (*self.ar.get()).isvararg != 0,
-            };
-            #[cfg(feature = "luau")]
-            let stack = DebugStack {
-                num_ups: (*self.ar.get()).nupvals as i32,
-                num_params: (*self.ar.get()).nparams as i32,
-                is_vararg: (*self.ar.get()).isvararg != 0,
-            };
-            stack
-        }
-    }
-}
-
-enum ActivationRecord {
-    #[cfg(not(feature = "luau"))]
-    Borrowed(*mut lua_Debug),
-    Owned(UnsafeCell<lua_Debug>),
-}
-
-impl ActivationRecord {
-    #[inline]
-    fn get(&self) -> *mut lua_Debug {
-        match self {
-            #[cfg(not(feature = "luau"))]
-            ActivationRecord::Borrowed(x) => *x,
-            ActivationRecord::Owned(x) => x.get(),
-        }
-    }
-}
-
-/// Represents a specific event that triggered the hook.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum DebugEvent {
-    Call,
-    Ret,
-    TailCall,
-    Line,
-    Count,
-    Unknown(c_int),
-}
-
-#[derive(Clone, Debug)]
-pub struct DebugNames<'a> {
-    pub name: Option<&'a [u8]>,
-    pub name_what: Option<&'a [u8]>,
-}
-
-#[derive(Clone, Debug)]
-pub struct DebugSource<'a> {
-    pub source: Option<&'a [u8]>,
-    pub short_src: Option<&'a [u8]>,
-    pub line_defined: i32,
-    #[cfg(not(feature = "luau"))]
-    pub last_line_defined: i32,
-    pub what: Option<&'a [u8]>,
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct DebugStack {
-    pub num_ups: i32,
-    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
-    pub num_params: i32,
-    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
-    pub is_vararg: bool,
-}
-
-/// Determines when a hook function will be called by Lua.
-#[cfg(not(feature = "luau"))]
-#[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
-#[derive(Clone, Copy, Debug, Default)]
-pub struct HookTriggers {
-    /// Before a function call.
-    pub on_calls: bool,
-    /// When Lua returns from a function.
-    pub on_returns: bool,
-    /// Before executing a new line, or returning from a function call.
-    pub every_line: bool,
-    /// After a certain number of VM instructions have been executed. When set to `Some(count)`,
-    /// `count` is the number of VM instructions to execute before calling the hook.
-    ///
-    /// # Performance
-    ///
-    /// Setting this option to a low value can incur a very high overhead.
-    pub every_nth_instruction: Option<u32>,
-}
-
-#[cfg(not(feature = "luau"))]
-impl HookTriggers {
-    /// Returns a new instance of `HookTriggers` with [`on_calls`] trigger set.
-    ///
-    /// [`on_calls`]: #structfield.on_calls
-    pub fn on_calls() -> Self {
-        HookTriggers {
-            on_calls: true,
-            ..Default::default()
-        }
-    }
-
-    /// Returns a new instance of `HookTriggers` with [`on_returns`] trigger set.
-    ///
-    /// [`on_returns`]: #structfield.on_returns
-    pub fn on_returns() -> Self {
-        HookTriggers {
-            on_returns: true,
-            ..Default::default()
-        }
-    }
-
-    /// Returns a new instance of `HookTriggers` with [`every_line`] trigger set.
-    ///
-    /// [`every_line`]: #structfield.every_line
-    pub fn every_line() -> Self {
-        HookTriggers {
-            every_line: true,
-            ..Default::default()
-        }
-    }
-
-    /// Returns a new instance of `HookTriggers` with [`every_nth_instruction`] trigger set.
-    ///
-    /// [`every_nth_instruction`]: #structfield.every_nth_instruction
-    pub fn every_nth_instruction(n: u32) -> Self {
-        HookTriggers {
-            every_nth_instruction: Some(n),
-            ..Default::default()
-        }
-    }
-
-    // Compute the mask to pass to `lua_sethook`.
-    pub(crate) fn mask(&self) -> c_int {
-        let mut mask: c_int = 0;
-        if self.on_calls {
-            mask |= ffi::LUA_MASKCALL
-        }
-        if self.on_returns {
-            mask |= ffi::LUA_MASKRET
-        }
-        if self.every_line {
-            mask |= ffi::LUA_MASKLINE
-        }
-        if self.every_nth_instruction.is_some() {
-            mask |= ffi::LUA_MASKCOUNT
-        }
-        mask
-    }
-
-    // Returns the `count` parameter to pass to `lua_sethook`, if applicable. Otherwise, zero is
-    // returned.
-    pub(crate) fn count(&self) -> c_int {
-        self.every_nth_instruction.unwrap_or(0) as c_int
-    }
-}
-
-#[cfg(not(feature = "luau"))]
-impl BitOr for HookTriggers {
-    type Output = Self;
-
-    fn bitor(mut self, rhs: Self) -> Self::Output {
-        self.on_calls |= rhs.on_calls;
-        self.on_returns |= rhs.on_returns;
-        self.every_line |= rhs.every_line;
-        if self.every_nth_instruction.is_none() && rhs.every_nth_instruction.is_some() {
-            self.every_nth_instruction = rhs.every_nth_instruction;
-        }
-        self
-    }
-}
-
-#[cfg(not(feature = "luau"))]
-impl BitOrAssign for HookTriggers {
-    fn bitor_assign(&mut self, rhs: Self) {
-        *self = *self | rhs;
-    }
-}

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
@@ -27,123 +27,131 @@
 //!
 //! # Serde support
 //!
-//! The [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua values
-//! and vice versa using serde. Any user defined data type that implements [`serde::Serialize`] or
-//! [`serde::Deserialize`] can be converted.
+//! The [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua
+//! values and vice versa using serde. Any user defined data type that implements
+//! [`serde::Serialize`] or [`serde::Deserialize`] can be converted.
 //! For convenience, additional functionality to handle `NULL` values and arrays is provided.
 //!
-//! The [`Value`] enum implements [`serde::Serialize`] trait to support serializing Lua values
-//! (including [`UserData`]) into Rust values.
+//! The [`Value`] enum and other types implement [`serde::Serialize`] trait to support serializing
+//! Lua values into Rust values.
 //!
-//! Requires `feature = "serialize"`.
+//! Requires `feature = "serde"`.
 //!
 //! # Async/await support
 //!
-//! The [`create_async_function`] allows creating non-blocking functions that returns [`Future`].
-//! Lua code with async capabilities can be executed by [`call_async`] family of functions or polling
-//! [`AsyncThread`] using any runtime (eg. Tokio).
+//! The [`Lua::create_async_function`] allows creating non-blocking functions that returns
+//! [`Future`]. Lua code with async capabilities can be executed by [`Function::call_async`] family
+//! of functions or polling [`AsyncThread`] using any runtime (eg. Tokio).
 //!
 //! Requires `feature = "async"`.
 //!
-//! # `Send` requirement
-//! By default `mlua` is `!Send`. This can be changed by enabling `feature = "send"` that adds `Send` requirement
-//! to [`Function`]s and [`UserData`].
+//! # `Send` and `Sync` support
+//!
+//! By default `mlua` is `!Send`. This can be changed by enabling `feature = "send"` that adds
+//! `Send` requirement to Rust functions and [`UserData`] types.
+//!
+//! In this case [`Lua`] object and their types can be send or used from other threads. Internally
+//! access to Lua VM is synchronized using a reentrant mutex that can be locked many times within
+//! the same thread.
 //!
 //! [Lua programming language]: https://www.lua.org/
-//! [`Lua`]: crate::Lua
 //! [executing]: crate::Chunk::exec
 //! [evaluating]: crate::Chunk::eval
 //! [globals]: crate::Lua::globals
-//! [`ToLua`]: crate::ToLua
-//! [`FromLua`]: crate::FromLua
-//! [`ToLuaMulti`]: crate::ToLuaMulti
-//! [`FromLuaMulti`]: crate::FromLuaMulti
-//! [`Function`]: crate::Function
-//! [`UserData`]: crate::UserData
-//! [`UserDataFields`]: crate::UserDataFields
-//! [`UserDataMethods`]: crate::UserDataMethods
-//! [`LuaSerdeExt`]: crate::LuaSerdeExt
-//! [`Value`]: crate::Value
-//! [`create_async_function`]: crate::Lua::create_async_function
-//! [`call_async`]: crate::Function::call_async
-//! [`AsyncThread`]: crate::AsyncThread
 //! [`Future`]: std::future::Future
 //! [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
-// mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.8.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))))]
 #![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(not(send), allow(clippy::arc_with_non_send_sync))]
+#![allow(clippy::ptr_eq)]
+#![allow(unsafe_op_in_unsafe_fn)]
 
 #[macro_use]
 mod macros;
 
+mod buffer;
 mod chunk;
 mod conversion;
+mod debug;
 mod error;
-mod ffi;
 mod function;
-mod hook;
-mod lua;
-#[cfg(feature = "luau")]
+#[cfg(any(feature = "luau", doc))]
 mod luau;
+mod memory;
 mod multi;
 mod scope;
+mod state;
 mod stdlib;
 mod string;
 mod table;
 mod thread;
+mod traits;
 mod types;
 mod userdata;
-mod userdata_impl;
 mod util;
 mod value;
+mod vector;
 
 pub mod prelude;
 
-pub use crate::{ffi::lua_CFunction, ffi::lua_State};
+pub use bstr::BString;
+pub use ffi::{self, lua_CFunction, lua_State};
 
 pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
-pub use crate::error::{Error, ExternalError, ExternalResult, Result};
+pub use crate::debug::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
+pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
 pub use crate::function::{Function, FunctionInfo};
-pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
-pub use crate::lua::{GCMode, Lua, LuaOptions};
-pub use crate::multi::Variadic;
+pub use crate::multi::{MultiValue, Variadic};
 pub use crate::scope::Scope;
+pub use crate::state::{GCMode, Lua, LuaOptions, WeakLua};
 pub use crate::stdlib::StdLib;
-pub use crate::string::String;
-pub use crate::table::{Table, TableExt, TablePairs, TableSequence};
+pub use crate::string::{BorrowedBytes, BorrowedStr, String};
+pub use crate::table::{Table, TablePairs, TableSequence};
 pub use crate::thread::{Thread, ThreadStatus};
-pub use crate::types::{Integer, LightUserData, Number, RegistryKey};
-pub use crate::userdata::{
-    AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
+pub use crate::traits::{
+    FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, LuaNativeFn, LuaNativeFnMut, ObjectLike,
 };
-pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
+pub use crate::types::{
+    AppDataRef, AppDataRefMut, Either, Integer, LightUserData, MaybeSend, Number, RegistryKey, VmState,
+};
+pub use crate::userdata::{
+    AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods, UserDataRef,
+    UserDataRefMut, UserDataRegistry,
+};
+pub use crate::value::{Nil, Value};
 
 #[cfg(not(feature = "luau"))]
-pub use crate::hook::HookTriggers;
+pub use crate::debug::HookTriggers;
 
 #[cfg(any(feature = "luau", doc))]
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-pub use crate::{chunk::Compiler, function::CoverageInfo, types::VmState};
-
-#[cfg(feature = "async")]
-pub use crate::thread::AsyncThread;
-
-#[cfg(feature = "serialize")]
-#[doc(inline)]
-pub use crate::serde::{
-    de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt,
+pub use crate::{
+    buffer::Buffer,
+    chunk::{CompileConstant, Compiler},
+    function::CoverageInfo,
+    luau::{NavigateError, Require, TextRequirer},
+    vector::Vector,
 };
 
-#[cfg(feature = "serialize")]
-#[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+#[cfg(feature = "async")]
+#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+pub use crate::{thread::AsyncThread, traits::LuaNativeAsyncFn};
+
+#[cfg(feature = "serde")]
+#[doc(inline)]
+pub use crate::{
+    serde::{de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt},
+    value::SerializableValue,
+};
+
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 pub mod serde;
 
-#[cfg(any(feature = "mlua_derive"))]
+#[cfg(feature = "mlua_derive")]
 #[allow(unused_imports)]
 #[macro_use]
 extern crate mlua_derive;
@@ -153,7 +161,7 @@ extern crate mlua_derive;
 /// 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.
 ///
@@ -188,27 +196,31 @@ extern crate mlua_derive;
 ///
 /// Other minor limitations:
 ///
-/// - Certain escape codes in string literals don't work.
-///   (Specifically: `\a`, `\b`, `\f`, `\v`, `\123` (octal escape codes), `\u`, and `\U`).
+/// - Certain escape codes in string literals don't work. (Specifically: `\a`, `\b`, `\f`, `\v`,
+///   `\123` (octal escape codes), `\u`, and `\U`).
 ///
 ///   These are accepted: : `\\`, `\n`, `\t`, `\r`, `\xAB` (hex escape codes), and `\0`.
 ///
 /// - The `//` (floor division) operator is unusable, as its start a comment.
 ///
 /// Everything else should work.
-///
-/// [`AsChunk`]: crate::AsChunk
-/// [`UserData`]: crate::UserData
-/// [`ToLua`]: crate::ToLua
-#[cfg(any(feature = "macros"))]
+#[cfg(feature = "macros")]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
 
+/// Derive [`FromLua`] for a Rust type.
+///
+/// Current implementation generate code that takes [`UserData`] value, borrow it (of the Rust type)
+/// and clone.
+#[cfg(feature = "macros")]
+#[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
+pub use mlua_derive::FromLua;
+
 /// Registers Lua module entrypoint.
 ///
 /// You can register multiple entrypoints as required.
 ///
-/// ```
+/// ```ignore
 /// use mlua::{Lua, Result, Table};
 ///
 /// #[mlua::lua_module]
@@ -221,6 +233,45 @@ pub use mlua_derive::chunk;
 ///
 /// Internally in the code above the compiler defines C function `luaopen_my_module`.
 ///
-#[cfg(any(feature = "module", docsrs))]
+/// 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> {
+///     ...
+/// }
+/// ```
+///
+/// * skip_memory_check - skip memory allocation checks for some operations.
+///
+/// In module mode, mlua runs in unknown environment and cannot say are there any memory
+/// limits or not. As result, some operations that require memory allocation runs in
+/// protected mode. Setting this attribute will improve performance of such operations
+/// with risk of having uncaught exceptions and memory leaks.
+///
+/// ```ignore
+/// #[mlua::lua_module(skip_memory_check)]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     ...
+/// }
+/// ```
+#[cfg(all(feature = "mlua_derive", any(feature = "module", doc)))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;
+
+#[cfg(all(feature = "module", feature = "send"))]
+compile_error!("`send` feature is not supported in module mode");
+
+pub(crate) mod private {
+    use super::*;
+
+    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

@@ -1,124 +0,0 @@
-use std::ffi::CStr;
-use std::os::raw::{c_float, c_int};
-
-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)?)?;
-
-        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<std::string::String>) -> Result<Value> {
-    let name = name.ok_or_else(|| Error::RuntimeError("invalid module name".into()))?;
-
-    // Find module in the cache
-    let loaded = unsafe {
-        let _sg = StackGuard::new(lua.state);
-        check_stack(lua.state, 2)?;
-        protect_lua!(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/luau/mod.rs

@@ -0,0 +1,99 @@
+use std::ffi::CStr;
+use std::os::raw::c_int;
+use std::ptr;
+
+use crate::chunk::ChunkMode;
+use crate::error::Result;
+use crate::function::Function;
+use crate::state::{callback_error_ext, ExtraData, Lua};
+use crate::traits::{FromLuaMulti, IntoLua};
+use crate::types::MaybeSend;
+
+pub use require::{NavigateError, Require, TextRequirer};
+
+// Since Luau has some missing standard functions, we re-implement them here
+
+impl Lua {
+    /// Create a custom Luau `require` function using provided [`Require`] implementation to find
+    /// and load modules.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn create_require_function<R: Require + MaybeSend + 'static>(&self, require: R) -> Result<Function> {
+        require::create_require_function(self, require)
+    }
+
+    pub(crate) unsafe fn configure_luau(&self) -> Result<()> {
+        let globals = self.globals();
+
+        globals.raw_set("collectgarbage", self.create_c_function(lua_collectgarbage)?)?;
+        globals.raw_set("loadstring", self.create_c_function(lua_loadstring)?)?;
+
+        // Set `_VERSION` global to include version number
+        // The environment variable `LUAU_VERSION` set by the build script
+        if let Some(version) = ffi::luau_version() {
+            globals.raw_set("_VERSION", format!("Luau {version}"))?;
+        }
+
+        // Enable default `require` implementation
+        let require = self.create_require_function(require::TextRequirer::new())?;
+        self.globals().raw_set("require", require)?;
+
+        Ok(())
+    }
+}
+
+unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
+    let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
+    let option = CStr::from_ptr(option);
+    let arg = ffi::luaL_optinteger(state, 2, 0);
+    let is_sandboxed = (*ExtraData::get(state)).sandboxed;
+    match option.to_str() {
+        Ok("collect") if !is_sandboxed => {
+            ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
+            0
+        }
+        Ok("stop") if !is_sandboxed => {
+            ffi::lua_gc(state, ffi::LUA_GCSTOP, 0);
+            0
+        }
+        Ok("restart") if !is_sandboxed => {
+            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") if !is_sandboxed => {
+            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg as _);
+            ffi::lua_pushboolean(state, res);
+            1
+        }
+        Ok("isrunning") if !is_sandboxed => {
+            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")),
+    }
+}
+
+unsafe extern "C-unwind" fn lua_loadstring(state: *mut ffi::lua_State) -> c_int {
+    callback_error_ext(state, ptr::null_mut(), false, move |extra, nargs| {
+        let rawlua = (*extra).raw_lua();
+        let (chunk, chunk_name) =
+            <(String, Option<String>)>::from_stack_args(nargs, 1, Some("loadstring"), rawlua)?;
+        let chunk_name = chunk_name.as_deref().unwrap_or("=(loadstring)");
+        (rawlua.lua())
+            .load(chunk)
+            .set_name(chunk_name)
+            .set_mode(ChunkMode::Text)
+            .into_function()?
+            .push_into_stack(rawlua)?;
+        Ok(1)
+    })
+}
+
+mod require;

src/luau/require.rs

@@ -0,0 +1,688 @@
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::ffi::CStr;
+use std::io::Result as IoResult;
+use std::ops::{Deref, DerefMut};
+use std::os::raw::{c_char, c_int, c_void};
+use std::path::{Component, Path, PathBuf};
+use std::result::Result as StdResult;
+use std::{env, fmt, fs, mem, ptr};
+
+use crate::error::{Error, Result};
+use crate::function::Function;
+use crate::state::{callback_error_ext, Lua};
+use crate::table::Table;
+use crate::types::MaybeSend;
+
+/// An error that can occur during navigation in the Luau `require-by-string` system.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Debug, Clone)]
+pub enum NavigateError {
+    Ambiguous,
+    NotFound,
+    Other(Error),
+}
+
+#[cfg(feature = "luau")]
+trait IntoNavigateResult {
+    fn into_nav_result(self) -> Result<ffi::luarequire_NavigateResult>;
+}
+
+#[cfg(feature = "luau")]
+impl IntoNavigateResult for StdResult<(), NavigateError> {
+    fn into_nav_result(self) -> Result<ffi::luarequire_NavigateResult> {
+        match self {
+            Ok(()) => Ok(ffi::luarequire_NavigateResult::Success),
+            Err(NavigateError::Ambiguous) => Ok(ffi::luarequire_NavigateResult::Ambiguous),
+            Err(NavigateError::NotFound) => Ok(ffi::luarequire_NavigateResult::NotFound),
+            Err(NavigateError::Other(err)) => Err(err),
+        }
+    }
+}
+
+impl From<Error> for NavigateError {
+    fn from(err: Error) -> Self {
+        NavigateError::Other(err)
+    }
+}
+
+#[cfg(feature = "luau")]
+type WriteResult = ffi::luarequire_WriteResult;
+
+/// A trait for handling modules loading and navigation in the Luau `require-by-string` system.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub trait Require {
+    /// Returns `true` if "require" is permitted for the given chunk name.
+    fn is_require_allowed(&self, chunk_name: &str) -> bool;
+
+    /// Resets the internal state to point at the requirer module.
+    fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError>;
+
+    /// Resets the internal state to point at an aliased module.
+    ///
+    /// This function received an exact path from a configuration file.
+    /// It's only called when an alias's path cannot be resolved relative to its
+    /// configuration file.
+    fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError>;
+
+    // Navigate to parent directory
+    fn to_parent(&mut self) -> StdResult<(), NavigateError>;
+
+    /// Navigate to the given child directory.
+    fn to_child(&mut self, name: &str) -> StdResult<(), NavigateError>;
+
+    /// Returns whether the context is currently pointing at a module
+    fn has_module(&self) -> bool;
+
+    /// Provides a cache key representing the current module.
+    ///
+    /// This function is only called if `has_module` returns true.
+    fn cache_key(&self) -> String;
+
+    /// Returns whether a configuration is present in the current context.
+    fn has_config(&self) -> bool;
+
+    /// Returns the contents of the configuration file in the current context.
+    ///
+    /// This function is only called if `has_config` returns true.
+    fn config(&self) -> IoResult<Vec<u8>>;
+
+    /// Returns a loader function for the current module, that when called, loads the module
+    /// and returns the result.
+    ///
+    /// Loader can be sync or async.
+    /// This function is only called if `has_module` returns true.
+    fn loader(&self, lua: &Lua) -> Result<Function>;
+}
+
+impl fmt::Debug for dyn Require {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "<dyn Require>")
+    }
+}
+
+/// The standard implementation of Luau `require-by-string` navigation.
+#[derive(Default, Debug)]
+pub struct TextRequirer {
+    /// An absolute path to the current Luau module (not mapped to a physical file)
+    abs_path: PathBuf,
+    /// A relative path to the current Luau module (not mapped to a physical file)
+    rel_path: PathBuf,
+    /// A physical path to the current Luau module, which is a file or a directory with an
+    /// `init.lua(u)` file
+    resolved_path: Option<PathBuf>,
+}
+
+impl TextRequirer {
+    /// The prefix used for chunk names in the require system.
+    /// Only chunk names starting with this prefix are allowed to be used in `require`.
+    const CHUNK_PREFIX: &str = "@";
+
+    /// The file extensions that are considered valid for Luau modules.
+    const FILE_EXTENSIONS: &[&str] = &["luau", "lua"];
+
+    /// Creates a new `TextRequirer` instance.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    fn normalize_chunk_name(chunk_name: &str) -> &str {
+        if let Some((path, line)) = chunk_name.rsplit_once(':') {
+            if line.parse::<u32>().is_ok() {
+                return path;
+            }
+        }
+        chunk_name
+    }
+
+    // Normalizes the path by removing unnecessary components
+    fn normalize_path(path: &Path) -> PathBuf {
+        let mut components = VecDeque::new();
+
+        for comp in path.components() {
+            match comp {
+                Component::Prefix(..) | Component::RootDir => {
+                    components.push_back(comp);
+                }
+                Component::CurDir => {}
+                Component::ParentDir => {
+                    if matches!(components.back(), None | Some(Component::ParentDir)) {
+                        components.push_back(Component::ParentDir);
+                    } else if matches!(components.back(), Some(Component::Normal(..))) {
+                        components.pop_back();
+                    }
+                }
+                Component::Normal(..) => components.push_back(comp),
+            }
+        }
+
+        if matches!(components.front(), None | Some(Component::Normal(..))) {
+            components.push_front(Component::CurDir);
+        }
+
+        // Join the components back together
+        components.into_iter().collect()
+    }
+
+    /// Resolve a Luau module path to a physical file or directory.
+    ///
+    /// Empty directories without init files are considered valid as "intermediate" directories.
+    fn resolve_module(path: &Path) -> StdResult<Option<PathBuf>, NavigateError> {
+        let mut found_path = None;
+
+        if path.components().next_back() != Some(Component::Normal("init".as_ref())) {
+            let current_ext = (path.extension().and_then(|s| s.to_str()))
+                .map(|s| format!("{s}."))
+                .unwrap_or_default();
+            for ext in Self::FILE_EXTENSIONS {
+                let candidate = path.with_extension(format!("{current_ext}{ext}"));
+                if candidate.is_file() && found_path.replace(candidate).is_some() {
+                    return Err(NavigateError::Ambiguous);
+                }
+            }
+        }
+        if path.is_dir() {
+            for component in Self::FILE_EXTENSIONS.iter().map(|ext| format!("init.{ext}")) {
+                let candidate = path.join(component);
+                if candidate.is_file() && found_path.replace(candidate).is_some() {
+                    return Err(NavigateError::Ambiguous);
+                }
+            }
+
+            if found_path.is_none() {
+                // Directories without init files are considered valid "intermediate" path
+                return Ok(None);
+            }
+        }
+
+        Ok(Some(found_path.ok_or(NavigateError::NotFound)?))
+    }
+}
+
+impl Require for TextRequirer {
+    fn is_require_allowed(&self, chunk_name: &str) -> bool {
+        chunk_name.starts_with(Self::CHUNK_PREFIX)
+    }
+
+    fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError> {
+        if !chunk_name.starts_with(Self::CHUNK_PREFIX) {
+            return Err(NavigateError::NotFound);
+        }
+        let chunk_name = Self::normalize_chunk_name(&chunk_name[1..]);
+        let chunk_path = Self::normalize_path(chunk_name.as_ref());
+
+        if chunk_path.extension() == Some("rs".as_ref()) {
+            // Special case for Rust source files, reset to the current directory
+            let chunk_filename = chunk_path.file_name().unwrap();
+            let cwd = env::current_dir().map_err(|_| NavigateError::NotFound)?;
+            self.abs_path = Self::normalize_path(&cwd.join(chunk_filename));
+            self.rel_path = ([Component::CurDir, Component::Normal(chunk_filename)].into_iter()).collect();
+            self.resolved_path = None;
+
+            return Ok(());
+        }
+
+        if chunk_path.is_absolute() {
+            let resolved_path = Self::resolve_module(&chunk_path)?;
+            self.abs_path = chunk_path.clone();
+            self.rel_path = chunk_path;
+            self.resolved_path = resolved_path;
+        } else {
+            // Relative path
+            let cwd = env::current_dir().map_err(|_| NavigateError::NotFound)?;
+            let abs_path = Self::normalize_path(&cwd.join(&chunk_path));
+            let resolved_path = Self::resolve_module(&abs_path)?;
+            self.abs_path = abs_path;
+            self.rel_path = chunk_path;
+            self.resolved_path = resolved_path;
+        }
+
+        Ok(())
+    }
+
+    fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError> {
+        let path = Self::normalize_path(path.as_ref());
+        let resolved_path = Self::resolve_module(&path)?;
+
+        self.abs_path = path.clone();
+        self.rel_path = path;
+        self.resolved_path = resolved_path;
+
+        Ok(())
+    }
+
+    fn to_parent(&mut self) -> StdResult<(), NavigateError> {
+        let mut abs_path = self.abs_path.clone();
+        if !abs_path.pop() {
+            // It's important to return `NotFound` if we reached the root, as it's a "recoverable" error if we
+            // cannot go beyond the root directory.
+            // Luau "require-by-string` has a special logic to search for config file to resolve aliases.
+            return Err(NavigateError::NotFound);
+        }
+        let mut rel_parent = self.rel_path.clone();
+        rel_parent.pop();
+        let resolved_path = Self::resolve_module(&abs_path)?;
+
+        self.abs_path = abs_path;
+        self.rel_path = Self::normalize_path(&rel_parent);
+        self.resolved_path = resolved_path;
+
+        Ok(())
+    }
+
+    fn to_child(&mut self, name: &str) -> StdResult<(), NavigateError> {
+        let abs_path = self.abs_path.join(name);
+        let rel_path = self.rel_path.join(name);
+        let resolved_path = Self::resolve_module(&abs_path)?;
+
+        self.abs_path = abs_path;
+        self.rel_path = rel_path;
+        self.resolved_path = resolved_path;
+
+        Ok(())
+    }
+
+    fn has_module(&self) -> bool {
+        (self.resolved_path.as_deref())
+            .map(Path::is_file)
+            .unwrap_or(false)
+    }
+
+    fn cache_key(&self) -> String {
+        self.resolved_path.as_deref().unwrap().display().to_string()
+    }
+
+    fn has_config(&self) -> bool {
+        self.abs_path.is_dir() && self.abs_path.join(".luaurc").is_file()
+    }
+
+    fn config(&self) -> IoResult<Vec<u8>> {
+        fs::read(self.abs_path.join(".luaurc"))
+    }
+
+    fn loader(&self, lua: &Lua) -> Result<Function> {
+        let name = format!("@{}", self.rel_path.display());
+        lua.load(self.resolved_path.as_deref().unwrap())
+            .set_name(name)
+            .into_function()
+    }
+}
+
+struct Context(Box<dyn Require>);
+
+impl Deref for Context {
+    type Target = dyn Require;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+
+impl DerefMut for Context {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.0
+    }
+}
+
+macro_rules! try_borrow {
+    ($state:expr, $ctx:expr) => {
+        match (*($ctx as *const RefCell<Context>)).try_borrow() {
+            Ok(ctx) => ctx,
+            Err(_) => ffi::luaL_error($state, cstr!("require context is already borrowed")),
+        }
+    };
+}
+
+macro_rules! try_borrow_mut {
+    ($state:expr, $ctx:expr) => {
+        match (*($ctx as *const RefCell<Context>)).try_borrow_mut() {
+            Ok(ctx) => ctx,
+            Err(_) => ffi::luaL_error($state, cstr!("require context is already borrowed")),
+        }
+    };
+}
+
+#[cfg(feature = "luau")]
+pub(super) unsafe extern "C-unwind" fn init_config(config: *mut ffi::luarequire_Configuration) {
+    if config.is_null() {
+        return;
+    }
+
+    unsafe extern "C-unwind" fn is_require_allowed(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        requirer_chunkname: *const c_char,
+    ) -> bool {
+        if requirer_chunkname.is_null() {
+            return false;
+        }
+
+        let this = try_borrow!(state, ctx);
+        let chunk_name = CStr::from_ptr(requirer_chunkname).to_string_lossy();
+        this.is_require_allowed(&chunk_name)
+    }
+
+    unsafe extern "C-unwind" fn reset(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        requirer_chunkname: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let chunk_name = CStr::from_ptr(requirer_chunkname).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.reset(&chunk_name).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn jump_to_alias(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        path: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let path = CStr::from_ptr(path).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.jump_to_alias(&path).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn to_parent(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_parent().into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn to_child(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        name: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let name = CStr::from_ptr(name).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_child(&name).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn is_module_present(state: *mut ffi::lua_State, ctx: *mut c_void) -> bool {
+        let this = try_borrow!(state, ctx);
+        this.has_module()
+    }
+
+    unsafe extern "C-unwind" fn get_chunkname(
+        _state: *mut ffi::lua_State,
+        _ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        write_to_buffer(buffer, buffer_size, size_out, &[])
+    }
+
+    unsafe extern "C-unwind" fn get_loadname(
+        _state: *mut ffi::lua_State,
+        _ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        write_to_buffer(buffer, buffer_size, size_out, &[])
+    }
+
+    unsafe extern "C-unwind" fn get_cache_key(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        let this = try_borrow!(state, ctx);
+        let cache_key = this.cache_key();
+        write_to_buffer(buffer, buffer_size, size_out, cache_key.as_bytes())
+    }
+
+    unsafe extern "C-unwind" fn is_config_present(state: *mut ffi::lua_State, ctx: *mut c_void) -> bool {
+        let this = try_borrow!(state, ctx);
+        this.has_config()
+    }
+
+    unsafe extern "C-unwind" fn get_config(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        buffer: *mut c_char,
+        buffer_size: usize,
+        size_out: *mut usize,
+    ) -> WriteResult {
+        let this = try_borrow!(state, ctx);
+        let config = callback_error_ext(state, ptr::null_mut(), true, move |_, _| Ok(this.config()?));
+        write_to_buffer(buffer, buffer_size, size_out, &config)
+    }
+
+    unsafe extern "C-unwind" fn load(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        _path: *const c_char,
+        _chunkname: *const c_char,
+        _loadname: *const c_char,
+    ) -> c_int {
+        let this = try_borrow!(state, ctx);
+        callback_error_ext(state, ptr::null_mut(), true, move |extra, _| {
+            let rawlua = (*extra).raw_lua();
+            let loader = this.loader(rawlua.lua())?;
+            rawlua.push(loader)?;
+            Ok(1)
+        })
+    }
+
+    (*config).is_require_allowed = is_require_allowed;
+    (*config).reset = reset;
+    (*config).jump_to_alias = jump_to_alias;
+    (*config).to_parent = to_parent;
+    (*config).to_child = to_child;
+    (*config).is_module_present = is_module_present;
+    (*config).get_chunkname = get_chunkname;
+    (*config).get_loadname = get_loadname;
+    (*config).get_cache_key = get_cache_key;
+    (*config).is_config_present = is_config_present;
+    (*config).get_alias = None;
+    (*config).get_config = Some(get_config);
+    (*config).load = load;
+}
+
+/// Helper function to write data to a buffer
+#[cfg(feature = "luau")]
+unsafe fn write_to_buffer(
+    buffer: *mut c_char,
+    buffer_size: usize,
+    size_out: *mut usize,
+    data: &[u8],
+) -> WriteResult {
+    // the buffer must be null terminated as it's a c++ `std::string` data() buffer
+    let is_null_terminated = data.last() == Some(&0);
+    *size_out = data.len() + if is_null_terminated { 0 } else { 1 };
+    if *size_out > buffer_size {
+        return WriteResult::BufferTooSmall;
+    }
+    ptr::copy_nonoverlapping(data.as_ptr(), buffer as *mut _, data.len());
+    if !is_null_terminated {
+        *buffer.add(data.len()) = 0;
+    }
+    WriteResult::Success
+}
+
+#[cfg(feature = "luau")]
+pub(super) fn create_require_function<R: Require + MaybeSend + 'static>(
+    lua: &Lua,
+    require: R,
+) -> Result<Function> {
+    unsafe extern "C-unwind" fn find_current_file(state: *mut ffi::lua_State) -> c_int {
+        let mut ar: ffi::lua_Debug = mem::zeroed();
+        for level in 2.. {
+            if ffi::lua_getinfo(state, level, cstr!("s"), &mut ar) == 0 {
+                ffi::luaL_error(state, cstr!("require is not supported in this context"));
+            }
+            if CStr::from_ptr(ar.what) != c"C" {
+                break;
+            }
+        }
+        ffi::lua_pushstring(state, ar.source);
+        1
+    }
+
+    unsafe extern "C-unwind" fn get_cache_key(state: *mut ffi::lua_State) -> c_int {
+        let ctx = ffi::lua_touserdata(state, ffi::lua_upvalueindex(1));
+        let ctx = try_borrow!(state, ctx);
+        let cache_key = ctx.cache_key();
+        ffi::lua_pushlstring(state, cache_key.as_ptr() as *const _, cache_key.len());
+        1
+    }
+
+    let (get_cache_key, find_current_file, proxyrequire, registered_modules, loader_cache) = unsafe {
+        lua.exec_raw::<(Function, Function, Function, Table, Table)>((), move |state| {
+            let context = Context(Box::new(require));
+            let context_ptr = ffi::lua_newuserdata_t(state, RefCell::new(context));
+            ffi::lua_pushcclosured(state, get_cache_key, cstr!("get_cache_key"), 1);
+            ffi::lua_pushcfunctiond(state, find_current_file, cstr!("find_current_file"));
+            ffi::luarequire_pushproxyrequire(state, init_config, context_ptr as *mut _);
+            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, ffi::LUA_REGISTERED_MODULES_TABLE);
+            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("__MLUA_LOADER_CACHE"));
+        })
+    }?;
+
+    unsafe extern "C-unwind" fn error(state: *mut ffi::lua_State) -> c_int {
+        ffi::luaL_where(state, 1);
+        ffi::lua_pushvalue(state, 1);
+        ffi::lua_concat(state, 2);
+        ffi::lua_error(state);
+    }
+
+    unsafe extern "C-unwind" fn r#type(state: *mut ffi::lua_State) -> c_int {
+        ffi::lua_pushstring(state, ffi::lua_typename(state, ffi::lua_type(state, 1)));
+        1
+    }
+
+    unsafe extern "C-unwind" fn to_lowercase(state: *mut ffi::lua_State) -> c_int {
+        let s = ffi::luaL_checkstring(state, 1);
+        let s = CStr::from_ptr(s);
+        if !s.to_bytes().iter().any(|&c| c.is_ascii_uppercase()) {
+            // If the string does not contain any uppercase ASCII letters, return it as is
+            return 1;
+        }
+        callback_error_ext(state, ptr::null_mut(), true, |extra, _| {
+            let s = (s.to_bytes().iter())
+                .map(|&c| c.to_ascii_lowercase())
+                .collect::<bstr::BString>();
+            (*extra).raw_lua().push(s).map(|_| 1)
+        })
+    }
+
+    let (error, r#type, to_lowercase) = unsafe {
+        lua.exec_raw::<(Function, Function, Function)>((), move |state| {
+            ffi::lua_pushcfunctiond(state, error, cstr!("error"));
+            ffi::lua_pushcfunctiond(state, r#type, cstr!("type"));
+            ffi::lua_pushcfunctiond(state, to_lowercase, cstr!("to_lowercase"));
+        })
+    }?;
+
+    // Prepare environment for the "require" function
+    let env = lua.create_table_with_capacity(0, 7)?;
+    env.raw_set("get_cache_key", get_cache_key)?;
+    env.raw_set("find_current_file", find_current_file)?;
+    env.raw_set("proxyrequire", proxyrequire)?;
+    env.raw_set("REGISTERED_MODULES", registered_modules)?;
+    env.raw_set("LOADER_CACHE", loader_cache)?;
+    env.raw_set("error", error)?;
+    env.raw_set("type", r#type)?;
+    env.raw_set("to_lowercase", to_lowercase)?;
+
+    lua.load(
+        r#"
+        local path = ...
+        if type(path) ~= "string" then
+            error("bad argument #1 to 'require' (string expected, got " .. type(path) .. ")")
+        end
+
+        -- Check if the module (path) is explicitly registered
+        local maybe_result = REGISTERED_MODULES[to_lowercase(path)]
+        if maybe_result ~= nil then
+            return maybe_result
+        end
+
+        local loader = proxyrequire(path, find_current_file())
+        local cache_key = get_cache_key()
+        -- Check if the loader result is already cached
+        local result = LOADER_CACHE[cache_key]
+        if result ~= nil then
+            return result
+        end
+
+        -- Call the loader function and cache the result
+        result = loader()
+        if result == nil then
+            result = true
+        end
+        LOADER_CACHE[cache_key] = result
+        return result
+        "#,
+    )
+    .try_cache()
+    .set_name("=__mlua_require")
+    .set_environment(env)
+    .into_function()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use super::TextRequirer;
+
+    #[test]
+    fn test_path_normalize() {
+        for (input, expected) in [
+            // Basic formatting checks
+            ("", "./"),
+            (".", "./"),
+            ("a/relative/path", "./a/relative/path"),
+            // Paths containing extraneous '.' and '/' symbols
+            ("./remove/extraneous/symbols/", "./remove/extraneous/symbols"),
+            ("./remove/extraneous//symbols", "./remove/extraneous/symbols"),
+            ("./remove/extraneous/symbols/.", "./remove/extraneous/symbols"),
+            ("./remove/extraneous/./symbols", "./remove/extraneous/symbols"),
+            ("../remove/extraneous/symbols/", "../remove/extraneous/symbols"),
+            ("../remove/extraneous//symbols", "../remove/extraneous/symbols"),
+            ("../remove/extraneous/symbols/.", "../remove/extraneous/symbols"),
+            ("../remove/extraneous/./symbols", "../remove/extraneous/symbols"),
+            ("/remove/extraneous/symbols/", "/remove/extraneous/symbols"),
+            ("/remove/extraneous//symbols", "/remove/extraneous/symbols"),
+            ("/remove/extraneous/symbols/.", "/remove/extraneous/symbols"),
+            ("/remove/extraneous/./symbols", "/remove/extraneous/symbols"),
+            // Paths containing '..'
+            ("./remove/me/..", "./remove"),
+            ("./remove/me/../", "./remove"),
+            ("../remove/me/..", "../remove"),
+            ("../remove/me/../", "../remove"),
+            ("/remove/me/..", "/remove"),
+            ("/remove/me/../", "/remove"),
+            ("./..", "../"),
+            ("./../", "../"),
+            ("../..", "../../"),
+            ("../../", "../../"),
+            // '..' disappears if path is absolute and component is non-erasable
+            ("/../", "/"),
+        ] {
+            let path = TextRequirer::normalize_path(input.as_ref());
+            assert_eq!(
+                &path,
+                expected.as_ref() as &Path,
+                "wrong normalization for {input}"
+            );
+        }
+    }
+}

src/macros.rs

@@ -10,8 +10,7 @@ macro_rules! bug_msg {
 
 macro_rules! cstr {
     ($s:expr) => {
-        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char]
-            as *const ::std::os::raw::c_char
+        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char] as *const ::std::os::raw::c_char
     };
 }
 
@@ -101,9 +100,15 @@ macro_rules! protect_lua {
     };
 
     ($state:expr, $nargs:expr, $nresults:expr, fn($state_inner:ident) $code:expr) => {{
-        unsafe extern "C" fn do_call($state_inner: *mut ffi::lua_State) -> ::std::os::raw::c_int {
+        use ::std::os::raw::c_int;
+        unsafe extern "C-unwind" fn do_call($state_inner: *mut ffi::lua_State) -> c_int {
             $code;
-            $nresults
+            let nresults = $nresults;
+            if nresults == ::ffi::LUA_MULTRET {
+                ffi::lua_gettop($state_inner)
+            } else {
+                nresults
+            }
         }
 
         crate::util::protect_lua_call($state, $nargs, do_call)

src/memory.rs

@@ -0,0 +1,164 @@
+use std::alloc::{self, Layout};
+use std::os::raw::c_void;
+use std::ptr;
+
+pub(crate) static ALLOCATOR: ffi::lua_Alloc = allocator;
+
+#[repr(C)]
+#[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 {
+    #[cfg(feature = "luau")]
+    #[inline]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        ffi::lua_getallocf(state, &mut mem_state);
+        mlua_assert!(!mem_state.is_null(), "Luau state has no allocator userdata");
+        mem_state as *mut MemoryState
+    }
+
+    #[cfg(not(feature = "luau"))]
+    #[rustversion::since(1.85)]
+    #[inline]
+    #[allow(clippy::incompatible_msrv)]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        if !ptr::fn_addr_eq(ffi::lua_getallocf(state, &mut mem_state), ALLOCATOR) {
+            mem_state = ptr::null_mut();
+        }
+        mem_state as *mut MemoryState
+    }
+
+    #[cfg(not(feature = "luau"))]
+    #[rustversion::before(1.85)]
+    #[inline]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        if ffi::lua_getallocf(state, &mut mem_state) != ALLOCATOR {
+            mem_state = ptr::null_mut();
+        }
+        mem_state as *mut 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/luau
+    // to bypass the memory limit (if set).
+    #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+    #[inline]
+    pub(crate) unsafe fn relax_limit_with(state: *mut ffi::lua_State, f: impl FnOnce()) {
+        let mem_state = Self::get(state);
+        if !mem_state.is_null() {
+            (*mem_state).ignore_limit = true;
+            f();
+            (*mem_state).ignore_limit = false;
+        } else {
+            f();
+        }
+    }
+
+    // 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")]
+    #[inline]
+    pub(crate) unsafe fn limit_reached(state: *mut ffi::lua_State) -> bool {
+        (*Self::get(state)).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,58 +1,212 @@
-#![allow(clippy::wrong_self_convention)]
-
+use std::collections::{vec_deque, VecDeque};
 use std::iter::FromIterator;
+use std::mem;
 use std::ops::{Deref, DerefMut};
+use std::os::raw::c_int;
 use std::result::Result as StdResult;
 
 use crate::error::Result;
-use crate::lua::Lua;
-use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
+use crate::state::{Lua, RawLua};
+use crate::traits::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti};
+use crate::util::check_stack;
+use crate::value::{Nil, Value};
 
-/// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
+/// Result is convertible to [`MultiValue`] following the common Lua idiom of returning the result
 /// on success, or in the case of an error, returning `nil` and an error message.
-impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E> {
+impl<T: IntoLua, E: IntoLua> IntoLuaMulti for StdResult<T, E> {
     #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut result = MultiValue::new_or_cached(lua);
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
         match self {
-            Ok(v) => result.push_front(v.to_lua(lua)?),
-            Err(e) => {
-                result.push_front(e.to_lua(lua)?);
-                result.push_front(Nil);
-            }
+            Ok(val) => (val,).into_lua_multi(lua),
+            Err(err) => (Nil, err).into_lua_multi(lua),
+        }
+    }
+
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        match self {
+            Ok(val) => (val,).push_into_stack_multi(lua),
+            Err(err) => (Nil, err).push_into_stack_multi(lua),
         }
-        Ok(result)
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
+impl<E: IntoLua> IntoLuaMulti for StdResult<(), E> {
     #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut v = MultiValue::new_or_cached(lua);
-        v.push_front(self.to_lua(lua)?);
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        match self {
+            Ok(_) => const { Ok(MultiValue::new()) },
+            Err(err) => (Nil, err).into_lua_multi(lua),
+        }
+    }
+
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        match self {
+            Ok(_) => Ok(0),
+            Err(err) => (Nil, err).push_into_stack_multi(lua),
+        }
+    }
+}
+
+impl<T: IntoLua> IntoLuaMulti for T {
+    #[inline]
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        let mut v = MultiValue::with_capacity(1);
+        v.push_back(self.into_lua(lua)?);
         Ok(v)
     }
-}
 
-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);
-        res
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        self.push_into_stack(lua)?;
+        Ok(1)
     }
 }
 
-impl<'lua> ToLuaMulti<'lua> for MultiValue<'lua> {
+impl<T: FromLua> FromLuaMulti for T {
     #[inline]
-    fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
+        T::from_lua(values.pop_front().unwrap_or(Nil), lua)
+    }
+
+    #[inline]
+    fn from_lua_args(mut args: MultiValue, i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
+        T::from_lua_arg(args.pop_front().unwrap_or(Nil), i, to, lua)
+    }
+
+    #[inline]
+    unsafe fn from_stack_multi(nvals: c_int, lua: &RawLua) -> Result<Self> {
+        if nvals == 0 {
+            return T::from_lua(Nil, lua.lua());
+        }
+        T::from_stack(-nvals, lua)
+    }
+
+    #[inline]
+    unsafe fn from_stack_args(nargs: c_int, i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
+        if nargs == 0 {
+            return T::from_lua_arg(Nil, i, to, lua.lua());
+        }
+        T::from_stack_arg(-nargs, i, to, lua)
+    }
+}
+
+/// Multiple Lua values used for both argument passing and also for multiple return values.
+#[derive(Default, Debug, Clone)]
+pub struct MultiValue(VecDeque<Value>);
+
+impl Deref for MultiValue {
+    type Target = VecDeque<Value>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for MultiValue {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl MultiValue {
+    /// Creates an empty `MultiValue` containing no values.
+    #[inline]
+    pub const fn new() -> MultiValue {
+        MultiValue(VecDeque::new())
+    }
+
+    /// Creates an empty `MultiValue` container with space for at least `capacity` elements.
+    pub fn with_capacity(capacity: usize) -> MultiValue {
+        MultiValue(VecDeque::with_capacity(capacity))
+    }
+
+    /// Creates a `MultiValue` container from vector of values.
+    ///
+    /// This method works in *O*(1) time and does not allocate any additional memory.
+    #[inline]
+    pub fn from_vec(vec: Vec<Value>) -> MultiValue {
+        vec.into()
+    }
+
+    /// Consumes the `MultiValue` and returns a vector of values.
+    ///
+    /// This method needs *O*(*n*) data movement if the circular buffer doesn't happen to be at the
+    /// beginning of the allocation.
+    #[inline]
+    pub fn into_vec(self) -> Vec<Value> {
+        self.into()
+    }
+
+    #[inline]
+    pub(crate) fn from_lua_iter<T: IntoLua>(lua: &Lua, iter: impl IntoIterator<Item = T>) -> Result<Self> {
+        let iter = iter.into_iter();
+        let mut multi_value = MultiValue::with_capacity(iter.size_hint().0);
+        for value in iter {
+            multi_value.push_back(value.into_lua(lua)?);
+        }
+        Ok(multi_value)
+    }
+}
+
+impl From<Vec<Value>> for MultiValue {
+    #[inline]
+    fn from(value: Vec<Value>) -> Self {
+        MultiValue(value.into())
+    }
+}
+
+impl From<MultiValue> for Vec<Value> {
+    #[inline]
+    fn from(value: MultiValue) -> Self {
+        value.0.into()
+    }
+}
+
+impl FromIterator<Value> for MultiValue {
+    #[inline]
+    fn from_iter<I: IntoIterator<Item = Value>>(iter: I) -> Self {
+        let mut multi_value = MultiValue::new();
+        multi_value.extend(iter);
+        multi_value
+    }
+}
+
+impl IntoIterator for MultiValue {
+    type Item = Value;
+    type IntoIter = vec_deque::IntoIter<Value>;
+
+    #[inline]
+    fn into_iter(mut self) -> Self::IntoIter {
+        let deque = mem::take(&mut self.0);
+        mem::forget(self);
+        deque.into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a MultiValue {
+    type Item = &'a Value;
+    type IntoIter = vec_deque::Iter<'a, Value>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
+impl IntoLuaMulti for MultiValue {
+    #[inline]
+    fn into_lua_multi(self, _: &Lua) -> Result<MultiValue> {
         Ok(self)
     }
 }
 
-impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
+impl FromLuaMulti for MultiValue {
     #[inline]
-    fn from_lua_multi(values: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua_multi(values: MultiValue, _: &Lua) -> Result<Self> {
         Ok(values)
     }
 }
@@ -80,10 +234,7 @@ impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
 /// # Ok(())
 /// # }
 /// ```
-///
-/// [`FromLua`]: crate::FromLua
-/// [`MultiValue`]: crate::MultiValue
-#[derive(Debug, Clone)]
+#[derive(Default, Debug, Clone)]
 pub struct Variadic<T>(Vec<T>);
 
 impl<T> Variadic<T> {
@@ -91,11 +242,38 @@ impl<T> Variadic<T> {
     pub const fn new() -> Variadic<T> {
         Variadic(Vec::new())
     }
+
+    /// Creates an empty `Variadic` container with space for at least `capacity` elements.
+    pub fn with_capacity(capacity: usize) -> Variadic<T> {
+        Variadic(Vec::with_capacity(capacity))
+    }
 }
 
-impl<T> Default for Variadic<T> {
-    fn default() -> Variadic<T> {
-        Variadic::new()
+impl<T> Deref for Variadic<T> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for Variadic<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T> From<Vec<T>> for Variadic<T> {
+    #[inline]
+    fn from(vec: Vec<T>) -> Self {
+        Variadic(vec)
+    }
+}
+
+impl<T> From<Variadic<T>> for Vec<T> {
+    #[inline]
+    fn from(value: Variadic<T>) -> Self {
+        value.0
     }
 }
 
@@ -114,88 +292,145 @@ impl<T> IntoIterator for Variadic<T> {
     }
 }
 
-impl<T> Deref for Variadic<T> {
-    type Target = Vec<T>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<T> DerefMut for Variadic<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
+impl<T: IntoLua> IntoLuaMulti for Variadic<T> {
     #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut values = MultiValue::new_or_cached(lua);
-        values.refill(self.0.into_iter().map(|e| e.to_lua(lua)))?;
-        Ok(values)
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        MultiValue::from_lua_iter(lua, self)
+    }
+
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        let nresults = self.len() as i32;
+        check_stack(lua.state(), nresults + 1)?;
+        for value in self.0 {
+            value.push_into_stack(lua)?;
+        }
+        Ok(nresults)
     }
 }
 
-impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
+impl<T: FromLua> FromLuaMulti for Variadic<T> {
     #[inline]
-    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-        let res = values
-            .drain_all()
-            .map(|e| T::from_lua(e, lua))
+    fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
+        values
+            .drain(..)
+            .map(|val| T::from_lua(val, lua))
             .collect::<Result<Vec<T>>>()
-            .map(Variadic);
-        lua.cache_multivalue(values);
-        res
+            .map(Variadic)
     }
 }
 
 macro_rules! impl_tuple {
     () => (
-        impl<'lua> ToLuaMulti<'lua> for () {
+        impl IntoLuaMulti for () {
             #[inline]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-                Ok(MultiValue::new_or_cached(lua))
+            fn into_lua_multi(self, _: &Lua) -> Result<MultiValue> {
+                const { Ok(MultiValue::new()) }
+            }
+
+            #[inline]
+            unsafe fn push_into_stack_multi(self, _lua: &RawLua) -> Result<c_int> {
+                Ok(0)
             }
         }
 
-        impl<'lua> FromLuaMulti<'lua> for () {
+        impl FromLuaMulti for () {
             #[inline]
-            fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-                lua.cache_multivalue(values);
+            fn from_lua_multi(_values: MultiValue, _lua: &Lua) -> Result<Self> {
+                Ok(())
+            }
+
+            #[inline]
+            unsafe fn from_stack_multi(_nvals: c_int, _lua: &RawLua) -> Result<Self> {
                 Ok(())
             }
         }
     );
 
     ($last:ident $($name:ident)*) => (
-        impl<'lua, $($name,)* $last> ToLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: ToLua<'lua>,)*
-                  $last: ToLuaMulti<'lua>
+        impl<$($name,)* $last> IntoLuaMulti for ($($name,)* $last,)
+            where $($name: IntoLua,)*
+                  $last: IntoLuaMulti
         {
-            #[allow(unused_mut)]
-            #[allow(non_snake_case)]
+            #[allow(unused_mut, non_snake_case)]
             #[inline]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+            fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
                 let ($($name,)* $last,) = self;
 
-                let mut results = $last.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)
             }
+
+            #[allow(non_snake_case)]
+            #[inline]
+            unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+                let ($($name,)* $last,) = self;
+                let mut nresults = 0;
+                $(
+                    _ = $name;
+                    nresults += 1;
+                )*
+                check_stack(lua.state(), nresults + 1)?;
+                $(
+                    $name.push_into_stack(lua)?;
+                )*
+                nresults += $last.push_into_stack_multi(lua)?;
+                Ok(nresults)
+            }
         }
 
-        impl<'lua, $($name,)* $last> FromLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: FromLua<'lua>,)*
-                  $last: FromLuaMulti<'lua>
+        impl<$($name,)* $last> FromLuaMulti for ($($name,)* $last,)
+            where $($name: FromLua,)*
+                  $last: FromLuaMulti
         {
-            #[allow(unused_mut)]
-            #[allow(non_snake_case)]
+            #[allow(unused_mut, 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);)*
+            fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
+                $(let $name = FromLua::from_lua(values.pop_front().unwrap_or(Nil), lua)?;)*
                 let $last = FromLuaMulti::from_lua_multi(values, lua)?;
-                Ok(($(FromLua::from_lua($name, lua)?,)* $last,))
+                Ok(($($name,)* $last,))
+            }
+
+            #[allow(unused_mut, non_snake_case)]
+            #[inline]
+            fn from_lua_args(mut args: MultiValue, mut i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
+                $(
+                    let $name = FromLua::from_lua_arg(args.pop_front().unwrap_or(Nil), i, to, lua)?;
+                    i += 1;
+                )*
+                let $last = FromLuaMulti::from_lua_args(args, i, to, lua)?;
+                Ok(($($name,)* $last,))
+            }
+
+            #[allow(unused_mut, non_snake_case)]
+            #[inline]
+            unsafe fn from_stack_multi(mut nvals: c_int, lua: &RawLua) -> Result<Self> {
+                $(
+                    let $name = if nvals > 0 {
+                        nvals -= 1;
+                        FromLua::from_stack(-(nvals + 1), lua)
+                    } else {
+                        FromLua::from_lua(Nil, lua.lua())
+                    }?;
+                )*
+                let $last = FromLuaMulti::from_stack_multi(nvals, lua)?;
+                Ok(($($name,)* $last,))
+            }
+
+            #[allow(unused_mut, non_snake_case)]
+            #[inline]
+            unsafe fn from_stack_args(mut nargs: c_int, mut i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
+                $(
+                    let $name = if nargs > 0 {
+                        nargs -= 1;
+                        FromLua::from_stack_arg(-(nargs + 1), i, to, lua)
+                    } else {
+                        FromLua::from_lua_arg(Nil, i, to, lua.lua())
+                    }?;
+                    i += 1;
+                )*
+                let $last = FromLuaMulti::from_stack_args(nargs, i, to, lua)?;
+                Ok(($($name,)* $last,))
             }
         }
     );
@@ -231,3 +466,13 @@ impl_tuple!(A B C D E F G H I J K L M);
 impl_tuple!(A B C D E F G H I J K L M N);
 impl_tuple!(A B C D E F G H I J K L M N O);
 impl_tuple!(A B C D E F G H I J K L M N O P);
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(MultiValue: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(MultiValue: Send, Sync);
+}

src/prelude.rs

@@ -2,17 +2,19 @@
 
 #[doc(no_inline)]
 pub use crate::{
-    AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Error as LuaError,
+    AnyUserData as LuaAnyUserData, BorrowedBytes as LuaBorrowedBytes, BorrowedStr as LuaBorrowedStr,
+    Chunk as LuaChunk, Either as LuaEither, Error as LuaError, ErrorContext as LuaErrorContext,
     ExternalError as LuaExternalError, ExternalResult as LuaExternalResult, FromLua, FromLuaMulti,
-    Function as LuaFunction, FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode,
-    Integer as LuaInteger, LightUserData as LuaLightUserData, Lua, LuaOptions,
+    Function as LuaFunction, FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode, Integer as LuaInteger,
+    IntoLua, IntoLuaMulti, LightUserData as LuaLightUserData, Lua, LuaNativeFn, LuaNativeFnMut, LuaOptions,
     MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber,
-    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,
-    Value as LuaValue,
+    ObjectLike as LuaObjectLike, RegistryKey as LuaRegistryKey, Result as LuaResult, StdLib as LuaStdLib,
+    String as LuaString, Table as LuaTable, TablePairs as LuaTablePairs, TableSequence as LuaTableSequence,
+    Thread as LuaThread, ThreadStatus as LuaThreadStatus, UserData as LuaUserData,
+    UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
+    UserDataMethods as LuaUserDataMethods, UserDataRef as LuaUserDataRef,
+    UserDataRefMut as LuaUserDataRefMut, UserDataRegistry as LuaUserDataRegistry, Value as LuaValue,
+    Variadic as LuaVariadic, VmState as LuaVmState, WeakLua,
 };
 
 #[cfg(not(feature = "luau"))]
@@ -21,15 +23,19 @@ pub use crate::HookTriggers as LuaHookTriggers;
 
 #[cfg(feature = "luau")]
 #[doc(no_inline)]
-pub use crate::{CoverageInfo as LuaCoverageInfo, VmState as LuaVmState};
+pub use crate::{
+    CompileConstant as LuaCompileConstant, CoverageInfo as LuaCoverageInfo,
+    NavigateError as LuaNavigateError, Require as LuaRequire, TextRequirer as LuaTextRequirer,
+    Vector as LuaVector,
+};
 
 #[cfg(feature = "async")]
 #[doc(no_inline)]
-pub use crate::AsyncThread as LuaAsyncThread;
+pub use crate::{AsyncThread as LuaAsyncThread, LuaNativeAsyncFn};
 
-#[cfg(feature = "serialize")]
+#[cfg(feature = "serde")]
 #[doc(no_inline)]
 pub use crate::{
-    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt,
+    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt, SerializableValue as LuaSerializableValue,
     SerializeOptions as LuaSerializeOptions,
 };

src/serde/de.rs

@@ -1,7 +1,9 @@
+//! Deserialize Lua values to a Rust data structure.
+
 use std::cell::RefCell;
-use std::convert::TryInto;
 use std::os::raw::c_void;
 use std::rc::Rc;
+use std::result::Result as StdResult;
 use std::string::String as StdString;
 
 use rustc_hash::FxHashSet;
@@ -9,28 +11,30 @@ use serde::de::{self, IntoDeserializer};
 
 use crate::error::{Error, Result};
 use crate::table::{Table, TablePairs, TableSequence};
+use crate::userdata::AnyUserData;
 use crate::value::Value;
 
 /// A struct for deserializing Lua values into Rust values.
-#[derive(Debug)]
-pub struct Deserializer<'lua> {
-    value: Value<'lua>,
+#[derive(Debug, Default)]
+pub struct Deserializer {
+    value: Value,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+    len: Option<usize>, // A length hint for sequences
 }
 
 /// A struct with options to change default deserializer behavior.
 #[derive(Debug, Clone, Copy)]
 #[non_exhaustive]
 pub struct Options {
-    /// If true, an attempt to serialize types such as [`Thread`], [`UserData`], [`LightUserData`]
+    /// If true, an attempt to serialize types such as [`Function`], [`Thread`], [`LightUserData`]
     /// and [`Error`] will cause an error.
     /// Otherwise these types skipped when iterating or serialized as unit type.
     ///
     /// Default: **true**
     ///
+    /// [`Function`]: crate::Function
     /// [`Thread`]: crate::Thread
-    /// [`UserData`]: crate::UserData
     /// [`LightUserData`]: crate::LightUserData
     /// [`Error`]: crate::Error
     pub deny_unsupported_types: bool,
@@ -41,11 +45,34 @@ pub struct Options {
     ///
     /// Default: **true**
     pub deny_recursive_tables: bool,
+
+    /// If true, keys in tables will be iterated in sorted order.
+    ///
+    /// Default: **false**
+    pub sort_keys: bool,
+
+    /// If true, empty Lua tables will be encoded as array, instead of map.
+    ///
+    /// Default: **false**
+    pub encode_empty_tables_as_array: bool,
+
+    /// If true, enable detection of mixed tables.
+    ///
+    /// A mixed table is a table that has both array-like and map-like entries or several borders.
+    /// See [`The Length Operator`] documentation for details about borders.
+    ///
+    /// When this option is disabled, a table with a non-zero length (with one or more borders) will
+    /// be always encoded as an array.
+    ///
+    /// Default: **false**
+    ///
+    /// [`The Length Operator`]: https://www.lua.org/manual/5.4/manual.html#3.4.7
+    pub detect_mixed_tables: bool,
 }
 
 impl Default for Options {
     fn default() -> Self {
-        Self::new()
+        const { Self::new() }
     }
 }
 
@@ -55,6 +82,9 @@ impl Options {
         Options {
             deny_unsupported_types: true,
             deny_recursive_tables: true,
+            sort_keys: false,
+            encode_empty_tables_as_array: false,
+            detect_mixed_tables: false,
         }
     }
 
@@ -71,41 +101,70 @@ 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
     }
+
+    /// Sets [`sort_keys`] option.
+    ///
+    /// [`sort_keys`]: #structfield.sort_keys
+    #[must_use]
+    pub const fn sort_keys(mut self, enabled: bool) -> Self {
+        self.sort_keys = enabled;
+        self
+    }
+
+    /// Sets [`encode_empty_tables_as_array`] option.
+    ///
+    /// [`encode_empty_tables_as_array`]: #structfield.encode_empty_tables_as_array
+    #[must_use]
+    pub const fn encode_empty_tables_as_array(mut self, enabled: bool) -> Self {
+        self.encode_empty_tables_as_array = enabled;
+        self
+    }
+
+    /// Sets [`detect_mixed_tables`] option.
+    ///
+    /// [`detect_mixed_tables`]: #structfield.detect_mixed_tables
+    #[must_use]
+    pub const fn detect_mixed_tables(mut self, enable: bool) -> Self {
+        self.detect_mixed_tables = enable;
+        self
+    }
 }
 
-impl<'lua> Deserializer<'lua> {
-    /// Creates a new Lua Deserializer for the `Value`.
-    pub fn new(value: Value<'lua>) -> Self {
+impl Deserializer {
+    /// Creates a new Lua Deserializer for the [`Value`].
+    pub fn new(value: Value) -> Self {
         Self::new_with_options(value, Options::default())
     }
 
-    /// Creates a new Lua Deserializer for the `Value` with custom options.
-    pub fn new_with_options(value: Value<'lua>, options: Options) -> Self {
+    /// Creates a new Lua Deserializer for the [`Value`] with custom options.
+    pub fn new_with_options(value: Value, options: Options) -> Self {
         Deserializer {
             value,
             options,
-            visited: Rc::new(RefCell::new(FxHashSet::default())),
+            ..Default::default()
         }
     }
 
-    fn from_parts(
-        value: Value<'lua>,
-        options: Options,
-        visited: Rc<RefCell<FxHashSet<*const c_void>>>,
-    ) -> Self {
+    fn from_parts(value: Value, options: Options, visited: Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
         Deserializer {
             value,
             options,
             visited,
+            ..Default::default()
         }
     }
+
+    fn with_len(mut self, len: usize) -> Self {
+        self.len = Some(len);
+        self
+    }
 }
 
-impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
+impl<'de> serde::Deserializer<'de> for Deserializer {
     type Error = Error;
 
     #[inline]
@@ -117,30 +176,40 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             Value::Nil => visitor.visit_unit(),
             Value::Boolean(b) => visitor.visit_bool(b),
             #[allow(clippy::useless_conversion)]
-            Value::Integer(i) => {
-                visitor.visit_i64(i.try_into().expect("cannot convert lua_Integer to i64"))
-            }
+            Value::Integer(i) => visitor.visit_i64(i.into()),
             #[allow(clippy::useless_conversion)]
             Value::Number(n) => visitor.visit_f64(n.into()),
             #[cfg(feature = "luau")]
-            Value::Vector(_, _, _) => self.deserialize_seq(visitor),
+            Value::Vector(_) => self.deserialize_seq(visitor),
             Value::String(s) => match s.to_str() {
-                Ok(s) => visitor.visit_str(s),
-                Err(_) => visitor.visit_bytes(s.as_bytes()),
+                Ok(s) => visitor.visit_str(&s),
+                Err(_) => visitor.visit_bytes(&s.as_bytes()),
             },
-            Value::Table(ref t) if t.raw_len() > 0 || t.is_array() => self.deserialize_seq(visitor),
-            Value::Table(_) => self.deserialize_map(visitor),
+            Value::Table(ref t) => {
+                if let Some(len) = t.encode_as_array(self.options) {
+                    self.with_len(len).deserialize_seq(visitor)
+                } else {
+                    self.deserialize_map(visitor)
+                }
+            }
             Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_none(),
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_any(visitor))
+            }
+            #[cfg(feature = "luau")]
+            Value::Buffer(buf) => {
+                let lua = buf.0.lua.lock();
+                visitor.visit_bytes(buf.as_slice(&lua))
+            }
             Value::Function(_)
             | Value::Thread(_)
             | Value::UserData(_)
             | Value::LightUserData(_)
-            | Value::Error(_) => {
+            | Value::Error(_)
+            | Value::Other(_) => {
                 if self.options.deny_unsupported_types {
-                    Err(de::Error::custom(format!(
-                        "unsupported value type `{}`",
-                        self.value.type_name()
-                    )))
+                    let msg = format!("unsupported value type `{}`", self.value.type_name());
+                    Err(de::Error::custom(msg))
                 } else {
                     visitor.visit_unit()
                 }
@@ -163,8 +232,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
@@ -191,13 +260,18 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                         &"map with a single key",
                     ));
                 }
-                if check_value_if_skip(&value, self.options, &self.visited)? {
+                let skip = check_value_for_skip(&value, self.options, &self.visited)
+                    .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                if skip {
                     return Err(de::Error::custom("bad enum value"));
                 }
 
                 (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")),
         };
 
@@ -216,9 +290,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     {
         match self.value {
             #[cfg(feature = "luau")]
-            Value::Vector(x, y, z) => {
+            Value::Vector(vec) => {
                 let mut deserializer = VecDeserializer {
-                    vec: [x, y, z],
+                    vec,
                     next: 0,
                     options: self.options,
                     visited: self.visited,
@@ -228,22 +302,22 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             Value::Table(t) => {
                 let _guard = RecursionGuard::new(&t, &self.visited);
 
-                let len = t.raw_len() as usize;
+                let len = self.len.unwrap_or_else(|| t.raw_len());
                 let mut deserializer = SeqDeserializer {
-                    seq: t.raw_sequence_values(),
+                    seq: t.sequence_values().with_len(len),
                     options: self.options,
                     visited: self.visited,
                 };
                 let seq = visitor.visit_seq(&mut deserializer)?;
-                if deserializer.seq.count() == 0 {
+                if deserializer.seq.next().is_none() {
                     Ok(seq)
                 } else {
-                    Err(de::Error::invalid_length(
-                        len,
-                        &"fewer elements in the table",
-                    ))
+                    Err(de::Error::invalid_length(len, &"fewer elements in the table"))
                 }
             }
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_seq(visitor))
+            }
             value => Err(de::Error::invalid_type(
                 de::Unexpected::Other(value.type_name()),
                 &"table",
@@ -260,12 +334,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     }
 
     #[inline]
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value>
+    fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
@@ -282,7 +351,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                 let _guard = RecursionGuard::new(&t, &self.visited);
 
                 let mut deserializer = MapDeserializer {
-                    pairs: t.pairs(),
+                    pairs: MapPairs::new(&t, self.options.sort_keys)?,
                     value: None,
                     options: self.options,
                     visited: self.visited,
@@ -299,6 +368,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,26 +392,53 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     }
 
     #[inline]
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
-        visitor.visit_newtype_struct(self)
+        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),
+        }
+    }
+
+    #[inline]
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match self.value {
+            Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_unit(),
+            _ => self.deserialize_any(visitor),
+        }
+    }
+
+    #[inline]
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match self.value {
+            Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_unit(),
+            _ => self.deserialize_any(visitor),
+        }
     }
 
     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 identifier ignored_any
+        byte_buf identifier ignored_any
     }
 }
 
-struct SeqDeserializer<'lua> {
-    seq: TableSequence<'lua, Value<'lua>>,
+struct SeqDeserializer<'a> {
+    seq: TableSequence<'a, Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
-impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
+impl<'de> de::SeqAccess<'de> for SeqDeserializer<'_> {
     type Error = Error;
 
     fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
@@ -350,7 +449,9 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
             match self.seq.next() {
                 Some(value) => {
                     let value = value?;
-                    if check_value_if_skip(&value, self.options, &self.visited)? {
+                    let skip = check_value_for_skip(&value, self.options, &self.visited)
+                        .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                    if skip {
                         continue;
                     }
                     let visited = Rc::clone(&self.visited);
@@ -372,7 +473,7 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
 
 #[cfg(feature = "luau")]
 struct VecDeserializer {
-    vec: [f32; 3],
+    vec: crate::Vector,
     next: usize,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
@@ -386,12 +487,11 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
     where
         T: de::DeserializeSeed<'de>,
     {
-        match self.vec.get(self.next) {
+        match self.vec.0.get(self.next) {
             Some(&n) => {
                 self.next += 1;
                 let visited = Rc::clone(&self.visited);
-                let deserializer =
-                    Deserializer::from_parts(Value::Number(n as _), self.options, visited);
+                let deserializer = Deserializer::from_parts(Value::Number(n as _), self.options, visited);
                 seed.deserialize(deserializer).map(Some)
             }
             None => Ok(None),
@@ -399,55 +499,116 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
     }
 
     fn size_hint(&self) -> Option<usize> {
-        Some(3)
+        Some(crate::Vector::SIZE)
     }
 }
 
-struct MapDeserializer<'lua> {
-    pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>,
-    value: Option<Value<'lua>>,
+pub(crate) enum MapPairs<'a> {
+    Iter(TablePairs<'a, Value, Value>),
+    Vec(Vec<(Value, Value)>),
+}
+
+impl<'a> MapPairs<'a> {
+    pub(crate) fn new(t: &'a Table, sort_keys: bool) -> Result<Self> {
+        if sort_keys {
+            let mut pairs = t.pairs::<Value, Value>().collect::<Result<Vec<_>>>()?;
+            pairs.sort_by(|(a, _), (b, _)| b.sort_cmp(a)); // reverse order as we pop values from the end
+            Ok(MapPairs::Vec(pairs))
+        } else {
+            Ok(MapPairs::Iter(t.pairs::<Value, Value>()))
+        }
+    }
+
+    pub(crate) fn count(self) -> usize {
+        match self {
+            MapPairs::Iter(iter) => iter.count(),
+            MapPairs::Vec(vec) => vec.len(),
+        }
+    }
+
+    pub(crate) fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            MapPairs::Iter(iter) => iter.size_hint(),
+            MapPairs::Vec(vec) => (vec.len(), Some(vec.len())),
+        }
+    }
+}
+
+impl Iterator for MapPairs<'_> {
+    type Item = Result<(Value, Value)>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            MapPairs::Iter(iter) => iter.next(),
+            MapPairs::Vec(vec) => vec.pop().map(Ok),
+        }
+    }
+}
+
+struct MapDeserializer<'a> {
+    pairs: MapPairs<'a>,
+    value: Option<Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
     processed: usize,
 }
 
-impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
-    type Error = Error;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
+impl MapDeserializer<'_> {
+    fn next_key_deserializer(&mut self) -> Result<Option<Deserializer>> {
         loop {
             match self.pairs.next() {
                 Some(item) => {
                     let (key, value) = item?;
-                    if check_value_if_skip(&key, self.options, &self.visited)?
-                        || check_value_if_skip(&value, self.options, &self.visited)?
-                    {
+                    let skip_key = check_value_for_skip(&key, self.options, &self.visited)
+                        .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                    let skip_value = check_value_for_skip(&value, self.options, &self.visited)
+                        .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                    if skip_key || skip_value {
                         continue;
                     }
                     self.processed += 1;
                     self.value = Some(value);
                     let visited = Rc::clone(&self.visited);
                     let key_de = Deserializer::from_parts(key, self.options, visited);
-                    return seed.deserialize(key_de).map(Some);
+                    return Ok(Some(key_de));
                 }
                 None => return Ok(None),
             }
         }
     }
 
+    fn next_value_deserializer(&mut self) -> Result<Deserializer> {
+        match self.value.take() {
+            Some(value) => {
+                let visited = Rc::clone(&self.visited);
+                Ok(Deserializer::from_parts(value, self.options, visited))
+            }
+            None => Err(de::Error::custom("value is missing")),
+        }
+    }
+}
+
+impl<'de> de::MapAccess<'de> for MapDeserializer<'_> {
+    type Error = Error;
+
+    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        match self.next_key_deserializer() {
+            Ok(Some(key_de)) => seed.deserialize(key_de).map(Some),
+            Ok(None) => Ok(None),
+            Err(error) => Err(error),
+        }
+    }
+
     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value>
     where
         T: de::DeserializeSeed<'de>,
     {
-        match self.value.take() {
-            Some(value) => {
-                let visited = Rc::clone(&self.visited);
-                seed.deserialize(Deserializer::from_parts(value, self.options, visited))
-            }
-            None => Err(de::Error::custom("value is missing")),
+        match self.next_value_deserializer() {
+            Ok(value_de) => seed.deserialize(value_de),
+            Err(error) => Err(error),
         }
     }
 
@@ -459,16 +620,16 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
     }
 }
 
-struct EnumDeserializer<'lua> {
+struct EnumDeserializer {
     variant: StdString,
-    value: Option<Value<'lua>>,
+    value: Option<Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
-impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
+impl<'de> de::EnumAccess<'de> for EnumDeserializer {
     type Error = Error;
-    type Variant = VariantDeserializer<'lua>;
+    type Variant = VariantDeserializer;
 
     fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant)>
     where
@@ -484,13 +645,13 @@ impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
     }
 }
 
-struct VariantDeserializer<'lua> {
-    value: Option<Value<'lua>>,
+struct VariantDeserializer {
+    value: Option<Value>,
     options: Options,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
-impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
+impl<'de> de::VariantAccess<'de> for VariantDeserializer {
     type Error = Error;
 
     fn unit_variant(self) -> Result<()> {
@@ -508,9 +669,7 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
         T: de::DeserializeSeed<'de>,
     {
         match self.value {
-            Some(value) => {
-                seed.deserialize(Deserializer::from_parts(value, self.options, self.visited))
-            }
+            Some(value) => seed.deserialize(Deserializer::from_parts(value, self.options, self.visited)),
             None => Err(de::Error::invalid_type(
                 de::Unexpected::UnitVariant,
                 &"newtype variant",
@@ -553,14 +712,14 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
 
 // Adds `ptr` to the `visited` map and removes on drop
 // Used to track recursive tables but allow to traverse same tables multiple times
-struct RecursionGuard {
+pub(crate) struct RecursionGuard {
     ptr: *const c_void,
     visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
 impl RecursionGuard {
     #[inline]
-    fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
+    pub(crate) fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
         let visited = Rc::clone(visited);
         let ptr = table.to_pointer();
         visited.borrow_mut().insert(ptr);
@@ -575,21 +734,22 @@ impl Drop for RecursionGuard {
 }
 
 // Checks `options` and decides should we emit an error or skip next element
-fn check_value_if_skip(
+pub(crate) fn check_value_for_skip(
     value: &Value,
     options: Options,
     visited: &RefCell<FxHashSet<*const c_void>>,
-) -> Result<bool> {
+) -> StdResult<bool, &'static str> {
     match value {
         Value::Table(table) => {
             let ptr = table.to_pointer();
             if visited.borrow().contains(&ptr) {
                 if options.deny_recursive_tables {
-                    return Err(de::Error::custom("recursive table detected"));
+                    return Err("recursive table detected");
                 }
                 return Ok(true); // skip
             }
         }
+        Value::UserData(ud) if ud.is_serializable() => {}
         Value::Function(_)
         | Value::Thread(_)
         | Value::UserData(_)
@@ -603,3 +763,16 @@ 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> {
+    match serde_value::to_value(ud) {
+        Ok(value) => match f(value) {
+            Ok(r) => Ok(r),
+            Err(error) => Err(Error::DeserializeError(error.to_string())),
+        },
+        Err(error) => Err(Error::SerializeError(error.to_string())),
+    }
+}

src/serde/mod.rs

@@ -1,25 +1,22 @@
 //! (De)Serialization support using serde.
 
 use std::os::raw::c_void;
-use std::ptr;
 
-use serde::{Deserialize, Serialize};
+use serde::de::DeserializeOwned;
+use serde::ser::Serialize;
 
 use crate::error::Result;
-use crate::ffi;
-use crate::lua::Lua;
+use crate::private::Sealed;
+use crate::state::Lua;
 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> {
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+pub trait LuaSerdeExt: Sealed {
     /// A special value (lightuserdata) to encode/decode optional (none) values.
     ///
-    /// Requires `feature = "serialize"`
-    ///
     /// # Example
     ///
     /// ```
@@ -37,14 +34,12 @@ pub trait LuaSerdeExt<'lua> {
     ///     Ok(())
     /// }
     /// ```
-    fn null(&'lua self) -> Value<'lua>;
+    fn null(&self) -> Value;
 
     /// A metatable attachable to a Lua table to systematically encode it as Array (instead of Map).
     /// As result, encoded Array will contain only sequence part of the table, with the same length
     /// as the `#` operator on that table.
     ///
-    /// Requires `feature = "serialize"`
-    ///
     /// # Example
     ///
     /// ```
@@ -68,12 +63,10 @@ pub trait LuaSerdeExt<'lua> {
     ///     Ok(())
     /// }
     /// ```
-    fn array_metatable(&'lua self) -> Table<'lua>;
+    fn array_metatable(&self) -> Table;
 
     /// Converts `T` into a [`Value`] instance.
     ///
-    /// Requires `feature = "serialize"`
-    ///
     /// [`Value`]: crate::Value
     ///
     /// # Example
@@ -101,14 +94,10 @@ pub trait LuaSerdeExt<'lua> {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value<T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
+    fn to_value<T: Serialize + ?Sized>(&self, t: &T) -> Result<Value>;
 
     /// Converts `T` into a [`Value`] instance with options.
     ///
-    /// Requires `feature = "serialize"`
-    ///
-    /// [`Value`]: crate::Value
-    ///
     /// # Example
     ///
     /// ```
@@ -126,16 +115,12 @@ pub trait LuaSerdeExt<'lua> {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<T>(&self, t: &T, options: ser::Options) -> Result<Value>
     where
         T: Serialize + ?Sized;
 
     /// Deserializes a [`Value`] into any serde deserializable object.
     ///
-    /// Requires `feature = "serialize"`
-    ///
-    /// [`Value`]: crate::Value
-    ///
     /// # Example
     ///
     /// ```
@@ -159,14 +144,10 @@ pub trait LuaSerdeExt<'lua> {
     /// }
     /// ```
     #[allow(clippy::wrong_self_convention)]
-    fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> Result<T>;
+    fn from_value<T: DeserializeOwned>(&self, value: Value) -> Result<T>;
 
     /// Deserializes a [`Value`] into any serde deserializable object with options.
     ///
-    /// Requires `feature = "serialize"`
-    ///
-    /// [`Value`]: crate::Value
-    ///
     /// # Example
     ///
     /// ```
@@ -191,53 +172,46 @@ pub trait LuaSerdeExt<'lua> {
     /// }
     /// ```
     #[allow(clippy::wrong_self_convention)]
-    fn from_value_with<T: Deserialize<'lua>>(
-        &'lua self,
-        value: Value<'lua>,
-        options: de::Options,
-    ) -> Result<T>;
+    fn from_value_with<T: DeserializeOwned>(&self, value: Value, options: de::Options) -> Result<T>;
 }
 
-impl<'lua> LuaSerdeExt<'lua> for Lua {
-    fn null(&'lua self) -> Value<'lua> {
-        Value::LightUserData(LightUserData(ptr::null_mut()))
+impl LuaSerdeExt for Lua {
+    fn null(&self) -> Value {
+        Value::NULL
     }
 
-    fn array_metatable(&'lua self) -> Table<'lua> {
+    fn array_metatable(&self) -> Table {
+        let lua = self.lock();
         unsafe {
-            let _sg = StackGuard::new(self.state);
-            assert_stack(self.state, 1);
-
-            push_array_metatable(self.state);
-
-            Table(self.pop_ref())
+            push_array_metatable(lua.ref_thread());
+            Table(lua.pop_ref_thread())
         }
     }
 
-    fn to_value<T>(&'lua self, t: &T) -> Result<Value<'lua>>
+    fn to_value<T>(&self, t: &T) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
         t.serialize(ser::Serializer::new(self))
     }
 
-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<T>(&self, t: &T, options: ser::Options) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
         t.serialize(ser::Serializer::new_with_options(self, options))
     }
 
-    fn from_value<T>(&'lua self, value: Value<'lua>) -> Result<T>
+    fn from_value<T>(&self, value: Value) -> Result<T>
     where
-        T: Deserialize<'lua>,
+        T: DeserializeOwned,
     {
         T::deserialize(de::Deserializer::new(value))
     }
 
-    fn from_value_with<T>(&'lua self, value: Value<'lua>, options: de::Options) -> Result<T>
+    fn from_value_with<T>(&self, value: Value, options: de::Options) -> Result<T>
     where
-        T: Deserialize<'lua>,
+        T: DeserializeOwned,
     {
         T::deserialize(de::Deserializer::new_with_options(value, options))
     }

src/serde/ser.rs

@@ -1,21 +1,18 @@
-use std::os::raw::c_int;
+//! Serialize a Rust data structure into Lua value.
 
 use serde::{ser, Serialize};
 
 use super::LuaSerdeExt;
 use crate::error::{Error, Result};
-use crate::ffi;
-use crate::lua::Lua;
-use crate::string::String;
+use crate::state::Lua;
 use crate::table::Table;
-use crate::types::Integer;
-use crate::util::{check_stack, StackGuard};
-use crate::value::{ToLua, Value};
+use crate::traits::IntoLua;
+use crate::value::Value;
 
 /// A struct for serializing Rust values into Lua values.
 #[derive(Debug)]
-pub struct Serializer<'lua> {
-    lua: &'lua Lua,
+pub struct Serializer<'a> {
+    lua: &'a Lua,
     options: Options,
 }
 
@@ -48,11 +45,17 @@ pub struct Options {
     /// [`null`]: crate::LuaSerdeExt::null
     /// [`Nil`]: crate::Value::Nil
     pub serialize_unit_to_null: bool,
+
+    /// If true, serialize `serde_json::Number` with arbitrary_precision to a Lua number.
+    /// Otherwise it will be serialized as an object (what serde does).
+    ///
+    /// Default: **false**
+    pub detect_serde_json_arbitrary_precision: bool,
 }
 
 impl Default for Options {
     fn default() -> Self {
-        Self::new()
+        const { Self::new() }
     }
 }
 
@@ -63,6 +66,7 @@ impl Options {
             set_array_metatable: true,
             serialize_none_to_null: true,
             serialize_unit_to_null: true,
+            detect_serde_json_arbitrary_precision: false,
         }
     }
 
@@ -92,16 +96,30 @@ impl Options {
         self.serialize_unit_to_null = enabled;
         self
     }
+
+    /// Sets [`detect_serde_json_arbitrary_precision`] option.
+    ///
+    /// This option is used to serialize `serde_json::Number` with arbitrary precision to a Lua
+    /// number. Otherwise it will be serialized as an object (what serde does).
+    ///
+    /// This option is disabled by default.
+    ///
+    /// [`detect_serde_json_arbitrary_precision`]: #structfield.detect_serde_json_arbitrary_precision
+    #[must_use]
+    pub const fn detect_serde_json_arbitrary_precision(mut self, enabled: bool) -> Self {
+        self.detect_serde_json_arbitrary_precision = enabled;
+        self
+    }
 }
 
-impl<'lua> Serializer<'lua> {
+impl<'a> Serializer<'a> {
     /// Creates a new Lua Serializer with default options.
-    pub fn new(lua: &'lua Lua) -> Self {
+    pub fn new(lua: &'a Lua) -> Self {
         Self::new_with_options(lua, Options::default())
     }
 
     /// Creates a new Lua Serializer with custom options.
-    pub fn new_with_options(lua: &'lua Lua, options: Options) -> Self {
+    pub fn new_with_options(lua: &'a Lua, options: Options) -> Self {
         Serializer { lua, options }
     }
 }
@@ -109,28 +127,28 @@ impl<'lua> Serializer<'lua> {
 macro_rules! lua_serialize_number {
     ($name:ident, $t:ty) => {
         #[inline]
-        fn $name(self, value: $t) -> Result<Value<'lua>> {
-            value.to_lua(self.lua)
+        fn $name(self, value: $t) -> Result<Value> {
+            value.into_lua(self.lua)
         }
     };
 }
 
-impl<'lua> ser::Serializer for Serializer<'lua> {
-    type Ok = Value<'lua>;
+impl<'a> ser::Serializer for Serializer<'a> {
+    type Ok = Value;
     type Error = Error;
 
     // Associated types for keeping track of additional state while serializing
     // compound data structures like sequences and maps.
-    type SerializeSeq = SerializeVec<'lua>;
-    type SerializeTuple = SerializeVec<'lua>;
-    type SerializeTupleStruct = SerializeVec<'lua>;
-    type SerializeTupleVariant = SerializeTupleVariant<'lua>;
-    type SerializeMap = SerializeMap<'lua>;
-    type SerializeStruct = SerializeMap<'lua>;
-    type SerializeStructVariant = SerializeStructVariant<'lua>;
+    type SerializeSeq = SerializeSeq<'a>;
+    type SerializeTuple = SerializeSeq<'a>;
+    type SerializeTupleStruct = SerializeSeq<'a>;
+    type SerializeTupleVariant = SerializeTupleVariant<'a>;
+    type SerializeMap = SerializeMap<'a>;
+    type SerializeStruct = SerializeStruct<'a>;
+    type SerializeStructVariant = SerializeStructVariant<'a>;
 
     #[inline]
-    fn serialize_bool(self, value: bool) -> Result<Value<'lua>> {
+    fn serialize_bool(self, value: bool) -> Result<Value> {
         Ok(Value::Boolean(value))
     }
 
@@ -149,22 +167,22 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     lua_serialize_number!(serialize_f64, f64);
 
     #[inline]
-    fn serialize_char(self, value: char) -> Result<Value<'lua>> {
+    fn serialize_char(self, value: char) -> Result<Value> {
         self.serialize_str(&value.to_string())
     }
 
     #[inline]
-    fn serialize_str(self, value: &str) -> Result<Value<'lua>> {
+    fn serialize_str(self, value: &str) -> Result<Value> {
         self.lua.create_string(value).map(Value::String)
     }
 
     #[inline]
-    fn serialize_bytes(self, value: &[u8]) -> Result<Value<'lua>> {
+    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
         self.lua.create_string(value).map(Value::String)
     }
 
     #[inline]
-    fn serialize_none(self) -> Result<Value<'lua>> {
+    fn serialize_none(self) -> Result<Value> {
         if self.options.serialize_none_to_null {
             Ok(self.lua.null())
         } else {
@@ -173,7 +191,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_some<T>(self, value: &T) -> Result<Value<'lua>>
+    fn serialize_some<T>(self, value: &T) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
@@ -181,7 +199,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_unit(self) -> Result<Value<'lua>> {
+    fn serialize_unit(self) -> Result<Value> {
         if self.options.serialize_unit_to_null {
             Ok(self.lua.null())
         } else {
@@ -190,7 +208,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value<'lua>> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
         if self.options.serialize_unit_to_null {
             Ok(self.lua.null())
         } else {
@@ -204,12 +222,12 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         _name: &'static str,
         _variant_index: u32,
         variant: &'static str,
-    ) -> Result<Value<'lua>> {
+    ) -> Result<Value> {
         self.serialize_str(variant)
     }
 
     #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value<'lua>>
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
@@ -223,7 +241,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         _variant_index: u32,
         variant: &'static str,
         value: &T,
-    ) -> Result<Value<'lua>>
+    ) -> Result<Value>
     where
         T: Serialize + ?Sized,
     {
@@ -236,13 +254,11 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     #[inline]
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        let len = len.unwrap_or(0) as c_int;
-        let table = self.lua.create_table_with_capacity(len, 0)?;
+        let table = self.lua.create_table_with_capacity(len.unwrap_or(0), 0)?;
         if self.options.set_array_metatable {
-            table.set_metatable(Some(self.lua.array_metatable()));
+            table.set_metatable(Some(self.lua.array_metatable()))?;
         }
-        let options = self.options;
-        Ok(SerializeVec { table, options })
+        Ok(SerializeSeq::new(self.lua, table, self.options))
     }
 
     #[inline]
@@ -251,11 +267,12 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     }
 
     #[inline]
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
+    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
+        #[cfg(feature = "luau")]
+        if name == "Vector" && len == crate::Vector::SIZE {
+            return Ok(SerializeSeq::new_vector(self.lua, self.options));
+        }
+        _ = name;
         self.serialize_seq(Some(len))
     }
 
@@ -268,7 +285,8 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         _len: usize,
     ) -> Result<Self::SerializeTupleVariant> {
         Ok(SerializeTupleVariant {
-            name: self.lua.create_string(variant)?,
+            lua: self.lua,
+            variant,
             table: self.lua.create_table()?,
             options: self.options,
         })
@@ -276,17 +294,32 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     #[inline]
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
-        let len = len.unwrap_or(0) as c_int;
         Ok(SerializeMap {
+            lua: self.lua,
             key: None,
-            table: self.lua.create_table_with_capacity(0, len)?,
+            table: self.lua.create_table_with_capacity(0, len.unwrap_or(0))?,
             options: self.options,
         })
     }
 
     #[inline]
-    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
-        self.serialize_map(Some(len))
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+        if self.options.detect_serde_json_arbitrary_precision
+            && name == "$serde_json::private::Number"
+            && len == 1
+        {
+            return Ok(SerializeStruct {
+                lua: self.lua,
+                inner: None,
+                options: self.options,
+            });
+        }
+
+        Ok(SerializeStruct {
+            lua: self.lua,
+            inner: Some(Value::Table(self.lua.create_table_with_capacity(0, len)?)),
+            options: self.options,
+        })
     }
 
     #[inline]
@@ -298,56 +331,70 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         len: usize,
     ) -> Result<Self::SerializeStructVariant> {
         Ok(SerializeStructVariant {
-            name: self.lua.create_string(variant)?,
-            table: self.lua.create_table_with_capacity(0, len as c_int)?,
+            lua: self.lua,
+            variant,
+            table: self.lua.create_table_with_capacity(0, len)?,
             options: self.options,
         })
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeVec<'lua> {
-    table: Table<'lua>,
+pub struct SerializeSeq<'a> {
+    lua: &'a Lua,
+    #[cfg(feature = "luau")]
+    vector: Option<crate::Vector>,
+    table: Option<Table>,
+    next: usize,
     options: Options,
 }
 
-impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
-    type Ok = Value<'lua>;
+impl<'a> SerializeSeq<'a> {
+    fn new(lua: &'a Lua, table: Table, options: Options) -> Self {
+        Self {
+            lua,
+            #[cfg(feature = "luau")]
+            vector: None,
+            table: Some(table),
+            next: 0,
+            options,
+        }
+    }
+
+    #[cfg(feature = "luau")]
+    const fn new_vector(lua: &'a Lua, options: Options) -> Self {
+        Self {
+            lua,
+            vector: Some(crate::Vector::zero()),
+            table: None,
+            next: 0,
+            options,
+        }
+    }
+}
+
+impl ser::SerializeSeq for SerializeSeq<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        let value = lua.to_value_with(value, self.options)?;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 4)?;
-
-            lua.push_ref(&self.table.0);
-            lua.push_value(value)?;
-            if lua.unlikely_memory_error() {
-                let len = ffi::lua_rawlen(lua.state, -2) as Integer;
-                ffi::lua_rawseti(lua.state, -2, len + 1);
-                ffi::lua_pop(lua.state, 1);
-                Ok(())
-            } else {
-                protect_lua!(lua.state, 2, 0, fn(state) {
-                    let len = ffi::lua_rawlen(state, -2) as Integer;
-                    ffi::lua_rawseti(state, -2, len + 1);
-                })
-            }
-        }
+        let value = self.lua.to_value_with(value, self.options)?;
+        let table = self.table.as_ref().unwrap();
+        table.raw_seti(self.next + 1, value)?;
+        self.next += 1;
+        Ok(())
     }
 
-    fn end(self) -> Result<Value<'lua>> {
-        Ok(Value::Table(self.table))
+    fn end(self) -> Result<Value> {
+        Ok(Value::Table(self.table.unwrap()))
     }
 }
 
-impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTuple for SerializeSeq<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
@@ -357,73 +404,82 @@ impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
         ser::SerializeSeq::serialize_element(self, value)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
         ser::SerializeSeq::end(self)
     }
 }
 
-impl<'lua> ser::SerializeTupleStruct for SerializeVec<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTupleStruct for SerializeSeq<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector.as_mut() {
+            let value = self.lua.to_value_with(value, self.options)?;
+            let value = self.lua.unpack(value)?;
+            vector.0[self.next] = value;
+            self.next += 1;
+            return Ok(());
+        }
         ser::SerializeSeq::serialize_element(self, value)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector {
+            return Ok(Value::Vector(vector));
+        }
         ser::SerializeSeq::end(self)
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeTupleVariant<'lua> {
-    name: String<'lua>,
-    table: Table<'lua>,
+pub struct SerializeTupleVariant<'a> {
+    lua: &'a Lua,
+    variant: &'static str,
+    table: Table,
     options: Options,
 }
 
-impl<'lua> ser::SerializeTupleVariant for SerializeTupleVariant<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTupleVariant for SerializeTupleVariant<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        let idx = self.table.raw_len() + 1;
-        self.table
-            .raw_insert(idx, lua.to_value_with(value, self.options)?)
+        self.table.raw_push(self.lua.to_value_with(value, self.options)?)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
-        let lua = self.table.0.lua;
-        let table = lua.create_table()?;
-        table.raw_set(self.name, self.table)?;
+    fn end(self) -> Result<Value> {
+        let table = self.lua.create_table()?;
+        table.raw_set(self.variant, self.table)?;
         Ok(Value::Table(table))
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeMap<'lua> {
-    table: Table<'lua>,
-    key: Option<Value<'lua>>,
+pub struct SerializeMap<'a> {
+    lua: &'a Lua,
+    table: Table,
+    key: Option<Value>,
     options: Options,
 }
 
-impl<'lua> ser::SerializeMap for SerializeMap<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeMap for SerializeMap<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_key<T>(&mut self, key: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        self.key = Some(lua.to_value_with(key, self.options)?);
+        self.key = Some(self.lua.to_value_with(key, self.options)?);
         Ok(())
     }
 
@@ -431,62 +487,90 @@ impl<'lua> ser::SerializeMap for SerializeMap<'lua> {
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
-        let key = mlua_expect!(
-            self.key.take(),
-            "serialize_value called before serialize_key"
-        );
-        let value = lua.to_value_with(value, self.options)?;
+        let key = mlua_expect!(self.key.take(), "serialize_value called before serialize_key");
+        let value = self.lua.to_value_with(value, self.options)?;
         self.table.raw_set(key, value)
     }
 
-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
         Ok(Value::Table(self.table))
     }
 }
 
-impl<'lua> ser::SerializeStruct for SerializeMap<'lua> {
-    type Ok = Value<'lua>;
+#[doc(hidden)]
+pub struct SerializeStruct<'a> {
+    lua: &'a Lua,
+    inner: Option<Value>,
+    options: Options,
+}
+
+impl ser::SerializeStruct for SerializeStruct<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        ser::SerializeMap::serialize_key(self, key)?;
-        ser::SerializeMap::serialize_value(self, value)
+        match self.inner {
+            Some(Value::Table(ref table)) => {
+                table.raw_set(key, self.lua.to_value_with(value, self.options)?)?;
+            }
+            None if self.options.detect_serde_json_arbitrary_precision => {
+                // A special case for `serde_json::Number` with arbitrary precision.
+                assert_eq!(key, "$serde_json::private::Number");
+                self.inner = Some(self.lua.to_value_with(value, self.options)?);
+            }
+            _ => unreachable!(),
+        }
+        Ok(())
     }
 
-    fn end(self) -> Result<Value<'lua>> {
-        ser::SerializeMap::end(self)
+    fn end(self) -> Result<Value> {
+        match self.inner {
+            Some(table @ Value::Table(_)) => Ok(table),
+            Some(value @ Value::String(_)) if self.options.detect_serde_json_arbitrary_precision => {
+                let number_s = value.to_string()?;
+                if number_s.contains(['.', 'e', 'E']) {
+                    if let Ok(number) = number_s.parse().map(Value::Number) {
+                        return Ok(number);
+                    }
+                }
+                Ok(number_s
+                    .parse()
+                    .map(Value::Integer)
+                    .or_else(|_| number_s.parse().map(Value::Number))
+                    .unwrap_or(value))
+            }
+            _ => unreachable!(),
+        }
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeStructVariant<'lua> {
-    name: String<'lua>,
-    table: Table<'lua>,
+pub struct SerializeStructVariant<'a> {
+    lua: &'a Lua,
+    variant: &'static str,
+    table: Table,
     options: Options,
 }
 
-impl<'lua> ser::SerializeStructVariant for SerializeStructVariant<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeStructVariant for SerializeStructVariant<'_> {
+    type Ok = Value;
     type Error = Error;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
         T: Serialize + ?Sized,
     {
-        let lua = self.table.0.lua;
         self.table
-            .raw_set(key, lua.to_value_with(value, self.options)?)?;
+            .raw_set(key, self.lua.to_value_with(value, self.options)?)?;
         Ok(())
     }
 
-    fn end(self) -> Result<Value<'lua>> {
-        let lua = self.table.0.lua;
-        let table = lua.create_table()?;
-        table.raw_set(self.name, self.table)?;
+    fn end(self) -> Result<Value> {
+        let table = self.lua.create_table_with_capacity(0, 1)?;
+        table.raw_set(self.variant, self.table)?;
         Ok(Value::Table(table))
     }
 }

src/state/extra.rs

@@ -0,0 +1,290 @@
+use std::any::TypeId;
+use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
+use std::os::raw::{c_int, c_void};
+use std::ptr;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+use rustc_hash::FxHashMap;
+
+use crate::error::Result;
+use crate::state::RawLua;
+use crate::stdlib::StdLib;
+use crate::types::{AppData, ReentrantMutex, XRc};
+use crate::userdata::RawUserDataRegistry;
+use crate::util::{get_internal_metatable, push_internal_userdata, TypeKey, WrappedFailure};
+
+#[cfg(any(feature = "luau", doc))]
+use crate::chunk::Compiler;
+
+#[cfg(feature = "async")]
+use {futures_util::task::noop_waker_ref, std::ptr::NonNull, std::task::Waker};
+
+use super::{Lua, WeakLua};
+
+// Unique key to store `ExtraData` in the registry
+static EXTRA_REGISTRY_KEY: u8 = 0;
+
+const WRAPPED_FAILURE_POOL_DEFAULT_CAPACITY: usize = 64;
+const REF_STACK_RESERVE: c_int = 3;
+
+/// Data associated with the Lua state.
+pub(crate) struct ExtraData {
+    pub(super) lua: MaybeUninit<Lua>,
+    pub(super) weak: MaybeUninit<WeakLua>,
+    pub(super) owned: bool,
+
+    pub(super) pending_userdata_reg: FxHashMap<TypeId, RawUserDataRegistry>,
+    pub(super) registered_userdata_t: FxHashMap<TypeId, c_int>,
+    pub(super) registered_userdata_mt: FxHashMap<*const c_void, Option<TypeId>>,
+    pub(super) last_checked_userdata_mt: (*const c_void, Option<TypeId>),
+
+    // When Lua instance dropped, setting `None` would prevent collecting `RegistryKey`s
+    pub(super) registry_unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
+
+    // Containers to store arbitrary data (extensions)
+    pub(super) app_data: AppData,
+    pub(super) app_data_priv: AppData,
+
+    pub(super) safe: bool,
+    pub(super) libs: StdLib,
+    // Used in module mode
+    pub(super) skip_memory_check: bool,
+
+    // Auxiliary thread to store references
+    pub(super) ref_thread: *mut ffi::lua_State,
+    pub(super) ref_stack_size: c_int,
+    pub(super) ref_stack_top: c_int,
+    pub(super) ref_free: Vec<c_int>,
+
+    // Pool of `WrappedFailure` enums in the ref thread (as userdata)
+    pub(super) wrapped_failure_pool: Vec<c_int>,
+    pub(super) wrapped_failure_top: usize,
+    // Pool of `Thread`s (coroutines) for async execution
+    #[cfg(feature = "async")]
+    pub(super) thread_pool: Vec<crate::types::ValueRefIndex>,
+
+    // Address of `WrappedFailure` metatable
+    pub(super) wrapped_failure_mt_ptr: *const c_void,
+
+    // Waker for polling futures
+    #[cfg(feature = "async")]
+    pub(super) waker: NonNull<Waker>,
+
+    #[cfg(not(feature = "luau"))]
+    pub(super) hook_callback: Option<crate::types::HookCallback>,
+    #[cfg(not(feature = "luau"))]
+    pub(super) hook_triggers: crate::debug::HookTriggers,
+    #[cfg(feature = "lua54")]
+    pub(super) warn_callback: Option<crate::types::WarnCallback>,
+    #[cfg(feature = "luau")]
+    pub(super) interrupt_callback: Option<crate::types::InterruptCallback>,
+    #[cfg(feature = "luau")]
+    pub(super) thread_creation_callback: Option<crate::types::ThreadCreationCallback>,
+    #[cfg(feature = "luau")]
+    pub(super) thread_collection_callback: Option<crate::types::ThreadCollectionCallback>,
+
+    #[cfg(feature = "luau")]
+    pub(crate) running_gc: bool,
+    #[cfg(feature = "luau")]
+    pub(crate) sandboxed: bool,
+    #[cfg(feature = "luau")]
+    pub(super) compiler: Option<Compiler>,
+    #[cfg(feature = "luau-jit")]
+    pub(super) enable_jit: bool,
+}
+
+impl Drop for ExtraData {
+    fn drop(&mut self) {
+        unsafe {
+            if !self.owned {
+                self.lua.assume_init_drop();
+            }
+
+            self.weak.assume_init_drop();
+        }
+        *self.registry_unref_list.lock() = None;
+    }
+}
+
+static EXTRA_TYPE_KEY: u8 = 0;
+
+impl TypeKey for XRc<UnsafeCell<ExtraData>> {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &EXTRA_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+impl ExtraData {
+    // Index of `error_traceback` function in auxiliary thread stack
+    #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+    pub(super) const ERROR_TRACEBACK_IDX: c_int = 1;
+
+    pub(super) unsafe fn init(state: *mut ffi::lua_State, owned: bool) -> XRc<UnsafeCell<Self>> {
+        // Create ref stack thread and place it in the registry to prevent it
+        // from being garbage collected.
+        let ref_thread = mlua_expect!(
+            protect_lua!(state, 0, 0, |state| {
+                let thread = ffi::lua_newthread(state);
+                ffi::luaL_ref(state, ffi::LUA_REGISTRYINDEX);
+                thread
+            }),
+            "Error while creating ref thread",
+        );
+
+        let wrapped_failure_mt_ptr = {
+            get_internal_metatable::<WrappedFailure>(state);
+            let ptr = ffi::lua_topointer(state, -1);
+            ffi::lua_pop(state, 1);
+            ptr
+        };
+
+        // Store `error_traceback` function on the ref stack
+        #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+        {
+            ffi::lua_pushcfunction(ref_thread, crate::util::error_traceback);
+            assert_eq!(ffi::lua_gettop(ref_thread), Self::ERROR_TRACEBACK_IDX);
+        }
+
+        #[allow(clippy::arc_with_non_send_sync)]
+        let extra = XRc::new(UnsafeCell::new(ExtraData {
+            lua: MaybeUninit::uninit(),
+            weak: MaybeUninit::uninit(),
+            owned,
+            pending_userdata_reg: FxHashMap::default(),
+            registered_userdata_t: FxHashMap::default(),
+            registered_userdata_mt: FxHashMap::default(),
+            last_checked_userdata_mt: (ptr::null(), None),
+            registry_unref_list: Arc::new(Mutex::new(Some(Vec::new()))),
+            app_data: AppData::default(),
+            app_data_priv: AppData::default(),
+            safe: false,
+            libs: StdLib::NONE,
+            skip_memory_check: false,
+            ref_thread,
+            // We need some reserved stack space to move values in and out of the ref stack.
+            ref_stack_size: ffi::LUA_MINSTACK - REF_STACK_RESERVE,
+            ref_stack_top: ffi::lua_gettop(ref_thread),
+            ref_free: Vec::new(),
+            wrapped_failure_pool: Vec::with_capacity(WRAPPED_FAILURE_POOL_DEFAULT_CAPACITY),
+            wrapped_failure_top: 0,
+            #[cfg(feature = "async")]
+            thread_pool: Vec::new(),
+            wrapped_failure_mt_ptr,
+            #[cfg(feature = "async")]
+            waker: NonNull::from(noop_waker_ref()),
+            #[cfg(not(feature = "luau"))]
+            hook_callback: None,
+            #[cfg(not(feature = "luau"))]
+            hook_triggers: Default::default(),
+            #[cfg(feature = "lua54")]
+            warn_callback: None,
+            #[cfg(feature = "luau")]
+            interrupt_callback: None,
+            #[cfg(feature = "luau")]
+            thread_creation_callback: None,
+            #[cfg(feature = "luau")]
+            thread_collection_callback: None,
+            #[cfg(feature = "luau")]
+            sandboxed: false,
+            #[cfg(feature = "luau")]
+            compiler: None,
+            #[cfg(feature = "luau-jit")]
+            enable_jit: true,
+            #[cfg(feature = "luau")]
+            running_gc: false,
+        }));
+
+        // Store it in the registry
+        mlua_expect!(Self::store(&extra, state), "Error while storing extra data");
+
+        extra
+    }
+
+    pub(super) unsafe fn set_lua(&mut self, raw: &XRc<ReentrantMutex<RawLua>>) {
+        self.lua.write(Lua {
+            raw: XRc::clone(raw),
+            collect_garbage: false,
+        });
+        self.weak.write(WeakLua(XRc::downgrade(raw)));
+    }
+
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        #[cfg(feature = "luau")]
+        if cfg!(not(feature = "module")) {
+            // In the main app we can use `lua_callbacks` to access ExtraData
+            return (*ffi::lua_callbacks(state)).userdata as *mut _;
+        }
+
+        let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
+        if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, extra_key) != ffi::LUA_TUSERDATA {
+            // `ExtraData` can be null only when Lua state is foreign.
+            // This case in used in `Lua::try_from_ptr()`.
+            ffi::lua_pop(state, 1);
+            return ptr::null_mut();
+        }
+        let extra_ptr = ffi::lua_touserdata(state, -1) as *mut Rc<UnsafeCell<ExtraData>>;
+        ffi::lua_pop(state, 1);
+        (*extra_ptr).get()
+    }
+
+    unsafe fn store(extra: &XRc<UnsafeCell<Self>>, state: *mut ffi::lua_State) -> Result<()> {
+        #[cfg(feature = "luau")]
+        if cfg!(not(feature = "module")) {
+            (*ffi::lua_callbacks(state)).userdata = extra.get() as *mut _;
+            return Ok(());
+        }
+
+        push_internal_userdata(state, XRc::clone(extra), true)?;
+        protect_lua!(state, 1, 0, fn(state) {
+            let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
+            ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, extra_key);
+        })
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn lua(&self) -> &Lua {
+        self.lua.assume_init_ref()
+    }
+
+    #[inline(always)]
+    pub(crate) unsafe fn raw_lua(&self) -> &RawLua {
+        &*self.lua.assume_init_ref().raw.data_ptr()
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn weak(&self) -> &WeakLua {
+        self.weak.assume_init_ref()
+    }
+
+    /// Pops a reference from top of the auxiliary stack and move it to a first free slot.
+    pub(super) unsafe fn ref_stack_pop(&mut self) -> c_int {
+        if let Some(free) = self.ref_free.pop() {
+            ffi::lua_replace(self.ref_thread, free);
+            return free;
+        }
+
+        // Try to grow max stack size
+        if self.ref_stack_top >= self.ref_stack_size {
+            let mut inc = self.ref_stack_size; // Try to double stack size
+            while inc > 0 && ffi::lua_checkstack(self.ref_thread, inc + REF_STACK_RESERVE) == 0 {
+                inc /= 2;
+            }
+            if inc == 0 {
+                // Pop item on top of the stack to avoid stack leaking and successfully run destructors
+                // during unwinding.
+                ffi::lua_pop(self.ref_thread, 1);
+                let top = self.ref_stack_top;
+                // It is a user error to create too many references to exhaust the Lua max stack size
+                // for the ref thread.
+                panic!("cannot create a Lua reference, out of auxiliary stack space (used {top} slots)");
+            }
+            self.ref_stack_size += inc;
+        }
+        self.ref_stack_top += 1;
+        self.ref_stack_top
+    }
+}

src/state/util.rs

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

src/stdlib.rs

@@ -1,5 +1,4 @@
 use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};
-use std::u32;
 
 /// Flags describing the set of lua standard libraries to load.
 #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
@@ -7,54 +6,68 @@ pub struct StdLib(u32);
 
 impl StdLib {
     /// [`coroutine`](https://www.lua.org/manual/5.4/manual.html#6.2) library
-    ///
-    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau")))
+    )]
     pub const COROUTINE: StdLib = StdLib(1);
+
     /// [`table`](https://www.lua.org/manual/5.4/manual.html#6.6) library
     pub const TABLE: StdLib = StdLib(1 << 1);
+
     /// [`io`](https://www.lua.org/manual/5.4/manual.html#6.8) library
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub const IO: StdLib = StdLib(1 << 2);
+
     /// [`os`](https://www.lua.org/manual/5.4/manual.html#6.9) library
     pub const OS: StdLib = StdLib(1 << 3);
+
     /// [`string`](https://www.lua.org/manual/5.4/manual.html#6.4) library
     pub const STRING: StdLib = StdLib(1 << 4);
+
     /// [`utf8`](https://www.lua.org/manual/5.4/manual.html#6.5) library
-    ///
-    /// Requires `feature = "lua54/lua53/luau"`
     #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))))]
     pub const UTF8: StdLib = StdLib(1 << 5);
+
     /// [`bit`](https://www.lua.org/manual/5.2/manual.html#6.7) library
-    ///
-    /// Requires `feature = "lua52/luajit/luau"`
     #[cfg(any(feature = "lua52", feature = "luajit", feature = "luau", doc))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "lua52", feature = "luajit", feature = "luau")))
+    )]
     pub const BIT: StdLib = StdLib(1 << 6);
+
     /// [`math`](https://www.lua.org/manual/5.4/manual.html#6.7) library
     pub const MATH: StdLib = StdLib(1 << 7);
+
     /// [`package`](https://www.lua.org/manual/5.4/manual.html#6.3) library
     #[cfg(not(feature = "luau"))]
     #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub const PACKAGE: StdLib = StdLib(1 << 8);
+
+    /// [`buffer`](https://luau.org/library#buffer-library) library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub const BUFFER: StdLib = StdLib(1 << 9);
+
+    /// [`vector`](https://luau.org/library#vector-library) library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub const VECTOR: StdLib = StdLib(1 << 10);
+
     /// [`jit`](http://luajit.org/ext_jit.html) library
-    ///
-    /// Requires `feature = "luajit"`
     #[cfg(any(feature = "luajit", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
-    pub const JIT: StdLib = StdLib(1 << 9);
+    pub const JIT: StdLib = StdLib(1 << 11);
 
     /// (**unsafe**) [`ffi`](http://luajit.org/ext_ffi.html) library
-    ///
-    /// 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);
 

src/string.rs

@@ -1,28 +1,30 @@
 use std::borrow::{Borrow, Cow};
 use std::hash::{Hash, Hasher};
-use std::os::raw::c_void;
+use std::ops::Deref;
+use std::os::raw::{c_int, c_void};
 use std::string::String as StdString;
-use std::{slice, str};
+use std::{cmp, fmt, slice, str};
 
-#[cfg(feature = "serialize")]
+use crate::error::{Error, Result};
+use crate::state::Lua;
+use crate::traits::IntoLua;
+use crate::types::{LuaType, ValueRef};
+use crate::value::Value;
+
+#[cfg(feature = "serde")]
 use {
     serde::ser::{Serialize, Serializer},
     std::result::Result as StdResult,
 };
 
-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)]
-pub struct String<'lua>(pub(crate) LuaRef<'lua>);
+#[derive(Clone)]
+pub struct String(pub(crate) ValueRef);
 
-impl<'lua> String<'lua> {
-    /// Get a `&str` slice if the Lua string is valid UTF-8.
+impl String {
+    /// Get a [`BorrowedStr`] if the Lua string is valid UTF-8.
     ///
     /// # Examples
     ///
@@ -40,19 +42,20 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn to_str(&self) -> Result<&str> {
-        str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
-            from: "string",
-            to: "&str",
-            message: Some(e.to_string()),
-        })
+    #[inline]
+    pub fn to_str(&self) -> Result<BorrowedStr<'_>> {
+        BorrowedStr::try_from(self)
     }
 
-    /// Converts this string to a [`Cow<str>`].
+    /// Converts this string to a [`StdString`].
     ///
     /// Any non-Unicode sequences are replaced with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].
     ///
+    /// This method returns [`StdString`] instead of [`Cow<'_, str>`] because lifetime cannot be
+    /// bound to a weak Lua object.
+    ///
     /// [U+FFFD]: std::char::REPLACEMENT_CHARACTER
+    /// [`Cow<'_, str>`]: std::borrow::Cow
     ///
     /// # Examples
     ///
@@ -66,13 +69,24 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        StdString::from_utf8_lossy(self.as_bytes())
+    #[inline]
+    pub fn to_string_lossy(&self) -> StdString {
+        StdString::from_utf8_lossy(&self.as_bytes()).into_owned()
+    }
+
+    /// Returns an object that implements [`Display`] for safely printing a Lua [`String`] that may
+    /// contain non-Unicode data.
+    ///
+    /// This may perform lossy conversion.
+    ///
+    /// [`Display`]: fmt::Display
+    pub fn display(&self) -> impl fmt::Display + '_ {
+        Display(self)
     }
 
     /// Get the bytes that make up this string.
     ///
-    /// The returned slice will not contain the terminating nul byte, but will contain any nul
+    /// The returned slice will not contain the terminating null byte, but will contain any null
     /// bytes embedded into the Lua string.
     ///
     /// # Examples
@@ -87,91 +101,334 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn as_bytes(&self) -> &[u8] {
-        let nulled = self.as_bytes_with_nul();
-        &nulled[..nulled.len() - 1]
+    #[inline]
+    pub fn as_bytes(&self) -> BorrowedBytes<'_> {
+        BorrowedBytes::from(self)
     }
 
-    /// Get the bytes that make up this string, including the trailing nul byte.
-    pub fn as_bytes_with_nul(&self) -> &[u8] {
-        let lua = self.0.lua;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
+    /// Get the bytes that make up this string, including the trailing null byte.
+    pub fn as_bytes_with_nul(&self) -> BorrowedBytes<'_> {
+        let BorrowedBytes { buf, borrow, _lua } = BorrowedBytes::from(self);
+        // Include the trailing null byte (it's always present but excluded by default)
+        let buf = unsafe { slice::from_raw_parts((*buf).as_ptr(), (*buf).len() + 1) };
+        BorrowedBytes { buf, borrow, _lua }
+    }
+
+    // Does not return the terminating null byte
+    unsafe fn to_slice(&self) -> (&[u8], Lua) {
+        let lua = self.0.lua.upgrade();
+        let slice = {
+            let rawlua = lua.lock();
+            let ref_thread = rawlua.ref_thread();
 
-            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);
-
-            slice::from_raw_parts(data as *const u8, size + 1)
-        }
+            let mut size = 0;
+            let data = ffi::lua_tolstring(ref_thread, self.0.index, &mut size);
+            slice::from_raw_parts(data as *const u8, size)
+        };
+        (slice, lua)
     }
 
-    /// Converts the string to a generic C pointer.
+    /// Converts this string to a generic C pointer.
     ///
     /// There is no way to convert the pointer back to its original value.
     ///
     /// Typically this function is used only for hashing and debug information.
     #[inline]
     pub fn to_pointer(&self) -> *const c_void {
-        let lua = self.0.lua;
-        unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) }
+        self.0.to_pointer()
     }
 }
 
-impl<'lua> AsRef<[u8]> for String<'lua> {
-    fn as_ref(&self) -> &[u8] {
-        self.as_bytes()
+impl fmt::Debug for String {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let bytes = self.as_bytes();
+        // Check if the string is valid utf8
+        if let Ok(s) = str::from_utf8(&bytes) {
+            return s.fmt(f);
+        }
+
+        // Format as bytes
+        write!(f, "b")?;
+        <bstr::BStr as fmt::Debug>::fmt(bstr::BStr::new(&bytes), f)
     }
 }
 
-impl<'lua> Borrow<[u8]> for String<'lua> {
-    fn borrow(&self) -> &[u8] {
-        self.as_bytes()
-    }
-}
-
-// Lua strings are basically &[u8] slices, so implement PartialEq for anything resembling that.
+// Lua strings are basically `&[u8]` slices, so implement `PartialEq` for anything resembling that.
 //
-// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str`, `String` and `mlua::String`
-// itself.
+// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str` and `String`.
 //
 // The only downside is that this disallows a comparison with `Cow<str>`, as that only implements
 // `AsRef<str>`, which collides with this impl. Requiring `AsRef<str>` would fix that, but limit us
 // in other ways.
-impl<'lua, T> PartialEq<T> for String<'lua>
+impl<T> PartialEq<T> for String
 where
-    T: AsRef<[u8]>,
+    T: AsRef<[u8]> + ?Sized,
 {
     fn eq(&self, other: &T) -> bool {
         self.as_bytes() == other.as_ref()
     }
 }
 
-impl<'lua> Eq for String<'lua> {}
+impl PartialEq for String {
+    fn eq(&self, other: &String) -> bool {
+        self.as_bytes() == other.as_bytes()
+    }
+}
 
-impl<'lua> Hash for String<'lua> {
+impl Eq for String {}
+
+impl<T> PartialOrd<T> for String
+where
+    T: AsRef<[u8]> + ?Sized,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.as_bytes().partial_cmp(&other.as_ref())
+    }
+}
+
+impl PartialOrd for String {
+    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for String {
+    fn cmp(&self, other: &String) -> cmp::Ordering {
+        self.as_bytes().cmp(&other.as_bytes())
+    }
+}
+
+impl Hash for String {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.as_bytes().hash(state);
     }
 }
 
-#[cfg(feature = "serialize")]
-impl<'lua> Serialize for String<'lua> {
+#[cfg(feature = "serde")]
+impl Serialize for String {
     fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
     where
         S: Serializer,
     {
         match self.to_str() {
-            Ok(s) => serializer.serialize_str(s),
-            Err(_) => serializer.serialize_bytes(self.as_bytes()),
+            Ok(s) => serializer.serialize_str(&s),
+            Err(_) => serializer.serialize_bytes(&self.as_bytes()),
         }
     }
 }
+
+struct Display<'a>(&'a String);
+
+impl fmt::Display for Display<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let bytes = self.0.as_bytes();
+        <bstr::BStr as fmt::Display>::fmt(bstr::BStr::new(&bytes), f)
+    }
+}
+
+/// A borrowed string (`&str`) that holds a strong reference to the Lua state.
+pub struct BorrowedStr<'a> {
+    // `buf` points to a readonly memory managed by Lua
+    pub(crate) buf: &'a str,
+    pub(crate) borrow: Cow<'a, String>,
+    pub(crate) _lua: Lua,
+}
+
+impl Deref for BorrowedStr<'_> {
+    type Target = str;
+
+    #[inline(always)]
+    fn deref(&self) -> &str {
+        self.buf
+    }
+}
+
+impl Borrow<str> for BorrowedStr<'_> {
+    #[inline(always)]
+    fn borrow(&self) -> &str {
+        self.buf
+    }
+}
+
+impl AsRef<str> for BorrowedStr<'_> {
+    #[inline(always)]
+    fn as_ref(&self) -> &str {
+        self.buf
+    }
+}
+
+impl fmt::Display for BorrowedStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.buf.fmt(f)
+    }
+}
+
+impl fmt::Debug for BorrowedStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.buf.fmt(f)
+    }
+}
+
+impl<T> PartialEq<T> for BorrowedStr<'_>
+where
+    T: AsRef<str>,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.buf == other.as_ref()
+    }
+}
+
+impl Eq for BorrowedStr<'_> {}
+
+impl<T> PartialOrd<T> for BorrowedStr<'_>
+where
+    T: AsRef<str>,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.buf.partial_cmp(other.as_ref())
+    }
+}
+
+impl Ord for BorrowedStr<'_> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.buf.cmp(other.buf)
+    }
+}
+
+impl<'a> TryFrom<&'a String> for BorrowedStr<'a> {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(value: &'a String) -> Result<Self> {
+        let BorrowedBytes { buf, borrow, _lua } = BorrowedBytes::from(value);
+        let buf = str::from_utf8(buf).map_err(|e| Error::FromLuaConversionError {
+            from: "string",
+            to: "&str".to_string(),
+            message: Some(e.to_string()),
+        })?;
+        Ok(Self { buf, borrow, _lua })
+    }
+}
+
+/// A borrowed byte slice (`&[u8]`) that holds a strong reference to the Lua state.
+pub struct BorrowedBytes<'a> {
+    // `buf` points to a readonly memory managed by Lua
+    pub(crate) buf: &'a [u8],
+    pub(crate) borrow: Cow<'a, String>,
+    pub(crate) _lua: Lua,
+}
+
+impl Deref for BorrowedBytes<'_> {
+    type Target = [u8];
+
+    #[inline(always)]
+    fn deref(&self) -> &[u8] {
+        self.buf
+    }
+}
+
+impl Borrow<[u8]> for BorrowedBytes<'_> {
+    #[inline(always)]
+    fn borrow(&self) -> &[u8] {
+        self.buf
+    }
+}
+
+impl AsRef<[u8]> for BorrowedBytes<'_> {
+    #[inline(always)]
+    fn as_ref(&self) -> &[u8] {
+        self.buf
+    }
+}
+
+impl fmt::Debug for BorrowedBytes<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.buf.fmt(f)
+    }
+}
+
+impl<T> PartialEq<T> for BorrowedBytes<'_>
+where
+    T: AsRef<[u8]>,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.buf == other.as_ref()
+    }
+}
+
+impl Eq for BorrowedBytes<'_> {}
+
+impl<T> PartialOrd<T> for BorrowedBytes<'_>
+where
+    T: AsRef<[u8]>,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.buf.partial_cmp(other.as_ref())
+    }
+}
+
+impl Ord for BorrowedBytes<'_> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.buf.cmp(other.buf)
+    }
+}
+
+impl<'a> IntoIterator for &'a BorrowedBytes<'_> {
+    type Item = &'a u8;
+    type IntoIter = slice::Iter<'a, u8>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a> From<&'a String> for BorrowedBytes<'a> {
+    #[inline]
+    fn from(value: &'a String) -> Self {
+        let (buf, _lua) = unsafe { value.to_slice() };
+        let borrow = Cow::Borrowed(value);
+        Self { buf, borrow, _lua }
+    }
+}
+
+struct WrappedString<T: AsRef<[u8]>>(T);
+
+impl String {
+    /// Wraps bytes, returning an opaque type that implements [`IntoLua`] trait.
+    ///
+    /// This function uses [`Lua::create_string`] under the hood.
+    pub fn wrap(data: impl AsRef<[u8]>) -> impl IntoLua {
+        WrappedString(data)
+    }
+}
+
+impl<T: AsRef<[u8]>> IntoLua for WrappedString<T> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.create_string(self.0).map(Value::String)
+    }
+}
+
+impl LuaType for String {
+    const TYPE_ID: c_int = ffi::LUA_TSTRING;
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(String: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(String: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(BorrowedBytes: Send, Sync);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(BorrowedStr: Send, Sync);
+}

src/thread.rs

@@ -1,83 +1,116 @@
-use std::cmp;
-use std::os::raw::c_int;
+use std::fmt;
+use std::os::raw::{c_int, c_void};
 
 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};
-
-#[cfg(any(
-    feature = "lua54",
-    all(feature = "luajit", feature = "vendored"),
-    feature = "luau",
-))]
 use crate::function::Function;
+use crate::state::RawLua;
+use crate::traits::{FromLuaMulti, IntoLuaMulti};
+use crate::types::{LuaType, ValueRef};
+use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
+
+#[cfg(not(feature = "luau"))]
+use crate::{
+    debug::{Debug, HookTriggers},
+    types::HookKind,
+};
 
 #[cfg(feature = "async")]
 use {
-    crate::{
-        lua::{Lua, ASYNC_POLL_PENDING},
-        value::{MultiValue, Value},
-    },
-    futures_core::{future::Future, stream::Stream},
+    futures_util::stream::Stream,
     std::{
-        cell::RefCell,
+        future::Future,
         marker::PhantomData,
         pin::Pin,
+        ptr::NonNull,
         task::{Context, Poll, Waker},
     },
 };
 
-/// Status of a Lua thread (or coroutine).
+/// Status of a Lua thread (coroutine).
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum ThreadStatus {
-    /// The thread was just created, or is suspended because it has called `coroutine.yield`.
+    /// The thread was just created or is suspended (yielded).
     ///
     /// If a thread is in this state, it can be resumed by calling [`Thread::resume`].
-    ///
-    /// [`Thread::resume`]: crate::Thread::resume
     Resumable,
-    /// Either the thread has finished executing, or the thread is currently running.
-    Unresumable,
+    /// The thread is currently running.
+    Running,
+    /// The thread has finished executing.
+    Finished,
     /// The thread has raised a Lua error during execution.
     Error,
 }
 
-/// Handle to an internal Lua thread (or coroutine).
-#[derive(Clone, Debug)]
-pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
+/// Internal representation of a Lua thread status.
+///
+/// The number in `New` and `Yielded` variants is the number of arguments pushed
+/// to the thread stack.
+#[derive(Clone, Copy)]
+enum ThreadStatusInner {
+    New(c_int),
+    Running,
+    Yielded(c_int),
+    Finished,
+    Error,
+}
+
+impl ThreadStatusInner {
+    #[cfg(feature = "async")]
+    #[inline(always)]
+    fn is_resumable(self) -> bool {
+        matches!(self, ThreadStatusInner::New(_) | ThreadStatusInner::Yielded(_))
+    }
+
+    #[cfg(feature = "async")]
+    #[inline(always)]
+    fn is_yielded(self) -> bool {
+        matches!(self, ThreadStatusInner::Yielded(_))
+    }
+}
+
+/// Handle to an internal Lua thread (coroutine).
+#[derive(Clone)]
+pub struct Thread(pub(crate) ValueRef, pub(crate) *mut ffi::lua_State);
+
+#[cfg(feature = "send")]
+unsafe impl Send for Thread {}
+#[cfg(feature = "send")]
+unsafe impl Sync for Thread {}
 
 /// Thread (coroutine) representation as an async [`Future`] or [`Stream`].
 ///
-/// Requires `feature = "async"`
-///
-/// [`Future`]: futures_core::future::Future
-/// [`Stream`]: futures_core::stream::Stream
+/// [`Future`]: std::future::Future
+/// [`Stream`]: futures_util::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-#[derive(Debug)]
-pub struct AsyncThread<'lua, R> {
-    thread: Thread<'lua>,
-    args0: RefCell<Option<Result<MultiValue<'lua>>>>,
-    ret: PhantomData<R>,
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct AsyncThread<R> {
+    thread: Thread,
+    ret: PhantomData<fn() -> R>,
     recycle: bool,
 }
 
-impl<'lua> Thread<'lua> {
+impl Thread {
+    /// Returns reference to the Lua state that this thread is associated with.
+    #[doc(hidden)]
+    #[inline(always)]
+    pub fn state(&self) -> *mut ffi::lua_State {
+        self.1
+    }
+
     /// Resumes execution of this thread.
     ///
-    /// Equivalent to `coroutine.resume`.
+    /// Equivalent to [`coroutine.resume`].
     ///
-    /// Passes `args` as arguments to the thread. If the coroutine has called `coroutine.yield`, it
-    /// will return these arguments. Otherwise, the coroutine wasn't yet started, so the arguments
-    /// are passed to its main function.
+    /// Passes `args` as arguments to the thread. If the coroutine has called [`coroutine.yield`],
+    /// it will return these arguments. Otherwise, the coroutine wasn't yet started, so the
+    /// arguments are passed to its main function.
     ///
-    /// If the thread is no longer in `Active` state (meaning it has finished execution or
-    /// encountered an error), this will return `Err(CoroutineInactive)`, otherwise will return `Ok`
-    /// as follows:
+    /// If the thread is no longer resumable (meaning it has finished execution or encountered an
+    /// error), this will return [`Error::CoroutineUnresumable`], otherwise will return `Ok` as
+    /// follows:
     ///
-    /// If the thread calls `coroutine.yield`, returns the values passed to `yield`. If the thread
+    /// If the thread calls [`coroutine.yield`], returns the values passed to `yield`. If the thread
     /// `return`s values from its main function, returns those.
     ///
     /// # Examples
@@ -95,78 +128,167 @@ impl<'lua> Thread<'lua> {
     ///     end)
     /// "#).eval()?;
     ///
-    /// assert_eq!(thread.resume::<_, u32>(42)?, 123);
-    /// assert_eq!(thread.resume::<_, u32>(43)?, 987);
+    /// assert_eq!(thread.resume::<u32>(42)?, 123);
+    /// assert_eq!(thread.resume::<u32>(43)?, 987);
     ///
     /// // The coroutine has now returned, so `resume` will fail
-    /// match thread.resume::<_, u32>(()) {
-    ///     Err(Error::CoroutineInactive) => {},
+    /// match thread.resume::<u32>(()) {
+    ///     Err(Error::CoroutineUnresumable) => {},
     ///     unexpected => panic!("unexpected result {:?}", unexpected),
     /// }
     /// # Ok(())
     /// # }
     /// ```
-    pub fn resume<A, R>(&self, args: A) -> Result<R>
+    ///
+    /// [`coroutine.resume`]: https://www.lua.org/manual/5.4/manual.html#pdf-coroutine.resume
+    /// [`coroutine.yield`]: https://www.lua.org/manual/5.4/manual.html#pdf-coroutine.yield
+    pub fn resume<R>(&self, args: impl IntoLuaMulti) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
+        R: FromLuaMulti,
     {
-        let lua = self.0.lua;
-        let mut args = args.to_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 thread_state =
-                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));
-
-            let status = ffi::lua_status(thread_state);
-            if status != ffi::LUA_YIELD && ffi::lua_gettop(thread_state) == 0 {
-                return Err(Error::CoroutineInactive);
-            }
-
-            check_stack(thread_state, nargs)?;
-            for arg in args.drain_all() {
-                lua.push_value(arg)?;
-            }
-            ffi::lua_xmove(lua.state, thread_state, nargs);
-
-            let mut nresults = 0;
-
-            let ret = ffi::lua_resume(thread_state, lua.state, nargs, &mut nresults as *mut c_int);
-            if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
-                protect_lua!(lua.state, 0, 0, |_| error_traceback(thread_state))?;
-                return Err(pop_error(thread_state, ret));
-            }
-
-            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);
-
-            for _ in 0..nresults {
-                results.push_front(lua.pop_value());
-            }
-            results
+        let lua = self.0.lua.lock();
+        let mut pushed_nargs = match self.status_inner(&lua) {
+            ThreadStatusInner::New(nargs) | ThreadStatusInner::Yielded(nargs) => nargs,
+            _ => return Err(Error::CoroutineUnresumable),
         };
-        R::from_lua_multi(results, lua)
+
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+
+            let nargs = args.push_into_stack_multi(&lua)?;
+            if nargs > 0 {
+                check_stack(thread_state, nargs)?;
+                ffi::lua_xmove(state, thread_state, nargs);
+                pushed_nargs += nargs;
+            }
+
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let (_, nresults) = self.resume_inner(&lua, pushed_nargs)?;
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            R::from_stack_multi(nresults, &lua)
+        }
+    }
+
+    /// Resumes execution of this thread, immediately raising an error.
+    ///
+    /// This is a Luau specific extension.
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn resume_error<R>(&self, error: impl crate::IntoLua) -> Result<R>
+    where
+        R: FromLuaMulti,
+    {
+        let lua = self.0.lua.lock();
+        match self.status_inner(&lua) {
+            ThreadStatusInner::New(_) | ThreadStatusInner::Yielded(_) => {}
+            _ => return Err(Error::CoroutineUnresumable),
+        };
+
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+
+            check_stack(state, 1)?;
+            error.push_into_stack(&lua)?;
+            ffi::lua_xmove(state, thread_state, 1);
+
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let (_, nresults) = self.resume_inner(&lua, ffi::LUA_RESUMEERROR)?;
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            R::from_stack_multi(nresults, &lua)
+        }
+    }
+
+    /// Resumes execution of this thread.
+    ///
+    /// It's similar to `resume()` but leaves `nresults` values on the thread stack.
+    unsafe fn resume_inner(&self, lua: &RawLua, nargs: c_int) -> Result<(ThreadStatusInner, c_int)> {
+        let state = lua.state();
+        let thread_state = self.state();
+        let mut nresults = 0;
+        #[cfg(not(feature = "luau"))]
+        let ret = ffi::lua_resume(thread_state, state, nargs, &mut nresults as *mut c_int);
+        #[cfg(feature = "luau")]
+        let ret = ffi::lua_resumex(thread_state, state, nargs, &mut nresults as *mut c_int);
+        match ret {
+            ffi::LUA_OK => Ok((ThreadStatusInner::Finished, nresults)),
+            ffi::LUA_YIELD => Ok((ThreadStatusInner::Yielded(0), nresults)),
+            ffi::LUA_ERRMEM => {
+                // Don't call error handler for memory errors
+                Err(pop_error(thread_state, ret))
+            }
+            _ => {
+                check_stack(state, 3)?;
+                protect_lua!(state, 0, 1, |state| error_traceback_thread(state, thread_state))?;
+                Err(pop_error(state, ret))
+            }
+        }
     }
 
     /// Gets the status of the thread.
     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));
+        match self.status_inner(&self.0.lua.lock()) {
+            ThreadStatusInner::New(_) | ThreadStatusInner::Yielded(_) => ThreadStatus::Resumable,
+            ThreadStatusInner::Running => ThreadStatus::Running,
+            ThreadStatusInner::Finished => ThreadStatus::Finished,
+            ThreadStatusInner::Error => ThreadStatus::Error,
+        }
+    }
 
-            let status = ffi::lua_status(thread_state);
-            if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
-                ThreadStatus::Error
-            } else if status == ffi::LUA_YIELD || ffi::lua_gettop(thread_state) > 0 {
-                ThreadStatus::Resumable
-            } else {
-                ThreadStatus::Unresumable
-            }
+    /// Gets the status of the thread (internal implementation).
+    fn status_inner(&self, lua: &RawLua) -> ThreadStatusInner {
+        let thread_state = self.state();
+        if thread_state == lua.state() {
+            // The thread is currently running
+            return ThreadStatusInner::Running;
+        }
+        let status = unsafe { ffi::lua_status(thread_state) };
+        let top = unsafe { ffi::lua_gettop(thread_state) };
+        match status {
+            ffi::LUA_YIELD => ThreadStatusInner::Yielded(top),
+            ffi::LUA_OK if top > 0 => ThreadStatusInner::New(top - 1),
+            ffi::LUA_OK => ThreadStatusInner::Finished,
+            _ => ThreadStatusInner::Error,
+        }
+    }
+
+    /// Sets a hook function that will periodically be called as Lua code executes.
+    ///
+    /// This function is similar or [`Lua::set_hook`] except that it sets for the thread.
+    /// You can have multiple hooks for different threads.
+    ///
+    /// To remove a hook call [`Thread::remove_hook`].
+    ///
+    /// [`Lua::set_hook`]: crate::Lua::set_hook
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
+    where
+        F: Fn(&crate::Lua, &Debug) -> Result<crate::VmState> + crate::MaybeSend + 'static,
+    {
+        let lua = self.0.lua.lock();
+        unsafe {
+            lua.set_thread_hook(
+                self.state(),
+                HookKind::Thread(triggers, crate::types::XRc::new(callback)),
+            )
+        }
+    }
+
+    /// Removes any hook function from this thread.
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn remove_hook(&self) {
+        let _lua = self.0.lua.lock();
+        unsafe {
+            ffi::lua_sethook(self.state(), None, 0, 0);
         }
     }
 
@@ -176,47 +298,28 @@ impl<'lua> Thread<'lua> {
     /// Returns a error in case of either the original error that stopped the thread or errors
     /// in closing methods.
     ///
-    /// In [LuaJIT] and Luau: resets to the initial state of a newly created Lua thread.
+    /// In Luau: resets to the initial state of a newly created Lua thread.
     /// Lua threads in arbitrary states (like yielded or errored) can be reset properly.
     ///
+    /// Other Lua versions can reset only new or finished threads.
+    ///
     /// Sets a Lua function for the thread afterwards.
     ///
-    /// Requires `feature = "lua54"` OR `feature = "luajit,vendored"` OR `feature = "luau"`
-    ///
-    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_resetthread
-    /// [LuaJIT]: https://github.com/openresty/luajit2#lua_resetthread
-    #[cfg(any(
-        feature = "lua54",
-        all(feature = "luajit", feature = "vendored"),
-        feature = "luau",
-    ))]
-    pub fn reset(&self, func: Function<'lua>) -> Result<()> {
-        let lua = self.0.lua;
+    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_closethread
+    pub fn reset(&self, func: Function) -> Result<()> {
+        let lua = self.0.lua.lock();
+        let thread_state = self.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 2)?;
+            let status = self.status_inner(&lua);
+            self.reset_inner(status)?;
 
-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-
-            #[cfg(feature = "lua54")]
-            let status = ffi::lua_resetthread(thread_state);
-            #[cfg(feature = "lua54")]
-            if status != ffi::LUA_OK {
-                return Err(pop_error(thread_state, status));
-            }
-            #[cfg(all(feature = "luajit", feature = "vendored"))]
-            ffi::lua_resetthread(lua.state, thread_state);
-            #[cfg(feature = "luau")]
-            ffi::lua_resetthread(thread_state);
-
-            lua.push_ref(&func.0);
-            ffi::lua_xmove(lua.state, thread_state, 1);
+            // Push function to the top of the thread stack
+            ffi::lua_xpush(lua.ref_thread(), thread_state, func.0.index);
 
             #[cfg(feature = "luau")]
             {
-                // Inherit `LUA_GLOBALSINDEX` from the caller
-                ffi::lua_xpush(lua.state, thread_state, ffi::LUA_GLOBALSINDEX);
+                // Inherit `LUA_GLOBALSINDEX` from the main thread
+                ffi::lua_xpush(lua.main_state(), thread_state, ffi::LUA_GLOBALSINDEX);
                 ffi::lua_replace(thread_state, ffi::LUA_GLOBALSINDEX);
             }
 
@@ -224,27 +327,64 @@ impl<'lua> Thread<'lua> {
         }
     }
 
-    /// Converts Thread to an AsyncThread which implements [`Future`] and [`Stream`] traits.
+    unsafe fn reset_inner(&self, status: ThreadStatusInner) -> Result<()> {
+        match status {
+            ThreadStatusInner::New(_) => {
+                // The thread is new, so we can just set the top to 0
+                ffi::lua_settop(self.state(), 0);
+                Ok(())
+            }
+            ThreadStatusInner::Running => Err(Error::runtime("cannot reset a running thread")),
+            ThreadStatusInner::Finished => Ok(()),
+            #[cfg(not(any(feature = "lua54", feature = "luau")))]
+            ThreadStatusInner::Yielded(_) | ThreadStatusInner::Error => {
+                Err(Error::runtime("cannot reset non-finished thread"))
+            }
+            #[cfg(any(feature = "lua54", feature = "luau"))]
+            ThreadStatusInner::Yielded(_) | ThreadStatusInner::Error => {
+                let thread_state = self.state();
+
+                #[cfg(all(feature = "lua54", not(feature = "vendored")))]
+                let status = ffi::lua_resetthread(thread_state);
+                #[cfg(all(feature = "lua54", feature = "vendored"))]
+                let status = {
+                    let lua = self.0.lua.lock();
+                    ffi::lua_closethread(thread_state, lua.state())
+                };
+                #[cfg(feature = "lua54")]
+                if status != ffi::LUA_OK {
+                    return Err(pop_error(thread_state, status));
+                }
+                #[cfg(feature = "luau")]
+                ffi::lua_resetthread(thread_state);
+
+                Ok(())
+            }
+        }
+    }
+
+    /// Converts [`Thread`] to an [`AsyncThread`] which implements [`Future`] and [`Stream`] traits.
     ///
-    /// `args` are passed as arguments to the thread function for first call.
-    /// The object calls [`resume()`] while polling and also allows to run rust futures
+    /// Only resumable threads can be converted to [`AsyncThread`].
+    ///
+    /// `args` are pushed to the thread stack and will be used when the thread is resumed.
+    /// The object calls [`resume`] while polling and also allow to run Rust futures
     /// to completion using an executor.
     ///
-    /// Using AsyncThread as a Stream allows to iterate through `coroutine.yield()`
-    /// values whereas Future version discards that values and poll until the final
+    /// Using [`AsyncThread`] as a [`Stream`] allow to iterate through [`coroutine.yield`]
+    /// values whereas [`Future`] version discards that values and poll until the final
     /// one (returned from the thread function).
     ///
-    /// Requires `feature = "async"`
-    ///
-    /// [`Future`]: futures_core::future::Future
-    /// [`Stream`]: futures_core::stream::Stream
-    /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    /// [`Future`]: std::future::Future
+    /// [`Stream`]: futures_util::stream::Stream
+    /// [`resume`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    /// [`coroutine.yield`]: https://www.lua.org/manual/5.4/manual.html#pdf-coroutine.yield
     ///
     /// # Examples
     ///
     /// ```
     /// # use mlua::{Lua, Result, Thread};
-    /// use futures::stream::TryStreamExt;
+    /// use futures_util::stream::TryStreamExt;
     /// # #[tokio::main]
     /// # async fn main() -> Result<()> {
     /// # let lua = Lua::new();
@@ -258,7 +398,7 @@ impl<'lua> Thread<'lua> {
     ///     end)
     /// "#).eval()?;
     ///
-    /// let mut stream = thread.into_async::<_, i64>(1);
+    /// let mut stream = thread.into_async::<i64>(1)?;
     /// let mut sum = 0;
     /// while let Some(n) = stream.try_next().await? {
     ///     sum += n;
@@ -271,17 +411,31 @@ impl<'lua> Thread<'lua> {
     /// ```
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R>
+    pub fn into_async<R>(self, args: impl IntoLuaMulti) -> Result<AsyncThread<R>>
     where
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
+        R: FromLuaMulti,
     {
-        let args = args.to_lua_multi(self.0.lua);
-        AsyncThread {
-            thread: self,
-            args0: RefCell::new(Some(args)),
-            ret: PhantomData,
-            recycle: false,
+        let lua = self.0.lua.lock();
+        if !self.status_inner(&lua).is_resumable() {
+            return Err(Error::CoroutineUnresumable);
+        }
+
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+
+            let nargs = args.push_into_stack_multi(&lua)?;
+            if nargs > 0 {
+                check_stack(thread_state, nargs)?;
+                ffi::lua_xmove(state, thread_state, nargs);
+            }
+
+            Ok(AsyncThread {
+                thread: self,
+                ret: PhantomData,
+                recycle: false,
+            })
         }
     }
 
@@ -290,7 +444,7 @@ impl<'lua> Thread<'lua> {
     /// Under the hood replaces the global environment table with a new table,
     /// that performs writes locally and proxies reads to caller's global environment.
     ///
-    /// This mode ideally should be used together with the global sandbox mode [`Lua::sandbox()`].
+    /// This mode ideally should be used together with the global sandbox mode [`Lua::sandbox`].
     ///
     /// Please note that Luau links environment table with chunk when loading it into Lua state.
     /// Therefore you need to load chunks into a thread to link with the thread environment.
@@ -299,170 +453,214 @@ impl<'lua> Thread<'lua> {
     ///
     /// ```
     /// # use mlua::{Lua, Result};
+    /// # #[cfg(feature = "luau")]
     /// # fn main() -> Result<()> {
     /// let lua = Lua::new();
     /// let thread = lua.create_thread(lua.create_function(|lua2, ()| {
     ///     lua2.load("var = 123").exec()?;
-    ///     assert_eq!(lua2.globals().get::<_, u32>("var")?, 123);
+    ///     assert_eq!(lua2.globals().get::<u32>("var")?, 123);
     ///     Ok(())
     /// })?)?;
     /// thread.sandbox()?;
-    /// thread.resume(())?;
+    /// thread.resume::<()>(())?;
     ///
     /// // The global environment should be unchanged
-    /// assert_eq!(lua.globals().get::<_, Option<u32>>("var")?, None);
+    /// assert_eq!(lua.globals().get::<Option<u32>>("var")?, None);
     /// # Ok(())
     /// # }
-    /// ```
     ///
-    /// Requires `feature = "luau"`
-    #[cfg(any(feature = "luau", docsrs))]
+    /// # #[cfg(not(feature = "luau"))]
+    /// # fn main() { }
+    /// ```
+    #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
-    #[doc(hidden)]
     pub fn sandbox(&self) -> Result<()> {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        let thread_state = self.state();
         unsafe {
-            let thread = lua.ref_thread_exec(|t| ffi::lua_tothread(t, self.0.index));
-            check_stack(thread, 1)?;
-            check_stack(lua.state, 3)?;
-            // Inherit `LUA_GLOBALSINDEX` from the caller
-            ffi::lua_xpush(lua.state, thread, ffi::LUA_GLOBALSINDEX);
-            ffi::lua_replace(thread, ffi::LUA_GLOBALSINDEX);
-            protect_lua!(lua.state, 0, 0, |_| ffi::luaL_sandboxthread(thread))
+            check_stack(thread_state, 3)?;
+            check_stack(state, 3)?;
+            protect_lua!(state, 0, 0, |_| ffi::luaL_sandboxthread(thread_state))
         }
     }
+
+    /// Converts this thread to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
 }
 
-impl<'lua> PartialEq for Thread<'lua> {
+impl fmt::Debug for Thread {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_tuple("Thread").field(&self.0).finish()
+    }
+}
+
+impl PartialEq for Thread {
     fn eq(&self, other: &Self) -> bool {
         self.0 == other.0
     }
 }
 
+impl LuaType for Thread {
+    const TYPE_ID: c_int = ffi::LUA_TTHREAD;
+}
+
 #[cfg(feature = "async")]
-impl<'lua, R> AsyncThread<'lua, R> {
-    #[inline]
+impl<R> AsyncThread<R> {
+    #[inline(always)]
     pub(crate) fn set_recyclable(&mut self, recyclable: bool) {
         self.recycle = recyclable;
     }
 }
 
 #[cfg(feature = "async")]
-#[cfg(any(
-    feature = "lua54",
-    all(feature = "luajit", feature = "vendored"),
-    feature = "luau",
-))]
-impl<'lua, R> Drop for AsyncThread<'lua, R> {
+impl<R> Drop for AsyncThread<R> {
     fn drop(&mut self) {
         if self.recycle {
-            unsafe {
-                self.thread.0.lua.recycle_thread(&mut self.thread);
+            if let Some(lua) = self.thread.0.lua.try_lock() {
+                unsafe {
+                    let mut status = self.thread.status_inner(&lua);
+                    if matches!(status, ThreadStatusInner::Yielded(0)) {
+                        // The thread is dropped while yielded, resume it with the "terminate" signal
+                        ffi::lua_pushlightuserdata(self.thread.1, crate::Lua::poll_terminate().0);
+                        if let Ok((new_status, _)) = self.thread.resume_inner(&lua, 1) {
+                            // `new_status` should always be `ThreadStatusInner::Yielded(0)`
+                            status = new_status;
+                        }
+                    }
+
+                    // For Lua 5.4 this also closes all pending to-be-closed variables
+                    if self.thread.reset_inner(status).is_ok() {
+                        lua.recycle_thread(&mut self.thread);
+                    }
+                }
             }
         }
     }
 }
 
 #[cfg(feature = "async")]
-impl<'lua, R> Stream for AsyncThread<'lua, R>
-where
-    R: FromLuaMulti<'lua>,
-{
+impl<R: FromLuaMulti> Stream for AsyncThread<R> {
     type Item = Result<R>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let lua = self.thread.0.lua;
-
-        match self.thread.status() {
-            ThreadStatus::Resumable => {}
+        let lua = self.thread.0.lua.lock();
+        let nargs = match self.thread.status_inner(&lua) {
+            ThreadStatusInner::New(nargs) | ThreadStatusInner::Yielded(nargs) => nargs,
             _ => 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?)?
-        } else {
-            self.thread.resume(())?
-        };
+        let state = lua.state();
+        let thread_state = self.thread.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let _wg = WakerGuard::new(&lua, cx.waker());
 
-        if is_poll_pending(&ret) {
-            return Poll::Pending;
+            let (status, nresults) = (self.thread).resume_inner(&lua, nargs)?;
+
+            if status.is_yielded() {
+                if nresults == 1 && is_poll_pending(thread_state) {
+                    return Poll::Pending;
+                }
+                // Continue polling
+                cx.waker().wake_by_ref();
+            }
+
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            Poll::Ready(Some(R::from_stack_multi(nresults, &lua)))
         }
-
-        cx.waker().wake_by_ref();
-        Poll::Ready(Some(R::from_lua_multi(ret, lua)))
     }
 }
 
 #[cfg(feature = "async")]
-impl<'lua, R> Future for AsyncThread<'lua, R>
-where
-    R: FromLuaMulti<'lua>,
-{
+impl<R: FromLuaMulti> Future for AsyncThread<R> {
     type Output = Result<R>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let lua = self.thread.0.lua;
-
-        match self.thread.status() {
-            ThreadStatus::Resumable => {}
-            _ => return Poll::Ready(Err(Error::CoroutineInactive)),
+        let lua = self.thread.0.lua.lock();
+        let nargs = match self.thread.status_inner(&lua) {
+            ThreadStatusInner::New(nargs) | ThreadStatusInner::Yielded(nargs) => nargs,
+            _ => return Poll::Ready(Err(Error::CoroutineUnresumable)),
         };
 
-        let _wg = WakerGuard::new(lua, cx.waker().clone());
-        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
-            self.thread.resume(args?)?
-        } else {
-            self.thread.resume(())?
-        };
+        let state = lua.state();
+        let thread_state = self.thread.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let _wg = WakerGuard::new(&lua, cx.waker());
 
-        if is_poll_pending(&ret) {
-            return Poll::Pending;
+            let (status, nresults) = self.thread.resume_inner(&lua, nargs)?;
+
+            if status.is_yielded() {
+                if !(nresults == 1 && is_poll_pending(thread_state)) {
+                    // Ignore values returned via yield()
+                    cx.waker().wake_by_ref();
+                }
+                return Poll::Pending;
+            }
+
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            Poll::Ready(R::from_stack_multi(nresults, &lua))
         }
-
-        if let ThreadStatus::Resumable = self.thread.status() {
-            // Ignore value returned via yield()
-            cx.waker().wake_by_ref();
-            return Poll::Pending;
-        }
-
-        Poll::Ready(R::from_lua_multi(ret, lua))
     }
 }
 
 #[cfg(feature = "async")]
 #[inline(always)]
-fn is_poll_pending(val: &MultiValue) -> bool {
-    match val.iter().enumerate().last() {
-        Some((0, Value::LightUserData(ud))) => {
-            std::ptr::eq(ud.0 as *const u8, &ASYNC_POLL_PENDING as *const u8)
-        }
-        _ => false,
-    }
+unsafe fn is_poll_pending(state: *mut ffi::lua_State) -> bool {
+    ffi::lua_tolightuserdata(state, -1) == crate::Lua::poll_pending().0
 }
 
 #[cfg(feature = "async")]
-struct WakerGuard<'lua> {
-    lua: &'lua Lua,
-    prev: Option<Waker>,
+struct WakerGuard<'lua, 'a> {
+    lua: &'lua RawLua,
+    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> {
-        unsafe {
-            let prev = lua.set_waker(Some(waker));
-            Ok(WakerGuard { lua, prev })
-        }
+    pub fn new(lua: &'lua RawLua, waker: &'a Waker) -> Result<WakerGuard<'lua, 'a>> {
+        let prev = lua.set_waker(NonNull::from(waker));
+        Ok(WakerGuard {
+            lua,
+            prev,
+            _phantom: PhantomData,
+        })
     }
 }
 
 #[cfg(feature = "async")]
-impl<'lua> Drop for WakerGuard<'lua> {
+impl Drop for WakerGuard<'_, '_> {
     fn drop(&mut self) {
-        unsafe {
-            self.lua.set_waker(self.prev.take());
-        }
+        self.lua.set_waker(self.prev);
     }
 }
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(Thread: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Thread: Send, Sync);
+    #[cfg(all(feature = "async", not(feature = "send")))]
+    static_assertions::assert_not_impl_any!(AsyncThread<()>: Send);
+    #[cfg(all(feature = "async", feature = "send"))]
+    static_assertions::assert_impl_all!(AsyncThread<()>: Send, Sync);
+}

src/traits.rs

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

src/types.rs

@@ -1,22 +1,27 @@
 use std::cell::UnsafeCell;
-use std::hash::{Hash, Hasher};
 use std::os::raw::{c_int, c_void};
-use std::sync::{Arc, Mutex};
-use std::{fmt, mem, ptr};
 
-#[cfg(feature = "lua54")]
-use std::ffi::CStr;
+#[cfg(not(feature = "luau"))]
+use crate::debug::{Debug, HookTriggers};
+use crate::error::Result;
+use crate::state::{ExtraData, Lua, RawLua};
+
+// Re-export mutex wrappers
+pub(crate) use sync::{ArcReentrantMutexGuard, ReentrantMutex, ReentrantMutexGuard, XRc, XWeak};
+
+#[cfg(all(feature = "async", feature = "send"))]
+pub(crate) type BoxFuture<'a, T> = futures_util::future::BoxFuture<'a, T>;
+
+#[cfg(all(feature = "async", not(feature = "send")))]
+pub(crate) type BoxFuture<'a, T> = futures_util::future::LocalBoxFuture<'a, T>;
+
+pub use app_data::{AppData, AppDataRef, AppDataRefMut};
+pub use either::Either;
+pub use registry_key::RegistryKey;
+pub(crate) use value_ref::ValueRef;
 
 #[cfg(feature = "async")]
-use futures_core::future::LocalBoxFuture;
-
-use crate::error::Result;
-use crate::ffi;
-#[cfg(not(feature = "luau"))]
-use crate::hook::Debug;
-use crate::lua::{ExtraData, Lua};
-use crate::util::{assert_stack, StackGuard};
-use crate::value::MultiValue;
+pub(crate) use value_ref::ValueRefIndex;
 
 /// Type of Lua integer numbers.
 pub type Integer = ffi::lua_Integer;
@@ -27,52 +32,89 @@ pub type Number = ffi::lua_Number;
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub struct LightUserData(pub *mut c_void);
 
-pub(crate) type Callback<'lua, 'a> =
-    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> Result<MultiValue<'lua>> + 'a>;
+#[cfg(feature = "send")]
+unsafe impl Send for LightUserData {}
+#[cfg(feature = "send")]
+unsafe impl Sync for LightUserData {}
+
+#[cfg(feature = "send")]
+type CallbackFn<'a> = dyn Fn(&RawLua, c_int) -> Result<c_int> + Send + 'a;
+
+#[cfg(not(feature = "send"))]
+type CallbackFn<'a> = dyn Fn(&RawLua, c_int) -> Result<c_int> + 'a;
+
+pub(crate) type Callback = Box<CallbackFn<'static>>;
+pub(crate) type CallbackPtr = *const CallbackFn<'static>;
+
+pub(crate) type ScopedCallback<'s> = Box<dyn Fn(&RawLua, c_int) -> Result<c_int> + 's>;
 
 pub(crate) struct Upvalue<T> {
     pub(crate) data: T,
-    pub(crate) extra: Arc<UnsafeCell<ExtraData>>,
+    pub(crate) extra: XRc<UnsafeCell<ExtraData>>,
 }
 
-pub(crate) type CallbackUpvalue = Upvalue<Callback<'static, 'static>>;
+pub(crate) type CallbackUpvalue = Upvalue<Option<Callback>>;
+
+#[cfg(all(feature = "async", feature = "send"))]
+pub(crate) type AsyncCallback =
+    Box<dyn for<'a> Fn(&'a RawLua, c_int) -> BoxFuture<'a, Result<c_int>> + Send + 'static>;
+
+#[cfg(all(feature = "async", not(feature = "send")))]
+pub(crate) type AsyncCallback =
+    Box<dyn for<'a> Fn(&'a RawLua, c_int) -> BoxFuture<'a, Result<c_int>> + 'static>;
 
 #[cfg(feature = "async")]
-pub(crate) type AsyncCallback<'lua, 'a> =
-    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> LocalBoxFuture<'lua, Result<MultiValue<'lua>>> + 'a>;
+pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback>;
 
 #[cfg(feature = "async")]
-pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback<'static, 'static>>;
+pub(crate) type AsyncPollUpvalue = Upvalue<Option<BoxFuture<'static, Result<c_int>>>>;
 
-#[cfg(feature = "async")]
-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")))]
+/// Type to set next Lua VM action after executing interrupt or hook function.
 pub enum VmState {
     Continue,
+    /// Yield the current thread.
+    ///
+    /// Supported by Lua 5.3+ and Luau.
     Yield,
 }
 
+#[cfg(not(feature = "luau"))]
+pub(crate) enum HookKind {
+    Global,
+    Thread(HookTriggers, HookCallback),
+}
+
 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()> + Send>;
+pub(crate) type HookCallback = XRc<dyn Fn(&Lua, &Debug) -> Result<VmState> + Send>;
 
 #[cfg(all(not(feature = "send"), not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()>>;
+pub(crate) type HookCallback = XRc<dyn Fn(&Lua, &Debug) -> Result<VmState>>;
 
-#[cfg(all(feature = "luau", feature = "send"))]
-pub(crate) type InterruptCallback = Arc<dyn Fn() -> Result<VmState> + Send>;
+#[cfg(all(feature = "send", feature = "luau"))]
+pub(crate) type InterruptCallback = XRc<dyn Fn(&Lua) -> Result<VmState> + Send>;
 
-#[cfg(all(feature = "luau", not(feature = "send")))]
-pub(crate) type InterruptCallback = Arc<dyn Fn() -> Result<VmState>>;
+#[cfg(all(not(feature = "send"), feature = "luau"))]
+pub(crate) type InterruptCallback = XRc<dyn Fn(&Lua) -> Result<VmState>>;
+
+#[cfg(all(feature = "send", feature = "luau"))]
+pub(crate) type ThreadCreationCallback = XRc<dyn Fn(&Lua, crate::Thread) -> Result<()> + Send>;
+
+#[cfg(all(not(feature = "send"), feature = "luau"))]
+pub(crate) type ThreadCreationCallback = XRc<dyn Fn(&Lua, crate::Thread) -> Result<()>>;
+
+#[cfg(all(feature = "send", feature = "luau"))]
+pub(crate) type ThreadCollectionCallback = XRc<dyn Fn(crate::LightUserData) + Send>;
+
+#[cfg(all(not(feature = "send"), feature = "luau"))]
+pub(crate) type ThreadCollectionCallback = XRc<dyn Fn(crate::LightUserData)>;
 
 #[cfg(all(feature = "send", feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()> + Send>;
+pub(crate) type WarnCallback = XRc<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;
 
 #[cfg(all(not(feature = "send"), feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()>>;
+pub(crate) type WarnCallback = XRc<dyn Fn(&Lua, &str, bool) -> Result<()>>;
 
+/// A trait that adds `Send` requirement if `send` feature is enabled.
 #[cfg(feature = "send")]
 pub trait MaybeSend: Send {}
 #[cfg(feature = "send")]
@@ -83,105 +125,35 @@ 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.
-///
-/// This is a handle to a value stored inside the Lua registry. It is not automatically
-/// garbage collected on Drop, but it can be removed with [`Lua::remove_registry_value`],
-/// and instances not manually removed can be garbage collected with [`Lua::expire_registry_values`].
-///
-/// Be warned, If you place this into Lua via a [`UserData`] type or a rust callback, it is *very
-/// easy* to accidentally cause reference cycles that the Lua garbage collector cannot resolve.
-/// Instead of placing a [`RegistryKey`] into a [`UserData`] type, prefer instead to use
-/// [`AnyUserData::set_user_value`] / [`AnyUserData::get_user_value`].
-///
-/// [`UserData`]: crate::UserData
-/// [`RegistryKey`]: crate::RegistryKey
-/// [`Lua::remove_registry_value`]: crate::Lua::remove_registry_value
-/// [`Lua::expire_registry_values`]: crate::Lua::expire_registry_values
-/// [`AnyUserData::set_user_value`]: crate::AnyUserData::set_user_value
-/// [`AnyUserData::get_user_value`]: crate::AnyUserData::get_user_value
-pub struct RegistryKey {
-    pub(crate) registry_id: c_int,
-    pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
+pub(crate) trait LuaType {
+    const TYPE_ID: c_int;
 }
 
-impl fmt::Debug for RegistryKey {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "RegistryKey({})", self.registry_id)
-    }
+impl LuaType for bool {
+    const TYPE_ID: c_int = ffi::LUA_TBOOLEAN;
 }
 
-impl Hash for RegistryKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.registry_id.hash(state)
-    }
+impl LuaType for Number {
+    const TYPE_ID: c_int = ffi::LUA_TNUMBER;
 }
 
-impl PartialEq for RegistryKey {
-    fn eq(&self, other: &RegistryKey) -> bool {
-        self.registry_id == other.registry_id && Arc::ptr_eq(&self.unref_list, &other.unref_list)
-    }
+impl LuaType for LightUserData {
+    const TYPE_ID: c_int = ffi::LUA_TLIGHTUSERDATA;
 }
 
-impl Eq for RegistryKey {}
+mod app_data;
+mod registry_key;
+mod sync;
+mod value_ref;
 
-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);
-        }
-    }
-}
+#[cfg(test)]
+mod assertions {
+    use super::*;
 
-impl RegistryKey {
-    // Destroys the RegistryKey without adding to the drop list
-    pub(crate) fn take(self) -> c_int {
-        let registry_id = self.registry_id;
-        unsafe {
-            ptr::read(&self.unref_list);
-            mem::forget(self);
-        }
-        registry_id
-    }
-}
-
-pub(crate) struct LuaRef<'lua> {
-    pub(crate) lua: &'lua Lua,
-    pub(crate) index: c_int,
-}
-
-impl<'lua> fmt::Debug for LuaRef<'lua> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Ref({})", self.index)
-    }
-}
-
-impl<'lua> Clone for LuaRef<'lua> {
-    fn clone(&self) -> Self {
-        self.lua.clone_ref(self)
-    }
-}
-
-impl<'lua> Drop for LuaRef<'lua> {
-    fn drop(&mut self) {
-        if self.index > 0 {
-            self.lua.drop_ref(self);
-        }
-    }
-}
-
-impl<'lua> PartialEq for LuaRef<'lua> {
-    fn eq(&self, other: &Self) -> bool {
-        let lua = self.lua;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 2);
-            lua.push_ref(self);
-            lua.push_ref(other);
-            ffi::lua_rawequal(lua.state, -1, -2) == 1
-        }
-    }
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(ValueRef: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(ValueRef: Send, Sync);
 }

src/types/app_data.rs

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