v0.9.5

This would prevent cloning plus has better performance when pushing values to Lua stack (`IntoLua::push_into_stack` method)

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: khvzak

.github/workflows/coverage.yml

@@ -10,14 +10,14 @@ jobs:
       options: --security-opt seccomp=unconfined
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
-      - name: Generate code coverage
+      - name: Generate coverage report
         run: |
-          cargo tarpaulin --verbose --features lua53,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 tarpaulin --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@v3
         with:
           token: ${{secrets.CODECOV_TOKEN}}
           fail_ci_if_error: false

.github/workflows/main.yml

@@ -7,97 +7,94 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [ubuntu-22.04, macos-latest, windows-latest]
         rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
         include:
-        - os: ubuntu-18.04
-          target: x86_64-unknown-linux-gnu
-        - os: macos-latest
-          target: x86_64-apple-darwin
-        - os: windows-latest
-          target: x86_64-pc-windows-msvc
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        target: ${{ matrix.target }}
-        override: true
-    - name: Build ${{ matrix.lua }} vendored
-      run: |
-        cargo build --release --features "${{ matrix.lua }},vendored"
-        cargo build --release --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
-      shell: bash
-    - name: Build ${{ matrix.lua }} pkg-config
-      if: ${{ matrix.os == 'ubuntu-18.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 --release --features "${{ matrix.lua }}"
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Build ${{ matrix.lua }} vendored
+        run: |
+          cargo build --features "${{ matrix.lua }},vendored"
+          cargo build --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+        shell: bash
+      - name: Build ${{ matrix.lua }} pkg-config
+        if: ${{ matrix.os == 'ubuntu-22.04' }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends liblua5.4-dev liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
+          cargo build --features "${{ matrix.lua }}"
 
   build_aarch64_cross_macos:
     name: Cross-compile to aarch64-apple-darwin
-    runs-on: macos-11.0
+    runs-on: macos-latest
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: nightly
-        target: aarch64-apple-darwin
-        override: true
-    - name: Cross-compile
-      run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: aarch64-apple-darwin
+      - name: Cross-compile
+        run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
 
   build_aarch64_cross_ubuntu:
     name: Cross-compile to aarch64-unknown-linux-gnu
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51, luajit]
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: nightly
-        target: aarch64-unknown-linux-gnu
-        override: true
-    - name: Install ARM compiler toolchain
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu libc6-dev-arm64-cross
-      shell: bash
-    - name: Cross-compile
-      run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
-      shell: bash
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: aarch64-unknown-linux-gnu
+      - name: Install ARM compiler toolchain
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu libc6-dev-arm64-cross
+        shell: bash
+      - name: Cross-compile
+        run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+        shell: bash
 
   build_armv7_cross_ubuntu:
     name: Cross-compile to armv7-unknown-linux-gnueabihf
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     needs: build
     strategy:
       matrix:
         lua: [lua54, lua53, lua52, lua51]
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: nightly
-        target: armv7-unknown-linux-gnueabihf
-        override: true
-    - name: Install ARM compiler toolchain
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y --no-install-recommends gcc-arm-linux-gnueabihf libc-dev-armhf-cross
-      shell: bash
-    - name: Cross-compile
-      run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
-      shell: bash
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: armv7-unknown-linux-gnueabihf
+      - name: Install ARM compiler toolchain
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends gcc-arm-linux-gnueabihf libc-dev-armhf-cross
+        shell: bash
+      - name: Cross-compile
+        run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"
+        shell: bash
 
   test:
     name: Test
@@ -105,34 +102,61 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [ubuntu-22.04, macos-latest, windows-latest]
         rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau, luau-jit, luau-vector4]
         include:
-        - os: ubuntu-18.04
-          target: x86_64-unknown-linux-gnu
-        - os: macos-latest
-          target: x86_64-apple-darwin
-        - os: windows-latest
-          target: x86_64-pc-windows-msvc
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        target: ${{ matrix.target }}
-        override: true
-    - name: Run ${{ matrix.lua }} tests
-      run: |
-        cargo test --release --features "${{ matrix.lua }},vendored"
-        cargo test --release --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
-      shell: bash
-    - name: Run compile tests (macos lua53)
-      if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua53' }}
-      run: |
-        TRYBUILD=overwrite cargo test --release --features "${{ matrix.lua }},vendored" -- --ignored
-        TRYBUILD=overwrite cargo test --release --features "${{ matrix.lua }},vendored,async,send,serialize,macros" -- --ignored
-      shell: bash
+      - uses: actions/checkout@v4
+      - 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,send,serialize,macros,parking_lot"
+          cargo test --features "${{ matrix.lua }},vendored,async,serialize,macros,parking_lot,unstable"
+        shell: bash
+      - name: Run compile tests (macos lua54)
+        if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua54' }}
+        run: |
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored" -- --ignored
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable" -- --ignored
+        shell: bash
+
+  test_with_sanitizer:
+    name: Test with address sanitizer
+    runs-on: ${{ matrix.os }}
+    needs: build
+    strategy:
+      matrix:
+        os: [ubuntu-22.04]
+        rust: [nightly]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
+        include:
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+    steps:
+      - uses: actions/checkout@v4
+      - 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,send,serialize,macros,parking_lot,unstable" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+        shell: bash
+        env:
+          RUSTFLAGS: -Z sanitizer=address
 
   test_modules:
     name: Test modules
@@ -140,26 +164,26 @@ jobs:
     needs: build
     strategy:
       matrix:
-        os: [ubuntu-18.04, macos-latest]
-        rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        os: [ubuntu-22.04, macos-latest]
+        rust: [stable]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau]
         include:
-        - os: ubuntu-18.04
-          target: x86_64-unknown-linux-gnu
-        - os: macos-latest
-          target: x86_64-apple-darwin
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ matrix.rust }}
-        target: ${{ matrix.target }}
-        override: true
-    - name: Run ${{ matrix.lua }} module tests
-      run: |
-        (cd examples/module && cargo build --release --features "${{ matrix.lua }},vendored")
-        (cd tests/module && cargo test --release --features "${{ matrix.lua }},vendored")
-      shell: bash
+      - uses: actions/checkout@v4
+      - 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
@@ -172,42 +196,63 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-    - uses: msys2/setup-msys2@v2
-    - uses: actions/checkout@v2
-    - name: Install Rust & Lua
-      run: |
-        pacman -S --noconfirm mingw-w64-x86_64-rust mingw-w64-x86_64-lua mingw-w64-x86_64-luajit mingw-w64-x86_64-pkg-config
-    - name: Run ${{ matrix.lua }} module tests
-      run: |
-        (cd examples/module && cargo build --release --features "${{ matrix.lua }}")
-        (cd tests/module && cargo test --release --features "${{ matrix.lua }}")
+      - uses: msys2/setup-msys2@v2
+      - uses: actions/checkout@v4
+      - name: Install Rust & Lua
+        run: |
+          pacman -S --noconfirm mingw-w64-x86_64-rust mingw-w64-x86_64-lua mingw-w64-x86_64-luajit mingw-w64-x86_64-pkg-config
+      - 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-22.04
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua54, lua53, lua52, lua51, luau]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: wasm32-unknown-emscripten
+      - name: Install Emscripten
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends emscripten
+      - name: Run ${{ matrix.lua }} tests
+        run: |
+          cargo test --tests --features "${{ matrix.lua }},vendored"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,parking_lot,unstable"
 
   rustfmt:
     name: Rustfmt
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        components: rustfmt
-        override: true
-    - run: cargo fmt -- --check
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          components: rustfmt
+      - run: cargo fmt -- --check
 
   clippy:
-    name: Clippy check
-    runs-on: ubuntu-18.04
+    name: Clippy
+    runs-on: ubuntu-22.04
     strategy:
       matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
+      - 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"
+          reporter: 'github-pr-review'
+          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot,unstable"

.gitignore

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

CHANGELOG.md

@@ -1,3 +1,349 @@
+## 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
+- Added `Table::to_pointer()` and `String::to_pointer()` functions
+- Bugfixes and improvements (#176 #179)
+
+## v0.8.0
+Changes since 0.7.4
+- Roblox Luau support
+- Removed C glue
+- Added async support to `__index` and `__newindex` metamethods
+- Added `Function::info()` to get information about functions (#149).
+- Added `parking_lot` dependency under feature flag (for `UserData`)
+- `Hash` implementation for Lua String
+- Added `Value::to_pointer()` function
+- Performance improvements
+
+Breaking changes:
+- Refactored `AsChunk` trait (added implementation for `Path` and `PathBuf`).
+
+## v0.8.0-beta.5
+
+- Lua sources no longer needed to build modules
+- Added `__iter` metamethod for Luau
+- Added `Value::to_pointer()` function
+- Added `Function::coverage` for Luau to obtain coverage report
+- Bugfixes and improvements (#153 #161 #168)
+
+## v0.8.0-beta.4
+
+- Removed `&Lua` from `Lua::set_interrupt` as it's not safe (introduced in v0.8.0-beta.3)
+- Enabled `Lua::gc_inc` for Luau
+- Luau `debug` module marked as safe (enabled by default)
+- Implemented `Hash` for Lua String
+- Support mode options in `collectgarbage` for Luau
+- Added ability to set global Luau compiler (used for loading all chunks).
+- Refactored `AsChunk` trait (breaking changes).
+  `AsChunk` now implemented for `Path` and `PathBuf` to load lua files from fs.
+- Added `parking_lot` dependency and feature flag (for `UserData`)
+- Added `Function::info()` to get information about functions (#149).
+- Bugfixes and improvements (#104 #142)
+
+## v0.8.0-beta.3
+
+- Luau vector constructor
+- Luau sandboxing support
+- Luau interrupts (yieldable)
+- More Luau compiler options (mutable globals)
+- Other performance improvements
+
+## v0.8.0-beta.2
+
+- Luau vector datatype support
+- Luau readonly table attribute
+- Other Luau improvements
+
+## v0.8.0-beta.1
+
+- Roblox Luau support
+- Refactored ffi module. C glue is no longer required
+- Added async support to `__index` and `__newindex` metamethods
+
+## v0.7.4
+
+- Improved `Lua::create_registry_value` to reuse previously expired registry keys.
+  No need to call `Lua::expire_registry_values` when creating/dropping registry values.
+- Added `Lua::replace_registry_value` to change value of an existing Registry Key
+- Async calls optimization
+
+## v0.7.3
+
+- Fixed cross-compilation issue (introduced in 84a174c)
+
+## v0.7.2
+
+- Allow `pkg-config` to omit include paths if they equals to standard (#114).
+- Various bugfixes (eg. #121)
+
+## v0.7.1
+
+- Fixed traceback generation for errors (#112)
+- `Lua::into_static/from_static` methods have been removed from the docs and are discouraged for use
+
+## v0.7.0
+
+- New "application data" api to store arbitrary objects inside Lua
+- New feature flag `luajit52` to build/support LuaJIT with partial compatibility with Lua 5.2
+- Added async meta methods for all Lua (except 5.1)
+- Added `AnyUserData::take()` to take UserData objects from Lua
+- Added `set_nth_user_value`/`get_nth_user_value` to `AnyUserData` for all Lua versions
+- Added `set_named_user_value`/`get_named_user_value` to `AnyUserData` for all Lua versions
+- Added `Lua::inspect_stack()` to get information about the interpreter runtime stack
+- Added `set_warning_function`/`remove_warning_function`/`warning` functions to `Lua` for 5.4
+- Added `TableExt::call()` to call tables with `__call` metamethod as functions
+- Added `Lua::unload()` to unload modules
+- `ToLua` implementation for arrays changed to const generics
+- Added thread (coroutine) cache for async execution (disabled by default and works for Lua 5.4/JIT)
+- LuaOptions and (De)SerializeOptions marked as const
+- Fixed recursive tables serialization when using `serde::Serialize` for Lua Tables
+- Improved errors reporting. Now source included to `fmt::Display` implementation for `Error::CallbackError`
+- Major performance improvements
+
+## v0.6.6
+
+- Fixed calculating `LUA_REGISTRYINDEX` when cross-compiling for lua51/jit (#82)
+- Updated documentation & examples
+
+## v0.6.5
+
+- Fixed bug when polling async futures (#77)
+- Refactor Waker handling in async code (+10% performance gain when calling async functions)
+- Added `Location::caller()` information to `Lua::load()` if chunk's name is None (Rust 1.46+)
+- Added serialization of i128/u128 types (serde)
+
+## v0.6.4
+
+- Performance optimizations
+- Fixed table traversal used in recursion detection in deserializer
+
+## v0.6.3
+
+- Disabled catching Rust panics in userdata finalizers on drop. It also has positive performance impact.
+- Added `Debug::event()` to the hook's Debug structure
+- Simplified interface of `hook::HookTriggers`
+- Added finalizer to `ExtraData` in module mode. This helps avoiding memory leak on closing state when Lua unloads modules and frees memory.
+- Added `DeserializeOptions` struct to control deserializer behavior (`from_value_with` function).
+
+## v0.6.2
+
+- New functionality: `Lua::load_from_function()` and `Lua::create_c_function()`
+- Many optimizations in callbacks/userdata creation and methods execution
+
+## v0.6.1
+
+- Update `chunk!` documentation (stable Rust limitations)
+- Fixed Lua sequence table conversion to HashSet/BTreeSet
+- `once_cell` dependency lowered to 1.0
+
+## v0.6.0
+Changes since 0.5.4
+- New `UserDataFields` API
+- Full access to `UserData` metatables with support of setting arbitrary fields.
+- Implement `UserData` for `Rc<RefCell<T>>`/`Arc<Mutex<T>>`/`Arc<RwLock<T>>` where `T: UserData`.
+- Added `SerializeOptions` to to change default Lua serializer behaviour (eg. `nil/null/array` serialization)
+- Added `LuaOptions` to customize Lua/Rust behaviour (currently panic handling)
+- Added `ToLua`/`FromLua` implementation for `Box<str>` and `Box<[T]>`.
+- Added `Thread::reset()` for luajit/lua54 to recycle threads (coroutines) with attaching a new function.
+- Added `chunk!` macro support to load chunks of Lua code using the Rust tokenizer and optionally capturing Rust variables.
+- Improved errors reporting (`Error`'s `__tostring` method formats full stacktraces). This is useful in a module mode.
+- Added `String::to_string_lossy`
+- Various bugfixes and improvements
+
+Breaking changes:
+- Errors are always `Send + Sync` to be compatible with the anyhow crate.
+- Removed `Result` from `LuaSerdeExt::null()` and `LuaSerdeExt::array_metatable()` (never fails)
+- Removed `Result` from `Function::dump()` (never fails)
+- Removed `AnyUserData::has_metamethod()` (in favour of full access to metatables)
+
 ## v0.6.0-beta.3
 
 - Errors are always `Send + Sync` to be compatible with anyhow crate

Cargo.toml

@@ -1,95 +1,116 @@
 [package]
 name = "mlua"
-version = "0.6.0-beta.3" # remember to update html_root_url and mlua_derive
-authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
-edition = "2018"
+version = "0.9.5" # remember to update mlua_derive
+authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
+rust-version = "1.71"
+edition = "2021"
 repository = "https://github.com/khvzak/mlua"
 documentation = "https://docs.rs/mlua"
 readme = "README.md"
-keywords = ["lua", "luajit", "async", "futures", "scripting"]
+keywords = ["lua", "luajit", "luau", "async", "scripting"]
 categories = ["api-bindings", "asynchronous"]
 license = "MIT"
-links = "lua"
-build = "build/main.rs"
 description = """
-High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT)
-with async/await features and support of writing native lua modules in Rust.
+High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+with async/await features and support of writing native Lua modules in Rust.
 """
 
 [package.metadata.docs.rs]
-features = ["lua53", "async", "send", "serialize", "macros"]
+features = ["lua54", "vendored", "async", "send", "serialize", "macros", "parking_lot", "unstable"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [workspace]
 members = [
     "mlua_derive",
-    "examples/module",
-    "tests/module",
+    "mlua-sys",
 ]
 
 [features]
-lua54 = []
-lua53 = []
-lua52 = []
-lua51 = []
-luajit = []
-vendored = ["lua-src", "luajit-src"]
-module = ["mlua_derive"]
-async = ["futures-core", "futures-task", "futures-util"]
+lua54 = ["ffi/lua54"]
+lua53 = ["ffi/lua53"]
+lua52 = ["ffi/lua52"]
+lua51 = ["ffi/lua51"]
+luajit = ["ffi/luajit"]
+luajit52 = ["luajit", "ffi/luajit52"]
+luau = ["ffi/luau", "libloading"]
+luau-jit = ["luau", "ffi/luau-codegen"]
+luau-vector4 = ["luau", "ffi/luau-vector4"]
+vendored = ["ffi/vendored"]
+module = ["mlua_derive", "ffi/module"]
+async = ["futures-util"]
 send = []
-serialize = ["serde", "erased-serde"]
+serialize = ["serde", "erased-serde", "serde-value"]
 macros = ["mlua_derive/macros"]
+unstable = []
 
 [dependencies]
-mlua_derive = { version = "=0.6.0-beta.2", optional = true, path = "mlua_derive" }
-bstr = { version = "0.2", features = ["std"], default_features = false }
-once_cell = { version = "1.7" }
+mlua_derive = { version = "=0.9.2", optional = true, path = "mlua_derive" }
+bstr = { version = "1.0", features = ["std"], default_features = false }
+once_cell = { version = "1.0" }
 num-traits = { version = "0.2.14" }
-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 = "1.0"
+futures-util = { version = "0.3", optional = true, default-features = false, features = ["std"] }
 serde = { version = "1.0", optional = true }
-erased-serde = { version = "0.3", optional = true }
+erased-serde = { version = "0.4", optional = true }
+serde-value = { version = "0.7", optional = true }
+parking_lot = { version = "0.12", optional = true }
 
-[build-dependencies]
-cc = { version = "1.0" }
-pkg-config = { version = "0.3.17" }
-lua-src = { version = ">= 540.0.0, < 550.0.0", optional = true }
-luajit-src = { version = ">= 210.1.2, < 220.0.0", optional = true }
+ffi = { package = "mlua-sys", version = "0.5.1", path = "mlua-sys" }
+
+[target.'cfg(unix)'.dependencies]
+libloading = { version = "0.8", optional = true }
 
 [dev-dependencies]
-rustyline = "8.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"
+tokio = { version = "1.0", features = ["macros", "rt", "time"] }
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 maplit = "1.0"
+tempfile = "3"
+static_assertions = "1.0"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+criterion = { version = "0.5", features = ["async_tokio"] }
+rustyline = "13.0"
+tokio = { version = "1.0", features = ["full"] }
 
 [[bench]]
 name = "benchmark"
 harness = false
 required-features = ["async"]
 
+[[bench]]
+name = "serde"
+harness = false
+required-features = ["serialize"]
+
 [[example]]
 name = "async_http_client"
-required-features = ["async"]
+required-features = ["async", "macros"]
 
 [[example]]
 name = "async_http_reqwest"
-required-features = ["async", "serialize"]
+required-features = ["async", "serialize", "macros"]
 
 [[example]]
 name = "async_http_server"
-required-features = ["async", "send"]
+required-features = ["async", "macros"]
 
 [[example]]
 name = "async_tcp_server"
-required-features = ["async"]
+required-features = ["async", "macros"]
+
+[[example]]
+name = "guided_tour"
+required-features = ["macros"]
 
 [[example]]
 name = "serialize"
 required-features = ["serialize"]
+
+[[example]]
+name = "userdata"
+required-features = ["macros"]

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,5 +1,5 @@
 # mlua
-[![Build Status]][github-actions] [![Latest Version]][crates.io] [![API Documentation]][docs.rs] [![Coverage Status]][codecov.io]
+[![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
@@ -7,19 +7,31 @@
 [crates.io]: https://crates.io/crates/mlua
 [API Documentation]: https://docs.rs/mlua/badge.svg
 [docs.rs]: https://docs.rs/mlua
-[Coverage Status]: https://codecov.io/gh/khvzak/mlua/branch/master/graph/badge.svg?token=99339FS1CG
-[codecov.io]: https://codecov.io/gh/khvzak/mlua
+[Coverage Status]: https://codecov.io/gh/mlua-rs/mlua/branch/master/graph/badge.svg?token=99339FS1CG
+[codecov.io]: https://codecov.io/gh/mlua-rs/mlua
+[MSRV]: https://img.shields.io/badge/rust-1.71+-brightgreen.svg?&logo=rust
 
-[Guided Tour](examples/guided_tour.rs)
+[Guided Tour] | [Benchmarks] | [FAQ]
+
+[Guided Tour]: examples/guided_tour.rs
+[Benchmarks]: https://github.com/khvzak/script-bench-rs
+[FAQ]: FAQ.md
+
+> **Note**
+>
+> See v0.9 [release notes](https://github.com/khvzak/mlua/blob/master/docs/release_notes/v0.9.md).
 
 `mlua` is bindings to [Lua](https://www.lua.org) programming language for Rust with a goal to provide
 _safe_ (as far as it's possible), high level, easy to use, practical and flexible API.
 
-Started as [rlua](https://github.com/amethyst/rlua/tree/0.15.3) fork, `mlua` supports Lua 5.4, 5.3, 5.2 and 5.1 including LuaJIT (2.0.5 and 2.1 beta) and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.
+Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Roblox Luau] and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.
 
 `mlua` tested on Windows/macOS/Linux including module mode in [GitHub Actions] on `x86_64` platform and cross-compilation to `aarch64` (other targets are also supported).
 
+WebAssembly (WASM) is supported through `wasm32-unknown-emscripten` target for all Lua versions excluding JIT.
+
 [GitHub Actions]: https://github.com/khvzak/mlua/actions
+[Roblox Luau]: https://luau-lang.org
 
 ## Usage
 
@@ -33,28 +45,38 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 * `lua52`: activate Lua [5.2] support
 * `lua51`: activate Lua [5.1] support
 * `luajit`: activate [LuaJIT] support
+* `luajit52`: activate [LuaJIT] support with partial compatibility with Lua 5.2
+* `luau`: activate [Luau] support (auto vendored mode)
+* `luau-jit`: activate [Luau] support with JIT backend.
+* `luau-vector4`: activate [Luau] support with 4-dimensional vector.
 * `vendored`: build static Lua(JIT) library from sources during `mlua` compilation using [lua-src] or [luajit-src] crates
 * `module`: enable module mode (building loadable `cdylib` library for Lua)
 * `async`: enable async/await support (any executor can be used, eg. [tokio] or [async-std])
 * `send`: make `mlua::Lua` transferable across thread boundaries (adds [`Send`] requirement to `mlua::Function` and `mlua::UserData`)
 * `serialize`: add serialization and deserialization support to `mlua` types using [serde] framework
 * `macros`: enable procedural macros (such as `chunk!`)
+* `parking_lot`: support UserData types wrapped in [parking_lot]'s primitives (`Arc<Mutex>` and `Arc<RwLock>`)
+* `unstable`: enable **unstable** features. The public API of these features may break between releases.
 
 [5.4]: https://www.lua.org/manual/5.4/manual.html
 [5.3]: https://www.lua.org/manual/5.3/manual.html
 [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
 [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. 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`.
+`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`.
 
 **Examples**:
 - [HTTP Client](examples/async_http_client.rs)
@@ -74,16 +96,16 @@ With `serialize` feature flag enabled, `mlua` allows you to serialize/deserializ
 
 ### Compiling
 
-You have to enable one of the features `lua54`, `lua53`, `lua52`, `lua51` or `luajit`, according to the chosen Lua version.
+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.
+To achieve this, mlua supports `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
 `LUA_LINK` is optional and may be `dylib` (a dynamic library) or `static` (a static library, `.a` archive).
 
 An example how to use them:
 ``` sh
-my_project $ LUA_INC=$HOME/tmp/lua-5.2.4/src LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
+my_project $ LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
 ```
 
 `mlua` also supports vendored lua/luajit using the auxiliary crates [lua-src](https://crates.io/crates/lua-src) and
@@ -97,7 +119,7 @@ Add to `Cargo.toml` :
 
 ``` toml
 [dependencies]
-mlua = { version = "0.6.0-beta", features = ["lua53", "vendored"] }
+mlua = { version = "0.9.1", features = ["lua54", "vendored"] }
 ```
 
 `main.rs`
@@ -121,7 +143,7 @@ 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.3/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.3/manual.html#6.10).
+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).
 
 [Example](examples/module)
 
@@ -132,7 +154,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]
 
 [dependencies]
-mlua = { version = "0.6.0-beta", features = ["lua53", "vendored", "module"] }
+mlua = { version = "0.9.1", features = ["lua54", "module"] }
 ```
 
 `lib.rs` :
@@ -158,7 +180,7 @@ And then (**macOS** example):
 ``` sh
 $ cargo rustc -- -C link-arg=-undefined -C link-arg=dynamic_lookup
 $ ln -s ./target/debug/libmy_module.dylib ./my_module.so
-$ lua5.3 -e 'require("my_module").hello("world")'
+$ lua5.4 -e 'require("my_module").hello("world")'
 hello, world!
 ```
 
@@ -177,13 +199,20 @@ rustflags = [
 ]
 ```
 On Linux you can build modules normally with `cargo build --release`.
-Vendored and non-vendored builds are supported for these OS.
 
-On Windows `vendored` mode for modules is not supported since you need to link to a Lua dll.
-Easiest way is to use either MinGW64 (as part of [MSYS2](https://github.com/msys2/msys2) package) with `pkg-config` or
-MSVC with `LUA_INC` / `LUA_LIB` / `LUA_LIB_NAME` environment variables.
+On Windows the target module will be linked with `lua5x.dll` library (depending on your feature flags).
+Your main application should provide this library.
 
-More details about compiling and linking Lua modules can be found on the [Building Modules](http://lua-users.org/wiki/BuildingModules) page.
+Module builds don't require Lua lib or headers to be installed on the system.
+
+### Publishing to luarocks.org
+
+There is a LuaRocks build backend for mlua modules [`luarocks-build-rust-mlua`].
+
+Modules written in Rust and published to luarocks:
+- [`lua-ryaml`](https://github.com/khvzak/lua-ryaml)
+
+[`luarocks-build-rust-mlua`]: https://luarocks.org/modules/khvzak/luarocks-build-rust-mlua
 
 ## Safety
 
@@ -238,6 +267,14 @@ If you encounter them, a bug report would be very welcome:
 
   + If you detect that, after catching a panic or during a Drop triggered from a panic, a `Lua` or handle method is triggering other bugs or there is a Lua stack space leak, this is a bug. `mlua` instances are supposed to remain fully usable in the face of user generated panics. This guarantee does not extend to panics marked with "mlua internal error" simply because that is already indicative of a separate bug.
 
+## Sandboxing
+
+Please check the [Luau Sandboxing] page if you are interested in running untrusted Lua scripts in controlled environment.
+
+`mlua` provides `Lua::sandbox` method for enabling sandbox mode (Luau only).
+
+[Luau Sandboxing]: https://luau-lang.org/sandbox
+
 ## License
 
 This project is licensed under the [MIT license](LICENSE)

benches/benchmark.rs

@@ -59,6 +59,93 @@ fn create_string_table(c: &mut Criterion) {
     });
 }
 
+fn table_get_set(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let table = lua.create_table().unwrap();
+
+    c.bench_function("table raw_get and raw_set [10]", |b| {
+        b.iter_batched(
+            || {
+                collect_gc_twice(&lua);
+                table.clear().unwrap();
+            },
+            |_| {
+                for (i, &s) in ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+                    .iter()
+                    .enumerate()
+                {
+                    table.raw_set(s, i).unwrap();
+                    assert_eq!(table.raw_get::<_, usize>(s).unwrap(), i);
+                }
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn table_traversal_pairs(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    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 create_function(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    c.bench_function("create [function] 10", |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();
 
@@ -104,7 +191,8 @@ fn call_sum_callback(c: &mut Criterion) {
 }
 
 fn call_async_sum_callback(c: &mut Criterion) {
-    let lua = Lua::new();
+    let options = LuaOptions::new().thread_pool_size(1024);
+    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
     let callback = lua
         .create_async_function(|_, (a, b, c): (i64, i64, i64)| async move {
             task::yield_now().await;
@@ -192,6 +280,33 @@ fn create_userdata(c: &mut Criterion) {
     });
 }
 
+fn call_userdata_index(c: &mut Criterion) {
+    struct UserData(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));
+        }
+    }
+
+    let lua = Lua::new();
+    lua.globals().set("userdata", UserData(10)).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();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
 fn call_userdata_method(c: &mut Criterion) {
     struct UserData(i64);
     impl LuaUserData for UserData {
@@ -220,16 +335,19 @@ fn call_userdata_method(c: &mut Criterion) {
 }
 
 fn call_async_userdata_method(c: &mut Criterion) {
-    #[derive(Clone, Copy)]
-    struct UserData(i64);
+    struct UserData(String);
+
     impl LuaUserData for UserData {
         fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_async_method("method", |_, this, ()| async move { Ok(this.0) });
+            methods.add_async_method("method", |_, this, ()| async move { Ok(this.0.clone()) });
         }
     }
 
-    let lua = Lua::new();
-    lua.globals().set("userdata", UserData(10)).unwrap();
+    let options = LuaOptions::new().thread_pool_size(1024);
+    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
+    lua.globals()
+        .set("userdata", UserData("hello".to_string()))
+        .unwrap();
 
     c.bench_function("call async [userdata method] 10", |b| {
         let rt = Runtime::new().unwrap();
@@ -258,12 +376,18 @@ criterion_group! {
         create_table,
         create_array,
         create_string_table,
+        table_get_set,
+        table_traversal_pairs,
+        table_traversal_for_each,
+        table_traversal_sequence,
+        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,
 }

benches/serde.rs

@@ -0,0 +1,64 @@
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use std::time::Duration;
+
+use mlua::prelude::*;
+
+fn collect_gc_twice(lua: &Lua) {
+    lua.gc_collect().unwrap();
+    lua.gc_collect().unwrap();
+}
+
+fn serialize_json(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    lua.globals()
+        .set(
+            "encode",
+            LuaFunction::wrap(|_, t: LuaValue| Ok(serde_json::to_string(&t).unwrap())),
+        )
+        .unwrap();
+
+    c.bench_function("serialize table to json [10]", |b| {
+        b.iter_batched(
+            || {
+                collect_gc_twice(&lua);
+                lua.load(
+                    r#"
+                local encode = encode
+                return function()
+                    for i = 1, 10 do
+                        encode({
+                            name = "Clark Kent",
+                            nickname = "Superman",
+                            address = {
+                                city = "Metropolis",
+                            },
+                            age = 32,
+                            superman = true,
+                        })
+                    end
+                end
+            "#,
+                )
+                .eval::<LuaFunction>()
+                .unwrap()
+            },
+            |func| {
+                func.call::<_, ()>(()).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .sample_size(300)
+        .measurement_time(Duration::from_secs(10))
+        .noise_threshold(0.02);
+    targets =
+        serialize_json,
+}
+
+criterion_main!(benches);

build/find_dummy.rs

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

build/find_normal.rs

@@ -1,119 +0,0 @@
-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() -> 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 PathBuf::from(include_dir);
-    }
-
-    // Find using `pkg-config`
-
-    #[cfg(feature = "lua54")]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.4"), Bound::Excluded("5.5")))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe("lua5.4");
-        }
-
-        lua.unwrap().include_paths[0].clone()
-    }
-
-    #[cfg(feature = "lua53")]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.3"), Bound::Excluded("5.4")))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe("lua5.3");
-        }
-
-        lua.unwrap().include_paths[0].clone()
-    }
-
-    #[cfg(feature = "lua52")]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.2"), Bound::Excluded("5.3")))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe("lua5.2");
-        }
-
-        lua.unwrap().include_paths[0].clone()
-    }
-
-    #[cfg(feature = "lua51")]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.1"), Bound::Excluded("5.2")))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe("lua5.1");
-        }
-
-        lua.unwrap().include_paths[0].clone()
-    }
-
-    #[cfg(feature = "luajit")]
-    {
-        let lua = pkg_config::Config::new()
-            .range_version((Bound::Included("2.0.5"), Bound::Unbounded))
-            .cargo_metadata(need_lua_lib)
-            .probe("luajit");
-
-        lua.unwrap().include_paths[0].clone()
-    }
-}

build/main.rs

@@ -1,252 +0,0 @@
-#![allow(unreachable_code)]
-
-use std::env;
-use std::fs::File;
-use std::io::{Error, ErrorKind, Result, Write};
-use std::path::{Path, PathBuf};
-use std::process::Command;
-
-#[cfg_attr(
-    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"
-    )),
-    path = "find_dummy.rs"
-)]
-mod find;
-
-trait CommandExt {
-    fn execute(&mut self) -> Result<()>;
-}
-
-impl CommandExt for Command {
-    /// Execute the command and return an error if it exited with a failure status.
-    fn execute(&mut self) -> Result<()> {
-        self.status()
-            .and_then(|status| {
-                if status.success() {
-                    Ok(())
-                } else {
-                    Err(Error::new(ErrorKind::Other, "non-zero exit code"))
-                }
-            })
-            .map_err(|_| {
-                Error::new(
-                    ErrorKind::Other,
-                    format!("The command {:?} did not run successfully.", self),
-                )
-            })
-    }
-}
-
-fn build_glue<P: AsRef<Path> + std::fmt::Debug>(include_path: &P) {
-    let build_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-
-    let mut config = cc::Build::new();
-    config.include(include_path);
-
-    // Compile and run glue.c
-    let glue = build_dir.join("glue");
-
-    config
-        .get_compiler()
-        .to_command()
-        .arg("src/ffi/glue/glue.c")
-        .arg("-o")
-        .arg(&glue)
-        .execute()
-        .unwrap();
-
-    Command::new(glue)
-        .arg(build_dir.join("glue.rs"))
-        .execute()
-        .unwrap();
-}
-
-// When cross-compiling, we cannot use `build_glue` as we cannot run the generated
-// executable.  Instead, let's take a stab at synthesizing the likely values.
-// If you're cross-compiling and using a non-vendored library then there is a chance
-// that the values selected here may be incorrect, but we have no way to determine
-// that here.
-fn generate_glue() -> Result<()> {
-    let build_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    let mut glue = File::create(build_dir.join("glue.rs"))?;
-    writeln!(
-        glue,
-        "/* This file was generated by build/main.rs; do not modify by hand */"
-    )?;
-    writeln!(glue, "use std::os::raw::*;")?;
-
-    writeln!(glue, "/* luaconf.h */")?;
-    let pointer_bit_width: usize = env::var("CARGO_CFG_TARGET_POINTER_WIDTH")
-        .unwrap()
-        .parse()
-        .unwrap();
-    writeln!(
-        glue,
-        "pub const LUA_EXTRASPACE: c_int = {} / 8;",
-        pointer_bit_width
-    )?;
-
-    // This is generally hardcoded to this size
-    writeln!(glue, "pub const LUA_IDSIZE: c_int = 60;")?;
-
-    // Unless the target is restricted, the defaults are 64 bit
-    writeln!(glue, "pub type LUA_NUMBER = c_double;")?;
-    writeln!(glue, "pub type LUA_INTEGER = i64;")?;
-    writeln!(glue, "pub type LUA_UNSIGNED = u64;")?;
-
-    writeln!(glue, "/* lua.h */")?;
-    let version = if cfg!(any(feature = "luajit", feature = "lua51")) {
-        (5, 1, 0)
-    } else if cfg!(feature = "lua52") {
-        (5, 2, 0)
-    } else if cfg!(feature = "lua53") {
-        (5, 3, 0)
-    } else if cfg!(feature = "lua54") {
-        (5, 4, 0)
-    } else {
-        unreachable!();
-    };
-    writeln!(
-        glue,
-        "pub const LUA_VERSION_NUM: c_int = {};",
-        (version.0 * 100) + version.1
-    )?;
-
-    let max_stack = if pointer_bit_width >= 32 {
-        1_000_000
-    } else {
-        15_000
-    };
-    writeln!(
-        glue,
-        "pub const LUA_REGISTRYINDEX: c_int = -{} - 1000;",
-        max_stack
-    )?;
-
-    // These two are only defined in lua 5.1
-    writeln!(glue, "pub const LUA_ENVIRONINDEX: c_int = -10001;")?;
-    writeln!(glue, "pub const LUA_GLOBALSINDEX: c_int = -10002;")?;
-
-    writeln!(glue, "/* lauxlib.h */")?;
-    // This is only defined in lua 5.3 and up, but we can always generate its value here,
-    // even if we don't use it.
-    // This matches the default definition in lauxlib.h
-    writeln!(glue, "pub const LUAL_NUMSIZES: c_int = std::mem::size_of::<LUA_INTEGER>() as c_int * 16 + std::mem::size_of::<LUA_NUMBER>() as c_int;")?;
-
-    writeln!(glue, "/* lualib.h */")?;
-    write!(
-        glue,
-        r#"
-#[cfg(feature = "luajit")]
-pub const LUA_BITLIBNAME: &str = "bit";
-#[cfg(not(feature = "luajit"))]
-pub const LUA_BITLIBNAME: &str = "bit32";
-
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_LOADLIBNAME: &str = "package";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-
-pub const LUA_JITLIBNAME: &str = "jit";
-pub const LUA_FFILIBNAME: &str = "ffi";
-"#
-    )?;
-
-    Ok(())
-}
-
-fn main() {
-    #[cfg(not(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit"
-    )))]
-    compile_error!("You must enable one of the features: lua54, lua53, lua52, lua51, luajit");
-
-    #[cfg(all(
-        feature = "lua54",
-        any(
-            feature = "lua53",
-            feature = "lua52",
-            feature = "lua51",
-            feature = "luajit"
-        )
-    ))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
-
-    #[cfg(all(
-        feature = "lua53",
-        any(feature = "lua52", feature = "lua51", feature = "luajit")
-    ))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
-
-    #[cfg(all(feature = "lua52", any(feature = "lua51", feature = "luajit")))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
-
-    #[cfg(all(feature = "lua51", feature = "luajit"))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
-
-    // 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."
-    );
-
-    let include_dir = find::probe_lua();
-    if env::var("TARGET").unwrap() != env::var("HOST").unwrap() {
-        generate_glue().unwrap();
-    } else {
-        build_glue(&include_dir);
-        println!("cargo:rerun-if-changed=src/ffi/glue/glue.c");
-    }
-
-    let mut shim_cc = cc::Build::new();
-    shim_cc
-        .include(include_dir)
-        .define("COMPAT53_INCLUDE_SOURCE", None);
-    #[cfg(feature = "luajit")]
-    shim_cc.define("COMPAT53_LUAJIT", None);
-    shim_cc.file("src/ffi/shim/shim.c").compile("shim");
-
-    println!("cargo:rerun-if-changed=src/ffi/shim");
-    println!("cargo:rerun-if-changed=build");
-}

codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    patch:
+      default:
+        only_pulls: true
+    project:
+      default:
+        only_pulls: true

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/khvzak/mlua/blob/master/CHANGELOG.md
+
+### New features
+
+#### 1. New Any UserData API
+
+This is a long awaited feature that allows to register in Lua foreign types that cannot implement `UserData` trait because of the Rust orphan rules.
+
+Now you can register any type that implements [`Any`] trait as a userdata type.
+
+Consider the following example:
+
+```rust
+lua.register_userdata_type::<std::string::String>(|reg| {
+    reg.add_method("len", |_, this, ()| Ok(this.len()));
+
+    reg.add_method_mut("push", |_, this, s: String| {
+        this.push_str(&s);
+        Ok(())
+    });
+
+    reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
+})?;
+
+let s = lua.create_any_userdata("hello".to_string())?;
+lua.load(chunk! {
+    print("s:len() is " .. $s:len())
+    $s:push(" world")
+    // Prints: hello, world
+    print($s)
+})
+.exec()?;
+```
+
+In this example we registered [`std::string::String`] as a userdata type with a set of methods and then created an instance of this type in Lua.
+
+It's _not_ required to register a type before using the `Lua::create_any_userdata()` method, instead an empty metatable will be created for you.
+You can also register the same type multiple times with different methods. Any previously created instances will share the old metatable, while new instances will have the new one.
+
+The new set of API is called `any_userdata` because it allows to register types that implements [`Any`] trait.
+
+[`std::string::String`]: https://doc.rust-lang.org/stable/std/string/struct.String.html
+[`Any`]: https://doc.rust-lang.org/stable/std/any/trait.Any.html
+
+#### 2. Scope support for the new any userdata types
+
+When you need to create non-static userdata instances in Lua, the usual way is use `Lua::scope()` helper to make them scoped. When out of scope, any scoped objects will be automatically
+dropped. The only downside of this approach is that every new instance will have a new metatable. This is not very fast if you need to create a lot of instances.
+
+With the new Any UserData API, you can place non-static references `&T` where `T: 'static` into a scope and they will share a single static metatable.
+
+```rust
+lua.register_userdata_type::<std::string::String>(|reg| {
+    reg.add_method_mut("replace", |_, this, (pat, to): (String, String)| {
+        *this = this.replace(&pat, &to);
+        Ok(())
+    });
+
+    reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
+})?;
+
+let mut s = "hello, world".to_string();
+
+lua.scope(|scope| {
+    // This userdata instance holds only a mutable reference to our string
+    let ud = scope.create_any_userdata_ref_mut(&mut s)?;
+    lua.load(chunk! {
+        $ud:replace("world", "user")
+    })
+    .exec()
+})?;
+
+// Prints: hello, user!
+println!("{s}!");
+```
+
+#### 3. Owned types (`unstable`)
+
+One of the common questions was how to embed a Lua type into Rust struct to use it later. It was non-trivial to do because of the `'lua` lifetime attached to every Lua value.
+
+In v0.9 mlua introduces "owned" types `OwnedTable`/`OwnedFunction`/`OwnedString`/`OwnedAnyUserData`/ `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/khvzak/script-bench-rs
+
+### Changes in `module` mode
+
+#### New attributes
+
+The `lua_module` macro now support the following attributes:
+
+- `name=...` - sets name of the module (defaults to the name of the function).
+
+Eg.:
+
+```rust
+#[mlua::lua_module(name = "alt_module")]
+fn my_module(lua: &Lua) -> LuaResult<LuaTable> {
+    lua.create_table()
+}
+```
+
+Under the hood a new function `luaopen_alt_module` will be created for the Lua module loader.
+
+- `skip_memory_check` - skip memory allocation checks for some operations.
+
+In module mode, mlua runs in unknown environment and cannot say are there any memory limits or not. As result, some operations that require memory allocation runs in
+protected mode. Setting this attribute will improve performance of such operations with risk of having uncaught exceptions and memory leaks.
+
+#### Improved Windows target
+
+In previous mlua versions, building a Lua module for Windows requires having Lua development libraries installed on the system.
+In contrast, on Linux and macOS, modules can be built without any external dependencies using the `-undefined=dynamic_lookup` linker flag.
+
+With Rust 1.71+ it's now possible to lift this restriction for Windows as well. You can build modules normally and they will be linked with
+`lua54.dll`/`lua53.dll`/`lua52.dll`/`lua51.dll` depending on the enabled Lua version.
+
+You still need to have the dll although, linked to application where the module will be loaded.
+
+### Breaking changes
+
+1) `ToLua`/`ToLuaMulti` traits have been renamed to `IntoLua`/`IntoLuaMulti` respectively (with the methods called `into_lua`/`into_lua_multi`).
+
+The main reason for this change is following the Rust self [convention](https://rust-lang.github.io/rust-clippy/master/index.html#/wrong_self_convention).
+
+2) Removed `FromLua` implementation for `T: UserData + Clone`.
+
+During the usage of mlua, it was found that this implementation is not very useful and prevents custom `FromLua` implementations for `T: UserData`.
+It should be a developer decision to opt-in `FromLua` for their `T` if needed rather than having enabled it unconditionally.
+
+To opt-in `FromLua` for `T: Clone` you can use a simple `#[derive(FromLua)]` macro (requires `feature = "macros"`):
+
+```rust
+#[derive(Clone, Copy, mlua::FromLua)]
+struct MyUserData(i32);
+```
+
+`T` is not required to implement `UserData` because of the new relaxed restrictions on userdata types.

examples/async_http_client.rs

@@ -1,27 +1,17 @@
 use std::collections::HashMap;
-use std::sync::Arc;
 
 use hyper::body::{Body as HyperBody, HttpBody as _};
 use hyper::Client as HyperClient;
-use tokio::sync::Mutex;
 
-use mlua::{ExternalResult, Lua, Result, UserData, UserDataMethods};
+use mlua::{chunk, ExternalResult, Lua, Result, UserData, UserDataMethods};
 
-#[derive(Clone)]
-struct BodyReader(Arc<Mutex<HyperBody>>);
-
-impl BodyReader {
-    fn new(body: HyperBody) -> Self {
-        BodyReader(Arc::new(Mutex::new(body)))
-    }
-}
+struct BodyReader(HyperBody);
 
 impl UserData for BodyReader {
     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("read", |lua, reader, ()| async move {
-            let mut reader = reader.0.lock().await;
-            if let Some(bytes) = reader.data().await {
-                let bytes = bytes.to_lua_err()?;
+        methods.add_async_method_mut("read", |lua, reader, ()| async move {
+            if let Some(bytes) = reader.0.data().await {
+                let bytes = bytes.into_lua_err()?;
                 return Some(lua.create_string(&bytes)).transpose();
             }
             Ok(None)
@@ -29,14 +19,14 @@ impl UserData for BodyReader {
     }
 }
 
-#[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 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())?;
@@ -46,23 +36,19 @@ 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)?;
-        lua_resp.set("body", BodyReader::new(resp.into_body()))?;
+        lua_resp.set("body", BodyReader(resp.into_body()))?;
 
         Ok(lua_resp)
     })?;
 
-    let globals = lua.globals();
-    globals.set("fetch_url", fetch_url)?;
-
     let f = lua
-        .load(
-            r#"
-            local res = fetch_url(...)
-            print(res.status)
+        .load(chunk! {
+            local res = $fetch_url(...)
+            print("status: "..res.status)
             for key, vals in pairs(res.headers) do
                 for _, val in ipairs(vals) do
                     print(key..": "..val)
@@ -74,8 +60,7 @@ async fn main() -> Result<()> {
                     print(body)
                 end
             until not body
-        "#,
-        )
+        })
         .into_function()?;
 
     f.call_async("http://httpbin.org/ip").await

examples/async_http_reqwest.rs

@@ -1,37 +1,34 @@
-use mlua::{ExternalResult, Lua, LuaSerdeExt, Result};
+use mlua::{chunk, ExternalResult, Lua, LuaSerdeExt, Result};
 
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
     let lua = Lua::new();
-    let globals = lua.globals();
-    globals.set("null", lua.null())?;
+
+    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)
     })?;
-    globals.set("fetch_json", fetch_json)?;
 
     let f = lua
-        .load(
-            r#"
+        .load(chunk! {
             function print_r(t, indent)
-                local indent = indent or ''
+                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
+                    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(...)
+            local res = $fetch_json(...)
             print_r(res)
-        "#,
-        )
+        })
         .into_function()?;
 
     f.call_async("https://httpbin.org/anything?arg0=val0").await

examples/async_http_server.rs

@@ -1,10 +1,16 @@
+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::{make_service_fn, service_fn};
+use hyper::service::Service;
 use hyper::{Body, Request, Response, Server};
 
-use mlua::{Error, Function, Lua, Result, Table, UserData, UserDataMethods};
+use mlua::{
+    chunk, Error as LuaError, Function, Lua, String as LuaString, Table, UserData, UserDataMethods,
+};
 
 struct LuaRequest(SocketAddr, Request<Body>);
 
@@ -15,75 +21,106 @@ impl UserData for LuaRequest {
     }
 }
 
-async fn run_server(handler: Function<'static>) -> Result<()> {
-    let make_svc = make_service_fn(|socket: &AddrStream| {
-        let remote_addr = socket.remote_addr();
-        let handler = handler.clone();
-        async move {
-            Ok::<_, Error>(service_fn(move |req: Request<Body>| {
-                let handler = handler.clone();
-                async move {
-                    let lua_req = LuaRequest(remote_addr, req);
-                    let lua_resp: Table = handler.call_async(lua_req).await?;
-                    let body = lua_resp
-                        .get::<_, Option<String>>("body")?
-                        .unwrap_or_default();
+pub struct Svc(Rc<Lua>, SocketAddr);
 
-                    let mut resp = Response::builder()
-                        .status(lua_resp.get::<_, Option<u16>>("status")?.unwrap_or(200));
+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(()))
+    }
+
+    fn call(&mut self, req: Request<Body>) -> Self::Future {
+        // If handler returns an error then generate 5xx response
+        let lua = self.0.clone();
+        let lua_req = LuaRequest(self.1, req);
+        Box::pin(async move {
+            let handler: Function = lua.named_registry_value("http_handler")?;
+            match handler.call_async::<_, Table>(lua_req).await {
+                Ok(lua_resp) => {
+                    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")? {
-                        for pair in headers.pairs::<String, String>() {
+                        for pair in headers.pairs::<String, LuaString>() {
                             let (h, v) = pair?;
-                            resp = resp.header(&h, v);
+                            resp = resp.header(&h, v.as_bytes());
                         }
                     }
 
-                    Ok::<_, Error>(resp.body(Body::from(body)).unwrap())
+                    let body = lua_resp
+                        .get::<_, Option<LuaString>>("body")?
+                        .map(|b| Body::from(b.as_bytes().to_vec()))
+                        .unwrap_or_else(Body::empty);
+
+                    Ok(resp.body(body).unwrap())
                 }
-            }))
-        }
-    });
+                Err(err) => {
+                    eprintln!("{}", err);
+                    Ok(Response::builder()
+                        .status(500)
+                        .body(Body::from("Internal Server Error"))
+                        .unwrap())
+                }
+            }
+        })
+    }
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let lua = Rc::new(Lua::new());
+
+    // Create Lua handler function
+    let handler: Function = lua
+        .load(chunk! {
+            function(req)
+                return {
+                    status = 200,
+                    headers = {
+                        ["X-Req-Method"] = req:method(),
+                        ["X-Remote-Addr"] = req:remote_addr(),
+                    },
+                    body = "Hello from Lua!\n"
+                }
+            end
+        })
+        .eval()
+        .expect("cannot create Lua handler");
+
+    // Store it in the Registry
+    lua.set_named_registry_value("http_handler", handler)
+        .expect("cannot store Lua handler");
 
     let addr = ([127, 0, 0, 1], 3000).into();
-    let server = Server::bind(&addr).executor(LocalExec).serve(make_svc);
+    let server = Server::bind(&addr).executor(LocalExec).serve(MakeSvc(lua));
 
     println!("Listening on http://{}", addr);
 
-    tokio::task::LocalSet::new()
-        .run_until(server)
-        .await
-        .map_err(Error::external)
+    // Create `LocalSet` to spawn !Send futures
+    let local = tokio::task::LocalSet::new();
+    local.run_until(server).await.expect("cannot run server")
 }
 
-#[tokio::main]
-async fn main() -> Result<()> {
-    let lua = Lua::new().into_static();
+struct MakeSvc(Rc<Lua>);
 
-    let handler: Function = lua
-        .load(
-            r#"
-        function(req)
-            return {
-                status = 200,
-                headers = {
-                    ["X-Req-Method"] = req:method(),
-                    ["X-Remote-Addr"] = req:remote_addr(),
-                },
-                body = "Hello, World!\n"
-            }
-        end
-    "#,
-        )
-        .eval()?;
+impl Service<&AddrStream> for MakeSvc {
+    type Response = Svc;
+    type Error = hyper::Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
 
-    run_server(handler).await?;
+    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
 
-    // Consume the static reference and drop it.
-    // This is safe as long as we don't hold any other references to Lua
-    // or alive resources.
-    unsafe { Lua::from_static(lua) };
-    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)]

examples/async_tcp_server.rs

@@ -1,126 +1,110 @@
-use std::sync::Arc;
+use std::io;
+use std::net::SocketAddr;
+use std::rc::Rc;
 
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
-use tokio::sync::Mutex;
 use tokio::task;
 
-use mlua::{Function, Lua, Result, String as LuaString, UserData, UserDataMethods};
+use mlua::{chunk, Function, Lua, RegistryKey, String as LuaString, UserData, UserDataMethods};
 
-struct LuaTcp;
-
-#[derive(Clone)]
-struct LuaTcpListener(Arc<Mutex<TcpListener>>);
-
-#[derive(Clone)]
-struct LuaTcpStream(Arc<Mutex<TcpStream>>);
-
-impl UserData for LuaTcp {
-    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_function("bind", |_, addr: String| async move {
-            let listener = TcpListener::bind(addr).await?;
-            Ok(LuaTcpListener(Arc::new(Mutex::new(listener))))
-        });
-    }
-}
-
-impl UserData for LuaTcpListener {
-    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("accept", |_, listener, ()| async move {
-            let (stream, _) = listener.0.lock().await.accept().await?;
-            Ok(LuaTcpStream(Arc::new(Mutex::new(stream))))
-        });
-    }
-}
+struct LuaTcpStream(TcpStream);
 
 impl UserData for LuaTcpStream {
     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("peer_addr", |_, stream, ()| async move {
-            Ok(stream.0.lock().await.peer_addr()?.to_string())
+        methods.add_method("peer_addr", |_, this, ()| {
+            Ok(this.0.peer_addr()?.to_string())
         });
 
-        methods.add_async_method("read", |lua, stream, size: usize| async move {
+        methods.add_async_method_mut("read", |lua, this, size| async move {
             let mut buf = vec![0; size];
-            let n = stream.0.lock().await.read(&mut buf).await?;
+            let n = this.0.read(&mut buf).await?;
             buf.truncate(n);
             lua.create_string(&buf)
         });
 
-        methods.add_async_method("write", |_, stream, data: LuaString| async move {
-            let n = stream.0.lock().await.write(&data.as_bytes()).await?;
+        methods.add_async_method_mut("write", |_, this, data: LuaString| async move {
+            let n = this.0.write(&data.as_bytes()).await?;
             Ok(n)
         });
 
-        methods.add_async_method("close", |_, stream, ()| async move {
-            stream.0.lock().await.shutdown().await?;
+        methods.add_async_method_mut("close", |_, this, ()| async move {
+            this.0.shutdown().await?;
             Ok(())
         });
     }
 }
 
-async fn run_server(lua: &'static Lua) -> Result<()> {
-    let spawn = lua.create_function(move |_, func: Function| {
-        task::spawn_local(async move { func.call_async::<_, ()>(()).await });
-        Ok(())
-    })?;
+async fn run_server(lua: Lua, handler: RegistryKey) -> io::Result<()> {
+    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
+    let listener = TcpListener::bind(addr).await.expect("cannot bind addr");
 
-    let globals = lua.globals();
-    globals.set("tcp", LuaTcp)?;
-    globals.set("spawn", spawn)?;
+    println!("Listening on {}", addr);
 
-    let server = lua
-        .load(
-            r#"
-            local addr = ...
-            local listener = tcp.bind(addr)
-            print("listening on "..addr)
+    let lua = Rc::new(lua);
+    let handler = Rc::new(handler);
+    loop {
+        let (stream, _) = match listener.accept().await {
+            Ok(res) => res,
+            Err(err) if is_transient_error(&err) => continue,
+            Err(err) => return Err(err),
+        };
 
-            local accept_new = true
-            while true do
-                local stream = listener:accept()
+        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");
+
+            let stream = LuaTcpStream(stream);
+            if let Err(err) = handler.call_async::<_, ()>(stream).await {
+                eprintln!("{}", err);
+            }
+        });
+    }
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let lua = Lua::new();
+
+    // Create Lua handler function
+    let handler_fn = lua
+        .load(chunk! {
+            function(stream)
                 local peer_addr = stream:peer_addr()
                 print("connected from "..peer_addr)
 
-                if not accept_new then
-                    return
-                end
-
-                spawn(function()
-                    while true do
-                        local data = stream:read(100)
-                        data = data:match("^%s*(.-)%s*$") -- trim
-                        print("["..peer_addr.."] "..data)
-                        if data == "bye" then
-                            stream:write("bye bye\n")
-                            stream:close()
-                            return
-                        end
-                        if data == "exit" then
-                            stream:close()
-                            accept_new = false
-                            return
-                        end
-                        stream:write("echo: "..data.."\n")
+                while true do
+                    local data = stream:read(100)
+                    data = data:match("^%s*(.-)%s*$") // trim
+                    print("["..peer_addr.."] "..data)
+                    if data == "bye" then
+                        stream:write("bye bye\n")
+                        stream:close()
+                        return
                     end
-                end)
+                    stream:write("echo: "..data.."\n")
+                end
             end
-        "#,
-        )
-        .into_function()?;
+        })
+        .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(server.call_async::<_, ()>("0.0.0.0:1234"))
+        .run_until(run_server(lua, handler))
         .await
+        .expect("cannot run server")
 }
 
-#[tokio::main]
-async fn main() {
-    let lua = Lua::new().into_static();
-
-    run_server(lua).await.unwrap();
-
-    // Consume the static reference and drop it.
-    // This is safe as long as we don't hold any other references to Lua
-    // or alive resources.
-    unsafe { Lua::from_static(lua) };
+fn is_transient_error(e: &io::Error) -> bool {
+    e.kind() == io::ErrorKind::ConnectionRefused
+        || e.kind() == io::ErrorKind::ConnectionAborted
+        || e.kind() == io::ErrorKind::ConnectionReset
 }

examples/guided_tour.rs

@@ -1,15 +1,17 @@
 use std::f32;
 use std::iter::FromIterator;
 
-use mlua::{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
+    // You can create a new Lua state with `Lua::new()`. This loads the default Lua std library
     // *without* the debug library.
     let lua = Lua::new();
 
-    // You can get and set global variables.  Notice that the globals table here is a permanent
-    // reference to _G, and it is mutated behind the scenes as Lua code is loaded.  This API is
+    // You can get and set global variables. Notice that the globals table here is a permanent
+    // reference to _G, and it is mutated behind the scenes as Lua code is loaded. This API is
     // based heavily around sharing and internal mutation (just like Lua itself).
 
     let globals = lua.globals();
@@ -20,9 +22,9 @@ fn main() -> Result<()> {
     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
+    // 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 loaded chunk to "example code", which will be used when Lua error
     // messages are printed.
 
     lua.load(
@@ -30,7 +32,7 @@ fn main() -> Result<()> {
             global = 'foo'..'bar'
         "#,
     )
-    .set_name("example code")?
+    .set_name("example code")
     .exec()?;
     assert_eq!(globals.get::<_, String>("global")?, "foobar");
 
@@ -38,6 +40,17 @@ fn main() -> Result<()> {
     assert_eq!(lua.load("false == false").eval::<bool>()?, true);
     assert_eq!(lua.load("return 1 + 2").eval::<i32>()?, 3);
 
+    // Use can use special `chunk!` macro to use Rust tokenizer and automatically capture variables
+
+    let a = 1;
+    let b = 2;
+    let name = "world";
+    lua.load(chunk! {
+        print($a + $b)
+        print("hello, " .. $name)
+    })
+    .exec()?;
+
     // You can create and manage Lua tables
 
     let array_table = lua.create_table()?;
@@ -76,7 +89,7 @@ fn main() -> Result<()> {
     let print: Function = globals.get("print")?;
     print.call::<_, ()>("hello from rust")?;
 
-    // This API generally handles variadics using tuples.  This is one way to call a function with
+    // This API generally handles variadic using tuples. This is one way to call a function with
     // multiple parameters:
 
     print.call::<_, ()>(("hello", "again", "from", "rust"))?;
@@ -87,15 +100,15 @@ fn main() -> Result<()> {
         ["hello", "yet", "again", "from", "rust"].iter().cloned(),
     ))?;
 
-    // You can bind rust functions to Lua as well.  Callbacks receive the Lua state inself as their
-    // first parameter, and the arguments given to the function as the second parameter.  The type
+    // 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.
 
     let check_equal = lua.create_function(|_, (list1, list2): (Vec<String>, Vec<String>)| {
         // This function just checks whether two string lists are equal, and in an inefficient way.
         // Lua callbacks return `mlua::Result`, an Ok value is a normal return, and an Err return
-        // turns into a Lua 'error'.  Again, any type that is convertible to Lua may be returned.
+        // turns into a Lua 'error'. Again, any type that is convertible to Lua may be returned.
         Ok(list1 == list2)
     })?;
     globals.set("check_equal", check_equal)?;
@@ -140,6 +153,16 @@ fn main() -> Result<()> {
     #[derive(Copy, Clone)]
     struct Vec2(f32, f32);
 
+    // We can implement `FromLua` trait for our `Vec2` to return a copy
+    impl<'lua> FromLua<'lua> for Vec2 {
+        fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+            match value {
+                Value::UserData(ud) => Ok(*ud.borrow::<Self>()?),
+                _ => unreachable!(),
+            }
+        }
+    }
+
     impl UserData for Vec2 {
         fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
             methods.add_method("magnitude", |_, vec, ()| {
@@ -174,7 +197,7 @@ fn main() -> Result<()> {
 
         lua.scope(|scope| {
             // We create a 'sketchy' Lua callback that holds a mutable reference to the variable
-            // `rust_val`.  Outside of a `Lua::scope` call, this would not be allowed
+            // `rust_val`. Outside of a `Lua::scope` call, this would not be allowed
             // because it could be unsafe.
 
             lua.globals().set(
@@ -191,9 +214,9 @@ fn main() -> Result<()> {
         assert_eq!(rust_val, 42);
     }
 
-    // We were able to run our 'sketchy' function inside the scope just fine.  However, if we
+    // 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
-    // been invalidated and we will generate an error.  If our function wasn't invalidated, we
+    // been invalidated and we will generate an error. If our function wasn't invalidated, we
     // might be able to improperly access the freed `rust_val` which would be unsafe.
     assert!(lua.load("sketchy()").exec().is_err());
 

examples/module/.cargo/config

@@ -3,3 +3,9 @@ rustflags = [
   "-C", "link-arg=-undefined",
   "-C", "link-arg=dynamic_lookup",
 ]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]

examples/module/Cargo.toml

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

examples/module/src/lib.rs

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

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,12 +19,12 @@ fn main() {
 
             match lua.load(&line).eval::<MultiValue>() {
                 Ok(values) => {
-                    editor.add_history_entry(line);
+                    editor.add_history_entry(line).unwrap();
                     println!(
                         "{}",
                         values
                             .iter()
-                            .map(|value| format!("{:?}", value))
+                            .map(|value| format!("{:#?}", value))
                             .collect::<Vec<_>>()
                             .join("\t")
                     );

examples/userdata.rs

@@ -0,0 +1,45 @@
+use mlua::{chunk, Lua, MetaMethod, Result, UserData};
+
+#[derive(Default)]
+struct Rectangle {
+    length: u32,
+    width: u32,
+}
+
+impl UserData for Rectangle {
+    fn add_fields<'lua, F: mlua::UserDataFields<'lua, 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;
+            Ok(())
+        });
+        fields.add_field_method_get("width", |_, this| Ok(this.width));
+        fields.add_field_method_set("width", |_, this, val| {
+            this.width = val;
+            Ok(())
+        });
+    }
+
+    fn add_methods<'lua, M: mlua::UserDataMethods<'lua, 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())
+        });
+
+        // Constructor
+        methods.add_meta_function(MetaMethod::Call, |_, ()| Ok(Rectangle::default()));
+    }
+}
+
+fn main() -> Result<()> {
+    let lua = Lua::new();
+    let rectangle = Rectangle::default();
+    lua.load(chunk! {
+        local rect = $rectangle()
+        rect.width = 10
+        rect.length = 5
+        assert(rect:area() == 50)
+        assert(rect:diagonal() - 11.1803 < 0.0001)
+    })
+    .exec()
+}

mlua-sys/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "mlua-sys"
+version = "0.5.1"
+authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
+rust-version = "1.71"
+edition = "2021"
+repository = "https://github.com/khvzak/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 Roblox 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"]
+module = []
+
+[dependencies]
+
+[build-dependencies]
+cc = "1.0"
+cfg-if = "1.0"
+pkg-config = "0.3.17"
+lua-src = { version = ">= 546.0.2, < 546.1.0", optional = true }
+luajit-src = { version = ">= 210.5.0, < 210.6.0", optional = true }
+luau0-src = { version = "0.8.0", optional = true }

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 Roblox [Luau].
+
+Intended to be consumed by the [mlua] crate.
+
+[Luau]: https://github.com/Roblox/luau
+[mlua]: https://crates.io/crates/mlua

mlua-sys/build/find_normal.rs

@@ -0,0 +1,58 @@
+#![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", Some("lua5.4"), "5.4");
+    #[cfg(feature = "lua53")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", Some("lua5.3"), "5.3");
+    #[cfg(feature = "lua52")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", Some("lua5.2"), "5.2");
+    #[cfg(feature = "lua51")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", Some("lua5.1"), "5.1");
+    #[cfg(feature = "luajit")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("2.0.4", "2.2", None, "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() && alt_probe.is_some() {
+        lua = pkg_config::Config::new()
+            .cargo_metadata(true)
+            .probe(alt_probe.unwrap());
+    }
+
+    lua.unwrap_or_else(|err| panic!("cannot find Lua{ver} using `pkg-config`: {err}"));
+}

mlua-sys/build/find_vendored.rs

@@ -1,19 +1,29 @@
-use std::path::PathBuf;
+#![allow(dead_code)]
 
-pub fn probe_lua() -> 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 = luajit_src::Build::new().build();
+    let artifacts = luajit_src::Build::new()
+        .lua52compat(cfg!(feature = "luajit52"))
+        .build();
+
+    #[cfg(feature = "luau")]
+    let artifacts = luau0_src::Build::new()
+        .enable_codegen(cfg!(feature = "luau-codegen"))
+        .set_max_cstack_size(1000000)
+        .set_vector_size(if cfg!(feature = "luau-vector4") { 4 } else { 3 })
+        .build();
 
-    #[cfg(not(feature = "module"))]
     artifacts.print_cargo_metadata();
-
-    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,33 @@
+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(all(feature = "module", feature = "vendored"))]
+    compile_error!("`vendored` and `module` features are mutually exclusive");
+
+    println!("cargo:rerun-if-changed=build");
+
+    #[cfg(windows)]
+    if cfg!(feature = "module") {
+        if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
+            // Don't use raw-dylib linking
+            find::probe_lua();
+            return;
+        }
+
+        println!("cargo:rustc-cfg=raw_dylib");
+    }
+
+    #[cfg(not(feature = "module"))]
+    find::probe_lua();
+}

mlua-sys/src/lib.rs

@@ -0,0 +1,101 @@
+//! Low level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau.
+
+#![allow(non_camel_case_types, non_snake_case, dead_code)]
+#![allow(clippy::missing_safety_doc)]
+#![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;
+
+// The minimum alignment guaranteed by the architecture. This value is used to
+// add fast paths for low alignment values.
+// Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/common/alloc.rs
+#[cfg(any(
+    target_arch = "x86",
+    target_arch = "arm",
+    target_arch = "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")),
+))]
+#[doc(hidden)]
+pub const SYS_MIN_ALIGN: usize = 8;
+#[cfg(any(
+    target_arch = "x86_64",
+    target_arch = "aarch64",
+    target_arch = "mips64",
+    target_arch = "s390x",
+    target_arch = "sparc64",
+    target_arch = "riscv64",
+    target_arch = "wasm64",
+    target_arch = "loongarch64",
+))]
+#[doc(hidden)]
+pub const SYS_MIN_ALIGN: usize = 16;
+// The allocator on the esp-idf platform guarentees 4 byte alignment.
+#[cfg(any(
+    all(target_arch = "riscv32", target_os = "espidf"),
+    all(target_arch = "xtensa", target_os = "espidf"),
+))]
+#[doc(hidden)]
+pub const SYS_MIN_ALIGN: usize = 4;
+
+#[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

@@ -1,69 +1,16 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+//! MLua compatibility layer for Lua 5.1/JIT
+//!
+//! Based on github.com/keplerproject/lua-compat-5.3
 
-// Based on github.com/keplerproject/lua-compat-5.3
-
-#![allow(clippy::needless_return)]
-
-use std::ffi::CStr;
+use std::convert::TryInto;
 use std::mem;
 use std::os::raw::{c_char, c_int, c_void};
 use std::ptr;
 
-use super::lauxlib::{
-    luaL_callmeta, luaL_error, luaL_getmetafield_old, luaL_loadbuffer, luaL_newmetatable_old,
-};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-use super::lauxlib::{luaL_Reg, luaL_checktype, luaL_getmetatable};
-
-#[cfg(feature = "lua52")]
-use super::lauxlib::{luaL_checkstack, luaL_getsubtable};
-
-use super::lua::{
-    self, lua_CFunction, lua_Debug, lua_Integer, lua_Number, lua_State, lua_Writer, lua_call,
-    lua_createtable, lua_dump_old, lua_error, lua_getfield_old, lua_getstack, lua_gettable_old,
-    lua_gettop, lua_insert, lua_isstring, lua_istable, lua_newuserdata, lua_pop, lua_pushboolean,
-    lua_pushcfunction, lua_pushfstring, lua_pushinteger, lua_pushliteral, lua_pushlstring_old,
-    lua_pushnil, lua_pushnumber, lua_pushthread, lua_pushvalue, lua_rawget_old, lua_rawgeti_old,
-    lua_rawset, lua_replace, lua_setfield, lua_setglobal, lua_setmetatable, lua_settable,
-    lua_toboolean, lua_tointeger, lua_tolstring, lua_tonumber, lua_topointer, lua_tostring,
-    lua_touserdata, lua_type, lua_typename,
-};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-use super::lua::{
-    lua_checkstack, lua_concat, lua_equal, lua_getfenv, lua_getinfo, lua_getmetatable,
-    lua_isnumber, lua_lessthan, lua_newtable, lua_next, lua_objlen, lua_pushcclosure,
-    lua_pushlightuserdata, lua_pushstring_old, lua_rawequal, lua_remove, lua_resume_old,
-    lua_setfenv, lua_settop, LUA_OPADD, LUA_OPUNM,
-};
-
-#[cfg(feature = "lua52")]
-use super::lua::{
-    lua_absindex, lua_getglobal_old, lua_getuservalue_old, lua_pushstring, lua_rawgetp_old,
-    lua_rawsetp, lua_tonumberx,
-};
+use super::lauxlib::*;
+use super::lua::*;
 
+#[inline(always)]
 unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
     while a < b {
         lua_pushvalue(L, a);
@@ -125,10 +72,9 @@ unsafe fn compat53_checkmode(
         );
         return err;
     }
-    lua::LUA_OK
+    LUA_OK
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) -> c_int {
     if level == 0 || lua_istable(L, -1) == 0 {
         return 0; // not found
@@ -137,7 +83,7 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
     lua_pushnil(L); // start 'next' loop
     while lua_next(L, -2) != 0 {
         // for each pair in table
-        if lua_type(L, -2) == lua::LUA_TSTRING {
+        if lua_type(L, -2) == LUA_TSTRING {
             // ignore non-string keys
             if lua_rawequal(L, objidx, -1) != 0 {
                 // found object?
@@ -154,25 +100,23 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
         }
         lua_pop(L, 1); // remove value
     }
-    return 0; // not found
+    0 // not found
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, ar: *mut lua_Debug) -> c_int {
     let top = lua_gettop(L);
     lua_getinfo(L, cstr!("f"), ar); // push function
-    lua_pushvalue(L, lua::LUA_GLOBALSINDEX);
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
     if compat53_findfield(L, top + 1, 2) != 0 {
         lua_copy(L, -1, top + 1); // move name to proper place
         lua_pop(L, 2); // remove pushed values
-        return 1;
+        1
     } else {
         lua_settop(L, top); // remove function and global table
-        return 0;
+        0
     }
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 unsafe fn compat53_pushfuncname(L: *mut lua_State, ar: *mut lua_Debug) {
     if *(*ar).namewhat != b'\0' as c_char {
         // is there a name?
@@ -197,75 +141,27 @@ unsafe fn compat53_pushfuncname(L: *mut lua_State, ar: *mut lua_Debug) {
     }
 }
 
-unsafe fn compat53_call_lua(L: *mut lua_State, code: &str, nargs: c_int, nret: c_int) {
-    lua_rawgetp(L, lua::LUA_REGISTRYINDEX, code.as_ptr() as *const c_void);
-    if lua_type(L, -1) != lua::LUA_TFUNCTION {
-        lua_pop(L, 1);
-        if luaL_loadbuffer(
-            L,
-            code.as_ptr() as *const c_char,
-            code.as_bytes().len(),
-            cstr!("=none"),
-        ) != 0
-        {
-            lua_error(L);
-        }
-        lua_pushvalue(L, -1);
-        lua_rawsetp(L, lua::LUA_REGISTRYINDEX, code.as_ptr() as *const c_void);
-    }
-    lua_insert(L, -nargs - 1);
-    lua_call(L, nargs, nret);
-}
-
 //
 // lua ported functions
 //
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub fn lua_upvalueindex(i: c_int) -> c_int {
-    lua::LUA_GLOBALSINDEX - i
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_absindex(L: *mut lua_State, mut idx: c_int) -> c_int {
-    if idx < 0 && idx > lua::LUA_REGISTRYINDEX {
+    if idx < 0 && idx > LUA_REGISTRYINDEX {
         idx += lua_gettop(L) + 1;
     }
     idx
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-static COMPAT53_ARITH_CODE: &str = r#"
-local op,a,b=...
-if op == 0 then return a+b
-elseif op == 1 then return a-b
-elseif op == 2 then return a*b
-elseif op == 3 then return a/b
-elseif op == 4 then return a%b
-elseif op == 5 then return a^b
-elseif op == 6 then return -a
-end
-"#;
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub unsafe fn lua_arith(L: *mut lua_State, op: c_int) {
-    #[allow(clippy::manual_range_contains)]
-    if op < LUA_OPADD || op > LUA_OPUNM {
-        luaL_error(L, cstr!("invalid 'op' argument for lua_arith"));
-    }
-    luaL_checkstack(L, 5, cstr!("not enough stack slots"));
-    if op == LUA_OPUNM {
-        lua_pushvalue(L, -1);
-    }
-    lua_pushnumber(L, op as lua_Number);
-    lua_insert(L, -3);
-    compat53_call_lua(L, COMPAT53_ARITH_CODE, 3, 1);
-}
-
 pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
     idx = lua_absindex(L, idx);
+    if n > 0 {
+        // Faster version
+        for _ in 0..n {
+            lua_insert(L, idx);
+        }
+        return;
+    }
     let n_elems = lua_gettop(L) - idx + 1;
     if n < 0 {
         n += n_elems;
@@ -279,7 +175,6 @@ pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
     }
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {
     let abs_to = lua_absindex(L, toidx);
@@ -290,32 +185,30 @@ pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {
 
 #[inline(always)]
 pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
-    if lua_type(L, idx) == lua::LUA_TNUMBER {
+    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 {
             return 1;
         }
     }
-    return 0;
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_tonumberx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Number {
     let n = lua_tonumber(L, i);
     if !isnum.is_null() {
-        *isnum = if n != 0.0 || lua_isnumber(L, i) != 0 {
-            1
-        } else {
-            0
-        };
+        *isnum = (n != 0.0 || lua_isnumber(L, i) != 0) as c_int;
     }
-    return n;
+    n
 }
 
-// Implemented for Lua 5.2 as well
-// See https://github.com/keplerproject/lua-compat-5.3/issues/40
 #[inline(always)]
 pub unsafe fn lua_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Integer {
     let mut ok = 0;
@@ -330,80 +223,45 @@ pub unsafe fn lua_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) ->
     if !isnum.is_null() {
         *isnum = 0;
     }
-    return 0;
+    0
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
     lua_objlen(L, idx)
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_compare(L: *mut lua_State, mut idx1: c_int, mut idx2: c_int, op: c_int) -> c_int {
-    match op {
-        lua::LUA_OPEQ => lua_equal(L, idx1, idx2),
-        lua::LUA_OPLT => lua_lessthan(L, idx1, idx2),
-        lua::LUA_OPLE => {
-            luaL_checkstack(L, 5, cstr!("not enough stack slots"));
-            idx1 = lua_absindex(L, idx1);
-            idx2 = lua_absindex(L, idx2);
-            lua_pushvalue(L, idx1);
-            lua_pushvalue(L, idx2);
-            compat53_call_lua(L, "local a,b=...\nreturn a<=b\n", 2, 1);
-            let result = lua_toboolean(L, -1);
-            lua_pop(L, 1);
-            result
-        }
-        _ => luaL_error(L, cstr!("invalid 'op' argument for lua_compare")),
-    }
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
     if l == 0 {
-        lua_pushlstring_old(L, cstr!(""), 0);
+        lua_pushlstring_(L, cstr!(""), 0);
     } else {
-        lua_pushlstring_old(L, s, l);
+        lua_pushlstring_(L, s, l);
     }
     lua_tostring(L, -1)
 }
 
-#[cfg(feature = "lua52")]
-#[inline(always)]
-pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
-    if l == 0 {
-        lua_pushlstring_old(L, cstr!(""), 0)
-    } else {
-        lua_pushlstring_old(L, s, l)
-    }
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char {
-    lua_pushstring_old(L, s);
+    lua_pushstring_(L, s);
     lua_tostring(L, -1)
 }
 
-#[cfg(feature = "lua52")]
 #[inline(always)]
 pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
-    lua_getglobal_old(L, var);
+    lua_getglobal_(L, var);
     lua_type(L, -1)
 }
 
 #[inline(always)]
 pub unsafe fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_gettable_old(L, idx);
+    lua_gettable_(L, idx);
     lua_type(L, -1)
 }
 
 #[inline(always)]
 pub unsafe fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int {
-    lua_getfield_old(L, idx, k);
+    lua_getfield_(L, idx, k);
     lua_type(L, -1)
 }
 
@@ -411,54 +269,35 @@ pub unsafe fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c
 pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_int {
     idx = lua_absindex(L, idx);
     lua_pushinteger(L, n);
-    lua_gettable(L, idx);
-    lua_type(L, -1)
+    lua_gettable(L, idx)
 }
 
-// A new version which returns c_int
 #[inline(always)]
 pub unsafe fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_rawget_old(L, idx);
+    lua_rawget_(L, idx);
     lua_type(L, -1)
 }
 
-// A new version which returns c_int
 #[inline(always)]
 pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
-    lua_rawgeti_old(L, idx, n);
+    let n = n.try_into().expect("cannot convert index to lua_Integer");
+    lua_rawgeti_(L, idx, n);
     lua_type(L, -1)
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
     let abs_i = lua_absindex(L, idx);
     lua_pushlightuserdata(L, p as *mut c_void);
-    lua_rawget(L, abs_i);
-    lua_type(L, -1)
+    lua_rawget(L, abs_i)
 }
 
-#[cfg(feature = "lua52")]
-#[inline(always)]
-pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
-    lua_rawgetp_old(L, idx, p);
-    lua_type(L, -1)
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
     lua_getfenv(L, idx);
     lua_type(L, -1)
 }
 
-#[cfg(feature = "lua52")]
-#[inline(always)]
-pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_getuservalue_old(L, idx);
-    lua_type(L, -1)
-}
-
 #[inline(always)]
 pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
     luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
@@ -468,7 +307,12 @@ pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
     lua_settable(L, idx);
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
+#[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);
@@ -478,10 +322,9 @@ pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
     lua_rawset(L, abs_i);
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) {
-    luaL_checktype(L, -1, lua::LUA_TTABLE);
+    luaL_checktype(L, -1, LUA_TTABLE);
     lua_setfenv(L, idx);
 }
 
@@ -492,28 +335,21 @@ pub unsafe fn lua_dump(
     data: *mut c_void,
     _strip: c_int,
 ) -> c_int {
-    lua_dump_old(L, writer, data)
+    lua_dump_(L, writer, data)
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_resume(L: *mut lua_State, _from: *mut lua_State, narg: c_int) -> c_int {
-    lua_resume_old(L, narg)
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_len(L: *mut lua_State, idx: c_int) {
     match lua_type(L, idx) {
-        lua::LUA_TSTRING => {
+        LUA_TSTRING => {
             lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
         }
-        lua::LUA_TTABLE => {
+        LUA_TTABLE => {
             if luaL_callmeta(L, idx, cstr!("__len")) == 0 {
                 lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
             }
         }
-        lua::LUA_TUSERDATA if luaL_callmeta(L, idx, cstr!("__len")) != 0 => {}
+        LUA_TUSERDATA if luaL_callmeta(L, idx, cstr!("__len")) != 0 => {}
         _ => {
             luaL_error(
                 L,
@@ -524,88 +360,32 @@ pub unsafe fn lua_len(L: *mut lua_State, idx: c_int) {
     }
 }
 
-#[inline(always)]
-pub unsafe fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize {
-    use std::str::FromStr;
-
-    let cs = CStr::from_ptr(s);
-    if let Ok(rs) = cs.to_str() {
-        if let Ok(n) = f64::from_str(rs.trim()) {
-            lua_pushnumber(L, n as lua_Number);
-            return cs.to_bytes_with_nul().len();
-        }
-    }
-    0
-}
-
-#[allow(clippy::branches_sharing_code)]
-pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
-    use super::glue::LUA_EXTRASPACE;
-
-    luaL_checkstack(L, 4, cstr!("not enough stack slots available"));
-    lua_pushliteral(L, "__compat53_extraspace");
-    lua_pushvalue(L, -1);
-    lua_rawget(L, lua::LUA_REGISTRYINDEX);
-    if lua_istable(L, -1) == 0 {
-        lua_pop(L, 1);
-        lua_createtable(L, 0, 2);
-        lua_createtable(L, 0, 1);
-        lua_pushliteral(L, "k");
-        lua_setfield(L, -2, cstr!("__mode"));
-        lua_setmetatable(L, -2);
-        lua_pushvalue(L, -2);
-        lua_pushvalue(L, -2);
-        lua_rawset(L, lua::LUA_REGISTRYINDEX);
-    }
-    lua_replace(L, -2);
-    let is_main = lua_pushthread(L);
-    lua_rawget(L, -2);
-    let mut _ptr = lua_touserdata(L, -1);
-    if _ptr.is_null() {
-        lua_pop(L, 1);
-        _ptr = lua_newuserdata(L, LUA_EXTRASPACE as usize);
-        if is_main != 0 {
-            // mem::size_of::<c_void>() == 1
-            ptr::write_bytes(_ptr, 0, LUA_EXTRASPACE as usize);
-            lua_pushthread(L);
-            lua_pushvalue(L, -2);
-            lua_rawset(L, -4);
-            lua_pushboolean(L, 1);
-            lua_pushvalue(L, -2);
-            lua_rawset(L, -4);
-        } else {
-            lua_pushboolean(L, 1);
-            lua_rawget(L, -3);
-            let mptr = lua_touserdata(L, -1);
-            if !mptr.is_null() {
-                ptr::copy_nonoverlapping(mptr, _ptr, LUA_EXTRASPACE as usize)
-            } else {
-                ptr::write_bytes(_ptr, 0, LUA_EXTRASPACE as usize);
-            }
-            lua_pop(L, 1);
-            lua_pushthread(L);
-            lua_pushvalue(L, -2);
-            lua_rawset(L, -4);
-        }
-    }
-    lua_pop(L, 2);
-    return _ptr;
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
-    lua_pushvalue(L, lua::LUA_GLOBALSINDEX);
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
+}
+
+#[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, narg);
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
 }
 
 //
 // lauxlib ported functions
 //
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char) {
-    if lua_checkstack(L, sz + lua::LUA_MINSTACK) == 0 {
+    if lua_checkstack(L, sz + LUA_MINSTACK) == 0 {
         if !msg.is_null() {
             luaL_error(L, cstr!("stack overflow (%s)"), msg);
         } else {
@@ -615,23 +395,19 @@ pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char)
     }
 }
 
-pub unsafe fn luaL_checkversion(_L: *mut lua_State) {
-    // Void
-}
-
 #[inline(always)]
 pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int {
-    if luaL_getmetafield_old(L, obj, e) != 0 {
+    if luaL_getmetafield_(L, obj, e) != 0 {
         lua_type(L, -1)
     } else {
-        lua::LUA_TNIL
+        LUA_TNIL
     }
 }
 
 #[inline(always)]
 pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int {
-    if luaL_newmetatable_old(L, tname) != 0 {
-        lua_pushstring(L, tname);
+    if luaL_newmetatable_(L, tname) != 0 {
+        lua_pushstring_(L, tname);
         lua_setfield(L, -2, cstr!("__name"));
         1
     } else {
@@ -639,7 +415,6 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
     }
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn luaL_loadbufferx(
     L: *mut lua_State,
@@ -648,32 +423,30 @@ pub unsafe fn luaL_loadbufferx(
     name: *const c_char,
     mode: *const c_char,
 ) -> c_int {
-    let status = if sz > 0 && *buff as u8 == lua::LUA_SIGNATURE[0] {
-        compat53_checkmode(L, mode, cstr!("binary"), lua::LUA_ERRSYNTAX)
+    let status = if sz > 0 && *buff as u8 == LUA_SIGNATURE[0] {
+        compat53_checkmode(L, mode, cstr!("binary"), LUA_ERRSYNTAX)
     } else {
-        compat53_checkmode(L, mode, cstr!("text"), lua::LUA_ERRSYNTAX)
+        compat53_checkmode(L, mode, cstr!("text"), LUA_ERRSYNTAX)
     };
-    if status != lua::LUA_OK {
+    if status != LUA_OK {
         return status;
     }
     luaL_loadbuffer(L, buff, sz, name)
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[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"));
     lua_len(L, idx);
     let res = lua_tointegerx(L, -1, &mut isnum);
-    lua::lua_pop(L, 1);
+    lua_pop(L, 1);
     if isnum == 0 {
         luaL_error(L, cstr!("object length is not an integer"));
     }
     res
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 pub unsafe fn luaL_traceback(
     L: *mut lua_State,
     L1: *mut lua_State,
@@ -713,33 +486,33 @@ 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 {
-            lua::LUA_TNIL => {
+        match lua_type(L, idx) {
+            LUA_TNIL => {
                 lua_pushliteral(L, "nil");
             }
-            lua::LUA_TSTRING | lua::LUA_TNUMBER => {
+            LUA_TSTRING | LUA_TNUMBER => {
                 lua_pushvalue(L, idx);
             }
-            lua::LUA_TBOOLEAN => {
+            LUA_TBOOLEAN => {
                 if lua_toboolean(L, idx) == 0 {
                     lua_pushliteral(L, "false");
                 } else {
                     lua_pushliteral(L, "true");
                 }
             }
-            _ => {
+            t => {
                 let tt = luaL_getmetafield(L, idx, cstr!("__name"));
-                let name = if tt == lua::LUA_TSTRING {
+                let name = if tt == LUA_TSTRING {
                     lua_tostring(L, -1)
                 } else {
                     lua_typename(L, t)
                 };
                 lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
-                if tt != lua::LUA_TNIL {
-                    lua_replace(L, -2);
+                if tt != LUA_TNIL {
+                    lua_replace(L, -2); // remove '__name'
                 }
             }
         };
@@ -749,7 +522,6 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
     lua_tolstring(L, -1, len)
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
     luaL_checkstack(L, 1, cstr!("not enough stack slots"));
@@ -757,57 +529,19 @@ pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
     lua_setmetatable(L, -2);
 }
 
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn luaL_testudata(L: *mut lua_State, i: c_int, tname: *const c_char) -> *mut c_void {
-    let mut p = lua_touserdata(L, i);
-    luaL_checkstack(L, 2, cstr!("not enough stack slots"));
-    if p.is_null() || lua_getmetatable(L, i) == 0 {
-        return ptr::null_mut();
-    } else {
-        luaL_getmetatable(L, tname);
-        let res = lua_rawequal(L, -1, -2);
-        lua_pop(L, 2);
-        if res == 0 {
-            p = ptr::null_mut();
-        }
-    }
-    return p;
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn luaL_setfuncs(L: *mut lua_State, mut l: *const luaL_Reg, nup: c_int) {
-    luaL_checkstack(L, nup + 1, cstr!("too many upvalues"));
-    while !(*l).name.is_null() {
-        // fill the table with given functions
-        l = l.offset(1);
-        lua_pushstring(L, (*l).name);
-        for _ in 0..nup {
-            // copy upvalues to the top
-            lua_pushvalue(L, -(nup + 1));
-        }
-        lua_pushcclosure(L, (*l).func, nup); // closure with those upvalues
-        lua_settable(L, -(nup + 3)); // table must be below the upvalues, the name and the closure
-    }
-    lua_pop(L, nup); // remove upvalues
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 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"));
-    lua_pushstring(L, fname);
-    lua_gettable(L, abs_i);
-    if lua_istable(L, -1) != 0 {
+    lua_pushstring_(L, fname);
+    if lua_gettable(L, abs_i) == LUA_TTABLE {
         return 1;
     }
     lua_pop(L, 1);
     lua_newtable(L);
-    lua_pushstring(L, fname);
+    lua_pushstring_(L, fname);
     lua_pushvalue(L, -2);
     lua_settable(L, abs_i);
-    return 0;
+    0
 }
 
 pub unsafe fn luaL_requiref(
@@ -817,12 +551,12 @@ pub unsafe fn luaL_requiref(
     glb: c_int,
 ) {
     luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, lua::LUA_REGISTRYINDEX, cstr!("_LOADED"));
-    if lua_getfield(L, -1, modname) == lua::LUA_TNIL {
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    if lua_getfield(L, -1, modname) == LUA_TNIL {
         lua_pop(L, 1);
         lua_pushcfunction(L, openf);
         lua_pushstring(L, modname);
-        #[cfg(any(feature = "lua52", feature = "lua51"))]
+        #[cfg(feature = "lua51")]
         {
             lua_call(L, 1, 1);
             lua_pushvalue(L, -1);
@@ -834,11 +568,10 @@ pub unsafe fn luaL_requiref(
             lua_getfield(L, -1, modname);
         }
     }
-    if cfg!(any(feature = "lua52", feature = "lua51")) && glb != 0 {
+    if glb != 0 {
         lua_pushvalue(L, -1);
         lua_setglobal(L, modname);
-    }
-    if cfg!(feature = "luajit") && glb == 0 {
+    } else {
         lua_pushnil(L);
         lua_setglobal(L, modname);
     }

mlua-sys/src/lua51/lauxlib.rs

@@ -0,0 +1,147 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+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;
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
+    #[link_name = "luaL_getmetafield"]
+    pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_typerror(L: *mut lua_State, narg: c_int, tname: *const c_char) -> c_int;
+    pub fn luaL_argerror(L: *mut lua_State, narg: c_int, extramsg: *const c_char) -> c_int;
+    pub fn luaL_checklstring(L: *mut lua_State, narg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        l: *mut usize,
+    ) -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, narg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, narg: c_int, def: lua_Number) -> lua_Number;
+    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_checkstack"]
+    pub fn luaL_checkstack_(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, narg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, narg: c_int);
+
+    #[link_name = "luaL_newmetatable"]
+    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_where(L: *mut lua_State, lvl: c_int);
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    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_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_findtable(
+        L: *mut lua_State,
+        idx: c_int,
+        fname: *const c_char,
+        szhint: c_int,
+    ) -> *const c_char;
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, narg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, narg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+// Deprecated from 5.3: luaL_checkint, luaL_optint, luaL_checklong, luaL_optlong
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield_(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+// TODO: luaL_opt
+
+//
+// TODO: Generic Buffer Manipulation
+//

mlua-sys/src/lua51/lua.rs

@@ -0,0 +1,407 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_double, c_int, c_void};
+use std::ptr;
+
+// Mark for precompiled code (`<esc>Lua`)
+#[cfg(not(feature = "luajit"))]
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+#[cfg(feature = "luajit")]
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLJ";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+//
+// 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 fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_GLOBALSINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRERR: c_int = 5;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+/// Type produced by LuaJIT FFI module
+#[cfg(feature = "luajit")]
+pub const LUA_TCDATA: c_int = 10;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// 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;
+
+/// Type for native C functions that can be passed to Lua.
+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-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-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_remove(L: *mut lua_State, idx: c_int);
+    pub fn lua_insert(L: *mut lua_State, idx: c_int);
+    pub fn lua_replace(L: *mut lua_State, idx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_equal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_lessthan(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+
+    pub fn lua_tonumber(L: *mut lua_State, idx: c_int) -> lua_Number;
+    #[link_name = "lua_tointeger"]
+    pub fn lua_tointeger_(L: *mut lua_State, idx: 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_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_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;
+
+    //
+    // Push functions (C -> stack)
+    //
+    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_pushlstring"]
+    pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize);
+    #[link_name = "lua_pushstring"]
+    pub fn lua_pushstring_(L: *mut lua_State, s: *const c_char);
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    #[link_name = "lua_gettable"]
+    pub fn lua_gettable_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_getfield"]
+    pub fn lua_getfield_(L: *mut lua_State, idx: c_int, k: *const c_char);
+    #[link_name = "lua_rawget"]
+    pub fn lua_rawget_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawgeti"]
+    pub fn lua_rawgeti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getfenv(L: *mut lua_State, idx: c_int);
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawseti"]
+    pub fn lua_rawseti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setfenv(L: *mut lua_State, idx: c_int) -> c_int;
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    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;
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+    ) -> c_int;
+
+    #[link_name = "lua_dump"]
+    pub fn lua_dump_(L: *mut lua_State, writer: lua_Writer, data: *mut c_void) -> c_int;
+
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yield(L: *mut lua_State, nresults: c_int) -> c_int;
+    #[link_name = "lua_resume"]
+    pub fn lua_resume_(L: *mut lua_State, narg: c_int) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+//
+// Miscellaneous functions
+//
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+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)
+//
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+// TODO: lua_strlen
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+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_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= LUA_TNIL) as 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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
+    lua_setfield(L, LUA_GLOBALSINDEX, var)
+}
+
+#[inline(always)]
+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
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+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-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    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_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;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub currentline: c_int,
+    pub nups: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: c_int,
+}

mlua-sys/src/lua51/lualib.rs

@@ -0,0 +1,43 @@
+//! 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_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+pub const LUA_LOADLIBNAME: &str = "package";
+
+#[cfg(feature = "luajit")]
+pub const LUA_BITLIBNAME: &str = "bit";
+#[cfg(feature = "luajit")]
+pub const LUA_JITLIBNAME: &str = "jit";
+#[cfg(feature = "luajit")]
+pub const LUA_FFILIBNAME: &str = "ffi";
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_io(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(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;
+
+    #[cfg(feature = "luajit")]
+    pub fn luaopen_bit(L: *mut lua_State) -> c_int;
+    #[cfg(feature = "luajit")]
+    pub fn luaopen_jit(L: *mut lua_State) -> c_int;
+    #[cfg(feature = "luajit")]
+    pub fn luaopen_ffi(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}

mlua-sys/src/lua51/mod.rs

@@ -0,0 +1,11 @@
+//! Low level bindings to Lua 5.1.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;

mlua-sys/src/lua52/compat.rs

@@ -0,0 +1,265 @@
+//! MLua compatibility layer for Lua 5.2
+//!
+//! 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;
+
+use super::lauxlib::*;
+use super::lua::*;
+
+#[inline(always)]
+unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
+    while a < b {
+        lua_pushvalue(L, a);
+        lua_pushvalue(L, b);
+        lua_replace(L, a);
+        lua_replace(L, b);
+        a += 1;
+        b -= 1;
+    }
+}
+
+//
+// lua ported functions
+//
+
+pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
+    idx = lua_absindex(L, idx);
+    if n > 0 {
+        // Faster version
+        for _ in 0..n {
+            lua_insert(L, idx);
+        }
+        return;
+    }
+    let n_elems = lua_gettop(L) - idx + 1;
+    if n < 0 {
+        n += n_elems;
+    }
+    if n > 0 && n < n_elems {
+        luaL_checkstack(L, 2, cstr!("not enough stack slots available"));
+        n = n_elems - n;
+        compat53_reverse(L, idx, idx + n - 1);
+        compat53_reverse(L, idx + n, idx + n_elems - 1);
+        compat53_reverse(L, idx, idx + n_elems - 1);
+    }
+}
+
+#[inline(always)]
+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 {
+            return 1;
+        }
+    }
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
+}
+
+// Implemented for Lua 5.2 as well
+// See https://github.com/keplerproject/lua-compat-5.3/issues/40
+#[inline(always)]
+pub unsafe fn lua_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Integer {
+    let mut ok = 0;
+    let n = lua_tonumberx(L, i, &mut ok);
+    let n_int = n as lua_Integer;
+    if ok != 0 && (n - n_int as lua_Number).abs() < lua_Number::EPSILON {
+        if !isnum.is_null() {
+            *isnum = 1;
+        }
+        return n_int;
+    }
+    if !isnum.is_null() {
+        *isnum = 0;
+    }
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
+    if l == 0 {
+        lua_pushlstring_(L, cstr!(""), 0)
+    } else {
+        lua_pushlstring_(L, s, l)
+    }
+}
+
+#[inline(always)]
+pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
+    lua_getglobal_(L, var);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_gettable_(L, idx);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int {
+    lua_getfield_(L, idx, k);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_int {
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_gettable(L, idx)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_rawget_(L, idx);
+    lua_type(L, -1)
+}
+
+#[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 to lua_Integer");
+    lua_rawgeti_(L, idx, n);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
+    lua_rawgetp_(L, idx, p);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_getuservalue_(L, idx);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_insert(L, -2);
+    lua_settable(L, idx);
+}
+
+#[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_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 {
+    let ret = lua_resume_(L, from, narg);
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
+}
+
+//
+// lauxlib ported functions
+//
+
+#[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 {
+        lua_type(L, -1)
+    } else {
+        LUA_TNIL
+    }
+}
+
+#[inline(always)]
+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"));
+        1
+    } else {
+        0
+    }
+}
+
+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 {
+        match lua_type(L, idx) {
+            LUA_TNIL => {
+                lua_pushliteral(L, "nil");
+            }
+            LUA_TSTRING | LUA_TNUMBER => {
+                lua_pushvalue(L, idx);
+            }
+            LUA_TBOOLEAN => {
+                if lua_toboolean(L, idx) == 0 {
+                    lua_pushliteral(L, "false");
+                } else {
+                    lua_pushliteral(L, "true");
+                }
+            }
+            t => {
+                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
+                let name = if tt == LUA_TSTRING {
+                    lua_tostring(L, -1)
+                } else {
+                    lua_typename(L, t)
+                };
+                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
+                if tt != LUA_TNIL {
+                    lua_replace(L, -2); // remove '__name'
+                }
+            }
+        };
+    } else if lua_isstring(L, -1) == 0 {
+        luaL_error(L, cstr!("'__tostring' must return a string"));
+    }
+    lua_tolstring(L, -1, len)
+}
+
+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 {
+        lua_pop(L, 1);
+        lua_pushcfunction(L, openf);
+        lua_pushstring(L, modname);
+        lua_call(L, 1, 1);
+        lua_pushvalue(L, -1);
+        lua_setfield(L, -3, modname);
+    }
+    if glb != 0 {
+        lua_pushvalue(L, -1);
+        lua_setglobal(L, modname);
+    }
+    lua_replace(L, -2);
+}

mlua-sys/src/lua52/lauxlib.rs

@@ -0,0 +1,187 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Unsigned};
+
+// Extra error code for 'luaL_load'
+pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);
+
+    #[link_name = "luaL_getmetafield"]
+    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;
+    #[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_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;
+    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
+    pub fn luaL_checkunsigned(L: *mut lua_State, arg: c_int) -> lua_Unsigned;
+    pub fn luaL_optunsigned(L: *mut lua_State, arg: c_int, def: lua_Unsigned) -> lua_Unsigned;
+
+    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
+
+    #[link_name = "luaL_newmetatable"]
+    pub fn luaL_newmetatable_(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
+    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+    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, ...) -> c_int;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
+    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
+        -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
+    luaL_loadfilex(L, f, ptr::null())
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_loadbufferx(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+        mode: *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;
+
+    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
+
+    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
+
+    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,
+    );
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+// TODO: luaL_newlibtable, luaL_newlib
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield_(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+// 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 {
+    luaL_loadbufferx(L, s, sz, n, ptr::null())
+}
+
+//
+// TODO: Generic Buffer Manipulation
+//

mlua-sys/src/lua52/lua.rs

@@ -0,0 +1,502 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_double, c_int, c_uchar, c_uint, c_void};
+use std::ptr;
+
+// Mark for precompiled code (`<esc>Lua`)
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+// Size of the Lua stack
+pub const LUAI_MAXSTACK: c_int = 1000000;
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -LUAI_MAXSTACK - 1000;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_REGISTRYINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRGCMM: c_int = 5;
+pub const LUA_ERRERR: c_int = 6;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+pub const LUA_NUMTAGS: c_int = 9;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+// Predefined values in the registry
+pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
+pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
+pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// 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` in Lua 5.2
+pub type lua_Unsigned = c_uint;
+
+/// Type for native C functions that can be passed to Lua
+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-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-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    pub fn lua_version(L: *mut lua_State) -> *const lua_Number;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_remove(L: *mut lua_State, idx: c_int);
+    pub fn lua_insert(L: *mut lua_State, idx: c_int);
+    pub fn lua_replace(L: *mut lua_State, idx: c_int);
+    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    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_tounsignedx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Unsigned;
+    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;
+    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;
+}
+
+//
+// Comparison and arithmetic functions
+//
+pub const LUA_OPADD: c_int = 0;
+pub const LUA_OPSUB: c_int = 1;
+pub const LUA_OPMUL: c_int = 2;
+pub const LUA_OPDIV: c_int = 3;
+pub const LUA_OPMOD: c_int = 4;
+pub const LUA_OPPOW: c_int = 5;
+pub const LUA_OPUNM: c_int = 6;
+
+pub const LUA_OPEQ: c_int = 0;
+pub const LUA_OPLT: c_int = 1;
+pub const LUA_OPLE: c_int = 2;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Push functions (C -> stack)
+    //
+    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);
+    pub fn lua_pushunsigned(L: *mut lua_State, n: lua_Unsigned);
+    #[link_name = "lua_pushlstring"]
+    pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char;
+    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    #[link_name = "lua_getglobal"]
+    pub fn lua_getglobal_(L: *mut lua_State, name: *const c_char);
+    #[link_name = "lua_gettable"]
+    pub fn lua_gettable_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_getfield"]
+    pub fn lua_getfield_(L: *mut lua_State, idx: c_int, k: *const c_char);
+    #[link_name = "lua_rawget"]
+    pub fn lua_rawget_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawgeti"]
+    pub fn lua_rawgeti_(L: *mut lua_State, idx: c_int, n: c_int);
+    #[link_name = "lua_rawgetp"]
+    pub fn lua_rawgetp_(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    #[link_name = "lua_getuservalue"]
+    pub fn lua_getuservalue_(L: *mut lua_State, idx: c_int);
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_setglobal(L: *mut lua_State, var: *const c_char);
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawseti"]
+    pub fn lua_rawseti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setuservalue(L: *mut lua_State, idx: c_int);
+
+    //
+    // '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_pcallk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        errfunc: c_int,
+        ctx: c_int,
+        k: Option<lua_CFunction>,
+    ) -> c_int;
+
+    pub fn lua_getctx(L: *mut lua_State, ctx: *mut c_int) -> c_int;
+
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+    #[link_name = "lua_dump"]
+    pub fn lua_dump_(L: *mut lua_State, writer: lua_Writer, data: *mut c_void) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
+    lua_callk(L, n, r, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
+    lua_pcallk(L, n, r, f, 0, None)
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+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;
+    #[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;
+}
+
+#[inline(always)]
+pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
+    lua_yieldk(L, n, 0, None)
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+pub const LUA_GCSETMAJORINC: c_int = 8;
+pub const LUA_GCISRUNNING: c_int = 9;
+pub const LUA_GCGEN: c_int = 10;
+pub const LUA_GCINC: c_int = 11;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Miscellaneous functions
+    //
+    #[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);
+    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)
+//
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, 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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tounsigned(L: *mut lua_State, i: c_int) -> lua_Unsigned {
+    lua_tounsignedx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+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_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= 0) as 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())
+}
+
+#[inline(always)]
+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
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+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-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    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_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
+    pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
+
+    pub fn lua_sethook(
+        L: *mut lua_State,
+        func: Option<lua_Hook>,
+        mask: c_int,
+        count: c_int,
+    ) -> c_int;
+    pub fn lua_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;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub currentline: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub nups: c_uchar,
+    pub nparams: c_uchar,
+    pub isvararg: c_char,
+    pub istailcall: c_char,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: *mut c_void,
+}

mlua-sys/src/lua52/lualib.rs

@@ -0,0 +1,32 @@
+//! 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";
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    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);
+}

mlua-sys/src/lua52/mod.rs

@@ -0,0 +1,11 @@
+//! Low level bindings to Lua 5.2.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;

mlua-sys/src/lua53/compat.rs

@@ -0,0 +1,19 @@
+//! MLua compatibility layer for Lua 5.3
+
+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
+}

mlua-sys/src/lua53/lauxlib.rs

@@ -0,0 +1,193 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
+
+// Extra error code for 'luaL_loadfilex'
+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";
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
+
+    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;
+    #[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_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;
+    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
+
+    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
+
+    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
+    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+    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, ...) -> c_int;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
+    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
+        -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
+    luaL_loadfilex(L, f, ptr::null())
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_loadbufferx(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+        mode: *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;
+
+    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
+
+    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
+
+    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,
+    );
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+// TODO: luaL_newlibtable, luaL_newlib
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+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 {
+    luaL_loadbufferx(L, s, sz, n, ptr::null())
+}
+
+//
+// TODO: Generic Buffer Manipulation
+//

mlua-sys/src/lua53/lua.rs

@@ -0,0 +1,521 @@
+//! Contains definitions from `lua.h`.
+
+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;
+
+// Mark for precompiled code (`<esc>Lua`)
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+// Size of the Lua stack
+pub const LUAI_MAXSTACK: c_int = 1000000;
+
+// Size of a raw memory area associated with  a Lua state with very fast access.
+pub const LUA_EXTRASPACE: usize = mem::size_of::<*const ()>();
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -LUAI_MAXSTACK - 1000;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_REGISTRYINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRGCMM: c_int = 5;
+pub const LUA_ERRERR: c_int = 6;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+pub const LUA_NUMTAGS: c_int = 9;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+// Predefined values in the registry
+pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
+pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
+pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// A Lua integer, usually equivalent to `i64`
+pub type lua_Integer = i64;
+
+/// A Lua unsigned integer, usually equivalent to `u64`
+pub type lua_Unsigned = u64;
+
+/// Type for continuation-function contexts
+pub type lua_KContext = isize;
+
+/// Type for native C functions that can be passed to Lua
+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-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-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-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    pub fn lua_version(L: *mut lua_State) -> *const lua_Number;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_rotate(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
+    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;
+    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;
+}
+
+//
+// Comparison and arithmetic functions
+//
+pub const LUA_OPADD: c_int = 0;
+pub const LUA_OPSUB: c_int = 1;
+pub const LUA_OPMUL: c_int = 2;
+pub const LUA_OPMOD: c_int = 3;
+pub const LUA_OPPOW: c_int = 4;
+pub const LUA_OPDIV: c_int = 5;
+pub const LUA_OPIDIV: c_int = 6;
+pub const LUA_OPBAND: c_int = 7;
+pub const LUA_OPBOR: c_int = 8;
+pub const LUA_OPBXOR: c_int = 9;
+pub const LUA_OPSHL: c_int = 10;
+pub const LUA_OPSHR: c_int = 11;
+pub const LUA_OPUNM: c_int = 12;
+pub const LUA_OPBNOT: c_int = 13;
+
+pub const LUA_OPEQ: c_int = 0;
+pub const LUA_OPLT: c_int = 1;
+pub const LUA_OPLE: c_int = 2;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Push functions (C -> stack)
+    //
+    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);
+    pub fn lua_pushlstring(L: *mut lua_State, s: *const c_char, len: usize) -> *const c_char;
+    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    pub fn lua_getglobal(L: *mut lua_State, name: *const c_char) -> c_int;
+    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_geti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int;
+
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int;
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_setglobal(L: *mut lua_State, name: *const c_char);
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_seti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    pub fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setuservalue(L: *mut lua_State, idx: c_int);
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    pub fn lua_callk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    );
+    pub fn lua_pcallk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        errfunc: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+        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;
+}
+
+#[inline(always)]
+pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
+    lua_callk(L, n, r, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
+    lua_pcallk(L, n, r, f, 0, None)
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yieldk(
+        L: *mut lua_State,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> 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;
+    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
+    lua_yieldk(L, n, 0, None)
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+pub const LUA_GCISRUNNING: c_int = 9;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Miscellaneous functions
+    //
+    #[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);
+    pub fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize;
+    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)
+//
+#[inline(always)]
+pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
+    (L as *mut c_char).sub(LUA_EXTRASPACE) as *mut c_void
+}
+
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, 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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+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_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= 0) as 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())
+}
+
+#[inline(always)]
+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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_insert(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_remove(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, -1);
+    lua_pop(L, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
+    lua_copy(L, -1, idx);
+    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
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+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-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    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_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_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;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub currentline: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub nups: c_uchar,
+    pub nparams: c_uchar,
+    pub isvararg: c_char,
+    pub istailcall: c_char,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: *mut c_void,
+}

mlua-sys/src/lua53/lualib.rs

@@ -0,0 +1,34 @@
+//! 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_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";
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    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/lua53/mod.rs

@@ -0,0 +1,11 @@
+//! Low level bindings to Lua 5.3.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;

mlua-sys/src/lua54/lauxlib.rs

@@ -0,0 +1,189 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
+
+// Extra error code for 'luaL_loadfilex'
+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";
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
+
+    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    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_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;
+    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
+
+    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
+
+    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
+    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+    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, ...) -> c_int;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
+    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
+        -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
+    luaL_loadfilex(L, f, ptr::null())
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaL_loadbufferx(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+        mode: *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;
+
+    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,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
+
+    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
+
+    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,
+    );
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+// TODO: luaL_newlibtable, luaL_newlib
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+// 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 {
+    luaL_loadbufferx(L, s, sz, n, ptr::null())
+}
+
+//
+// TODO: Generic Buffer Manipulation
+//

mlua-sys/src/lua54/lua.rs

@@ -0,0 +1,572 @@
+//! Contains definitions from `lua.h`.
+
+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;
+
+// Mark for precompiled code (`<esc>Lua`)
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+// Size of the Lua stack
+pub const LUAI_MAXSTACK: c_int = 1000000;
+
+// Size of a raw memory area associated with  a Lua state with very fast access.
+pub const LUA_EXTRASPACE: usize = mem::size_of::<*const ()>();
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -LUAI_MAXSTACK - 1000;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_REGISTRYINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRERR: c_int = 5;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+pub const LUA_NUMTYPES: c_int = 9;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+// Predefined values in the registry
+pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
+pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
+pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// A Lua integer, usually equivalent to `i64`
+pub type lua_Integer = i64;
+
+/// A Lua unsigned integer, usually equivalent to `u64`
+pub type lua_Unsigned = u64;
+
+/// Type for continuation-function contexts
+pub type lua_KContext = isize;
+
+/// Type for native C functions that can be passed to Lua
+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-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-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-unwind" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;
+
+/// Type for warning functions
+pub type lua_WarnFunction =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // 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;
+
+    pub fn lua_version(L: *mut lua_State) -> lua_Number;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_rotate(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
+    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;
+    #[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
+//
+pub const LUA_OPADD: c_int = 0;
+pub const LUA_OPSUB: c_int = 1;
+pub const LUA_OPMUL: c_int = 2;
+pub const LUA_OPMOD: c_int = 3;
+pub const LUA_OPPOW: c_int = 4;
+pub const LUA_OPDIV: c_int = 5;
+pub const LUA_OPIDIV: c_int = 6;
+pub const LUA_OPBAND: c_int = 7;
+pub const LUA_OPBOR: c_int = 8;
+pub const LUA_OPBXOR: c_int = 9;
+pub const LUA_OPSHL: c_int = 10;
+pub const LUA_OPSHR: c_int = 11;
+pub const LUA_OPUNM: c_int = 12;
+pub const LUA_OPBNOT: c_int = 13;
+
+pub const LUA_OPEQ: c_int = 0;
+pub const LUA_OPLT: c_int = 1;
+pub const LUA_OPLE: c_int = 2;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Push functions (C -> stack)
+    //
+    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);
+    pub fn lua_pushlstring(L: *mut lua_State, s: *const c_char, len: usize) -> *const c_char;
+    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    pub fn lua_getglobal(L: *mut lua_State, name: *const c_char) -> c_int;
+    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_geti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int;
+
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdatauv(L: *mut lua_State, sz: usize, nuvalue: c_int) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_setglobal(L: *mut lua_State, name: *const c_char);
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_seti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    pub fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    pub fn lua_callk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    );
+    pub fn lua_pcallk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        errfunc: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+        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;
+}
+
+#[inline(always)]
+pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
+    lua_callk(L, n, r, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
+    lua_pcallk(L, n, r, f, 0, None)
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yieldk(
+        L: *mut lua_State,
+        nresults: c_int,
+        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_status(L: *mut lua_State) -> c_int;
+    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
+    lua_yieldk(L, n, 0, None)
+}
+
+//
+// Warning-related functions
+//
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_setwarnf(L: *mut lua_State, f: Option<lua_WarnFunction>, ud: *mut c_void);
+    pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+pub const LUA_GCISRUNNING: c_int = 9;
+pub const LUA_GCGEN: c_int = 10;
+pub const LUA_GCINC: c_int = 11;
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
+}
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    //
+    // Miscellaneous functions
+    //
+    #[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);
+    pub fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize;
+    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);
+
+    pub fn lua_toclose(L: *mut lua_State, idx: c_int);
+    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)
+//
+#[inline(always)]
+pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
+    (L as *mut c_char).sub(LUA_EXTRASPACE) as *mut c_void
+}
+
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, 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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+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_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= 0) as 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())
+}
+
+#[inline(always)]
+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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_insert(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_remove(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, -1);
+    lua_pop(L, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
+    lua_copy(L, -1, idx);
+    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)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_getiuservalue(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_setiuservalue(L, idx, 1)
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+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-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    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_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_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;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub srclen: usize,
+    pub currentline: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub nups: c_uchar,
+    pub nparams: c_uchar,
+    pub isvararg: c_char,
+    pub istailcall: c_char,
+    pub ftransfer: c_ushort,
+    pub ntransfer: c_ushort,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: *mut c_void,
+}

mlua-sys/src/lua54/lualib.rs

@@ -0,0 +1,32 @@
+//! 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_UTF8LIBNAME: &str = "utf8";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+pub const LUA_LOADLIBNAME: &str = "package";
+
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    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_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/mod.rs

@@ -0,0 +1,9 @@
+//! Low level bindings to Lua 5.4.
+
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;

mlua-sys/src/luau/compat.rs

@@ -0,0 +1,521 @@
+//! MLua compatibility layer for Roblox 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 super::lauxlib::*;
+use super::lua::*;
+use super::luacode::*;
+
+unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
+    while a < b {
+        lua_pushvalue(L, a);
+        lua_pushvalue(L, b);
+        lua_replace(L, a);
+        lua_replace(L, b);
+        a += 1;
+        b -= 1;
+    }
+}
+
+const COMPAT53_LEVELS1: c_int = 12; // size of the first part of the stack
+const COMPAT53_LEVELS2: c_int = 10; // size of the second part of the stack
+
+unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) -> c_int {
+    if level == 0 || lua_istable(L, -1) == 0 {
+        return 0; // not found
+    }
+
+    lua_pushnil(L); // start 'next' loop
+    while lua_next(L, -2) != 0 {
+        // for each pair in table
+        if lua_type(L, -2) == LUA_TSTRING {
+            // ignore non-string keys
+            if lua_rawequal(L, objidx, -1) != 0 {
+                // found object?
+                lua_pop(L, 1); // remove value (but keep name)
+                return 1;
+            } else if compat53_findfield(L, objidx, level - 1) != 0 {
+                // try recursively
+                lua_remove(L, -2); // remove table (but keep name)
+                lua_pushliteral(L, ".");
+                lua_insert(L, -2); // place '.' between the two names
+                lua_concat(L, 3);
+                return 1;
+            }
+        }
+        lua_pop(L, 1); // remove value
+    }
+    0 // not found
+}
+
+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);
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
+    if compat53_findfield(L, top + 1, 2) != 0 {
+        lua_copy(L, -1, top + 1); // move name to proper place
+        lua_pop(L, 2); // remove pushed values
+        1
+    } else {
+        lua_settop(L, top); // remove function and global table
+        0
+    }
+}
+
+unsafe fn compat53_pushfuncname(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) {
+    if !(*ar).name.is_null() {
+        // is there a name?
+        lua_pushfstring(L, cstr!("function '%s'"), (*ar).name);
+    } else if compat53_pushglobalfuncname(L, level, ar) != 0 {
+        lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
+        lua_remove(L, -2); // remove name
+    } else {
+        lua_pushliteral(L, "?");
+    }
+}
+
+//
+// lua ported functions
+//
+
+pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
+    idx = lua_absindex(L, idx);
+    if n > 0 {
+        // Faster version
+        for _ in 0..n {
+            lua_insert(L, idx);
+        }
+        return;
+    }
+    let n_elems = lua_gettop(L) - idx + 1;
+    if n < 0 {
+        n += n_elems;
+    }
+    if n > 0 && n < n_elems {
+        luaL_checkstack(L, 2, cstr!("not enough stack slots available"));
+        n = n_elems - n;
+        compat53_reverse(L, idx, idx + n - 1);
+        compat53_reverse(L, idx + n, idx + n_elems - 1);
+        compat53_reverse(L, idx, idx + n_elems - 1);
+    }
+}
+
+#[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"));
+    lua_pushvalue(L, fromidx);
+    lua_replace(L, abs_to);
+}
+
+#[inline(always)]
+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 {
+            return 1;
+        }
+    }
+    0
+}
+
+#[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_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Integer {
+    let mut ok = 0;
+    let n = lua_tonumberx(L, i, &mut ok);
+    let n_int = n as lua_Integer;
+    if ok != 0 && (n - n_int as lua_Number).abs() < lua_Number::EPSILON {
+        if !isnum.is_null() {
+            *isnum = 1;
+        }
+        return n_int;
+    }
+    if !isnum.is_null() {
+        *isnum = 0;
+    }
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
+    lua_objlen(L, idx)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
+    if l == 0 {
+        lua_pushlstring_(L, cstr!(""), 0);
+    } else {
+        lua_pushlstring_(L, s, l);
+    }
+    lua_tostring(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char {
+    lua_pushstring_(L, s);
+    lua_tostring(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_int {
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_gettable(L, idx)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
+    lua_rawgeti_(L, idx, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
+    let abs_i = lua_absindex(L, idx);
+    lua_pushlightuserdata(L, p as *mut c_void);
+    lua_rawget(L, abs_i)
+}
+
+#[inline(always)]
+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");
+    if lua_rawget(L, LUA_REGISTRYINDEX) != LUA_TTABLE {
+        return LUA_TNIL;
+    }
+    lua_pushvalue(L, idx);
+    lua_rawget(L, -2);
+    lua_remove(L, -2);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_insert(L, -2);
+    lua_settable(L, idx);
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: 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"));
+    lua_pushlightuserdata(L, p as *mut c_void);
+    lua_insert(L, -2);
+    lua_rawset(L, abs_i);
+}
+
+#[inline(always)]
+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_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_setfield(L, -2, cstr!("__mode"));
+        lua_setmetatable(L, -2);
+        lua_pushvalue(L, -2);
+        lua_pushvalue(L, -2);
+        lua_rawset(L, LUA_REGISTRYINDEX);
+    }
+    lua_replace(L, -2);
+    lua_pushvalue(L, idx);
+    lua_pushvalue(L, -3);
+    lua_remove(L, -4);
+    lua_rawset(L, -3);
+    lua_pop(L, 1);
+}
+
+#[inline(always)]
+pub unsafe fn lua_len(L: *mut lua_State, idx: c_int) {
+    match lua_type(L, idx) {
+        LUA_TSTRING => {
+            lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
+        }
+        LUA_TTABLE => {
+            if luaL_callmeta(L, idx, cstr!("__len")) == 0 {
+                lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
+            }
+        }
+        LUA_TUSERDATA if luaL_callmeta(L, idx, cstr!("__len")) != 0 => {}
+        _ => {
+            luaL_error(
+                L,
+                cstr!("attempt to get length of a %s value"),
+                lua_typename(L, lua_type(L, idx)),
+            );
+        }
+    }
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
+}
+
+#[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
+}
+
+//
+// lauxlib ported functions
+//
+
+#[inline(always)]
+pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char) {
+    if lua_checkstack(L, sz + LUA_MINSTACK) == 0 {
+        if !msg.is_null() {
+            luaL_error(L, cstr!("stack overflow (%s)"), msg);
+        } else {
+            lua_pushliteral(L, "stack overflow");
+            lua_error(L);
+        }
+    }
+}
+
+#[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 {
+        lua_type(L, -1)
+    } else {
+        LUA_TNIL
+    }
+}
+
+#[inline(always)]
+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!("__type"));
+        1
+    } else {
+        0
+    }
+}
+
+pub unsafe fn luaL_loadbufferx(
+    L: *mut lua_State,
+    data: *const c_char,
+    mut size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+) -> c_int {
+    extern "C" {
+        fn free(p: *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,
+            );
+            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,
+            );
+            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;
+        }
+    } else if luau_load(L, name, data, size, 0) != 0 {
+        return LUA_ERRSYNTAX;
+    }
+    LUA_OK
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadbuffer(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+) -> c_int {
+    luaL_loadbufferx(L, data, size, name, ptr::null())
+}
+
+#[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"));
+    lua_len(L, idx);
+    let res = lua_tointegerx(L, -1, &mut isnum);
+    lua_pop(L, 1);
+    if isnum == 0 {
+        luaL_error(L, cstr!("object length is not an integer"));
+    }
+    res
+}
+
+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);
+    let mark = if numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2 {
+        COMPAT53_LEVELS1
+    } else {
+        0
+    };
+
+    if !msg.is_null() {
+        lua_pushfstring(L, cstr!("%s\n"), msg);
+    }
+    lua_pushliteral(L, "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 '...'
+            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);
+            if ar.currentline > 0 {
+                lua_pushfstring(L, cstr!("%d:"), ar.currentline);
+            }
+            lua_pushliteral(L, " in ");
+            compat53_pushfuncname(L, level, &mut ar);
+            lua_concat(L, lua_gettop(L) - top);
+        }
+        level += 1;
+    }
+    lua_concat(L, lua_gettop(L) - top);
+}
+
+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 {
+        match lua_type(L, idx) {
+            LUA_TNIL => {
+                lua_pushliteral(L, "nil");
+            }
+            LUA_TSTRING | LUA_TNUMBER => {
+                lua_pushvalue(L, idx);
+            }
+            LUA_TBOOLEAN => {
+                if lua_toboolean(L, idx) == 0 {
+                    lua_pushliteral(L, "false");
+                } else {
+                    lua_pushliteral(L, "true");
+                }
+            }
+            t => {
+                let tt = luaL_getmetafield(L, idx, cstr!("__type"));
+                let name = if tt == LUA_TSTRING {
+                    lua_tostring(L, -1)
+                } else {
+                    lua_typename(L, t)
+                };
+                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
+                if tt != LUA_TNIL {
+                    lua_replace(L, -2); // remove '__type'
+                }
+            }
+        };
+    } else if lua_isstring(L, -1) == 0 {
+        luaL_error(L, cstr!("'__tostring' must return a string"));
+    }
+    lua_tolstring(L, -1, len)
+}
+
+#[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_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"));
+    lua_pushstring_(L, fname);
+    if lua_gettable(L, abs_i) == LUA_TTABLE {
+        return 1;
+    }
+    lua_pop(L, 1);
+    lua_newtable(L);
+    lua_pushstring_(L, fname);
+    lua_pushvalue(L, -2);
+    lua_settable(L, abs_i);
+    0
+}
+
+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 {
+        lua_pop(L, 1);
+        lua_pushcfunction(L, openf);
+        lua_pushstring(L, modname);
+        lua_call(L, 1, 1);
+        lua_pushvalue(L, -1);
+        lua_setfield(L, -3, modname);
+    }
+    if glb != 0 {
+        lua_pushvalue(L, -1);
+        lua_setglobal(L, modname);
+    } else {
+        lua_pushnil(L);
+        lua_setglobal(L, modname);
+    }
+    lua_replace(L, -2);
+}

mlua-sys/src/luau/lauxlib.rs

@@ -0,0 +1,201 @@
+//! Contains definitions from `lualib.h`.
+
+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,
+};
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+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;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    #[link_name = "luaL_typeerrorL"]
+    pub fn luaL_typeerror(L: *mut lua_State, narg: c_int, tname: *const c_char) -> !;
+    #[link_name = "luaL_argerrorL"]
+    pub fn luaL_argerror(L: *mut lua_State, narg: c_int, extramsg: *const c_char) -> !;
+    pub fn luaL_checklstring(L: *mut lua_State, narg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        l: *mut usize,
+    ) -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, narg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, narg: c_int, def: lua_Number) -> lua_Number;
+
+    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;
+    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;
+
+    pub fn luaL_checkvector(L: *mut lua_State, narg: c_int) -> *const c_float;
+    pub fn luaL_optvector(L: *mut lua_State, narg: c_int, def: *const c_float) -> *const c_float;
+
+    #[link_name = "luaL_checkstack"]
+    pub fn luaL_checkstack_(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, narg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, narg: c_int);
+
+    #[link_name = "luaL_newmetatable"]
+    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"]
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    #[link_name = "luaL_tolstring"]
+    pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    // TODO: luaL_findtable
+
+    pub fn luaL_typename(L: *mut lua_State, idx: c_int) -> *const c_char;
+
+    // sandbox libraries and globals
+    #[link_name = "luaL_sandbox"]
+    pub fn luaL_sandbox_(L: *mut lua_State);
+    pub fn luaL_sandboxthread(L: *mut lua_State);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_argexpected(L: *mut lua_State, cond: c_int, arg: c_int, tname: *const c_char) {
+    if cond == 0 {
+        luaL_typeerror(L, arg, tname);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+// TODO: luaL_opt
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) -> c_int {
+    lua::lua_getfield(L, LUA_REGISTRYINDEX, n)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int {
+    assert_eq!(t, LUA_REGISTRYINDEX);
+    let r = lua::lua_ref(L, -1);
+    lua::lua_pop(L, 1);
+    r
+}
+
+#[inline(always)]
+pub unsafe fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int) {
+    assert_eq!(t, LUA_REGISTRYINDEX);
+    lua::lua_unref(L, r#ref)
+}
+
+pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
+    use super::lua::*;
+
+    // set all libraries to read-only
+    lua_pushnil(L);
+    while lua_next(L, LUA_GLOBALSINDEX) != 0 {
+        if lua_istable(L, -1) != 0 {
+            lua_setreadonly(L, -1, enabled);
+        }
+        lua_pop(L, 1);
+    }
+
+    // set all builtin metatables to read-only
+    lua_pushliteral(L, "");
+    lua_getmetatable(L, -1);
+    lua_setreadonly(L, -1, enabled);
+    lua_pop(L, 2);
+
+    // set globals to readonly and activate safeenv since the env is immutable
+    lua_setreadonly(L, LUA_GLOBALSINDEX, enabled);
+    lua_setsafeenv(L, LUA_GLOBALSINDEX, enabled);
+}
+
+//
+// Generic Buffer Manipulation
+//
+
+/// Buffer size used for on-stack string operations. This limit depends on native stack size.
+pub const LUA_BUFFERSIZE: usize = 512;
+
+#[repr(C)]
+pub struct luaL_Strbuf {
+    p: *mut c_char,   // current position in buffer
+    end: *mut c_char, // end of the current buffer
+    L: *mut lua_State,
+    storage: *mut c_void, // TString
+    buffer: [c_char; LUA_BUFFERSIZE],
+}
+
+// For compatibility
+pub type luaL_Buffer = luaL_Strbuf;
+
+extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Strbuf);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_prepbuffsize(B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Strbuf, s: *const c_char, l: usize);
+    pub fn luaL_addvalue(B: *mut luaL_Strbuf);
+    pub fn luaL_addvalueany(B: *mut luaL_Strbuf, idx: c_int);
+    pub fn luaL_pushresult(B: *mut luaL_Strbuf);
+    pub fn luaL_pushresultsize(B: *mut luaL_Strbuf, size: usize);
+}
+
+pub unsafe fn luaL_addchar(B: *mut luaL_Strbuf, c: c_char) {
+    if (*B).p >= (*B).end {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).p = c;
+    (*B).p = (*B).p.add(1);
+}
+
+pub unsafe fn luaL_addstring(B: *mut luaL_Strbuf, s: *const c_char) {
+    // Calculate length of s
+    let mut len = 0;
+    while *s.add(len) != 0 {
+        len += 1;
+    }
+    luaL_addlstring(B, s, len);
+}

mlua-sys/src/luau/lua.rs

@@ -0,0 +1,554 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_double, c_float, c_int, c_uint, c_void};
+use std::{mem, ptr};
+
+// 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
+const LUA_UTAG_LIMIT: c_int = 128;
+
+// Number of valid Lua lightuserdata tags
+const LUA_LUTAG_LIMIT: c_int = 128;
+
+//
+// Pseudo-indices
+//
+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
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRERR: c_int = 5;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TVECTOR: c_int = 4;
+
+pub const LUA_TSTRING: c_int = 5;
+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;
+
+/// 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 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-unwind" fn(L: *mut lua_State) -> c_int;
+pub type lua_Continuation = unsafe extern "C-unwind" fn(L: *mut lua_State, status: c_int) -> c_int;
+
+/// Type for userdata destructor functions.
+pub type lua_Udestructor = unsafe extern "C-unwind" fn(*mut c_void);
+pub type lua_Destructor = unsafe extern "C-unwind" fn(L: *mut lua_State, *mut c_void);
+
+/// Type for memory-allocation functions.
+pub type lua_Alloc = unsafe extern "C-unwind" fn(
+    ud: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void;
+
+/// Returns Luau release version (eg. `0.xxx`).
+pub const fn luau_version() -> Option<&'static str> {
+    option_env!("LUAU_VERSION")
+}
+
+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;
+    pub fn lua_mainthread(L: *mut lua_State) -> *mut lua_State;
+    pub fn lua_resetthread(L: *mut lua_State);
+    pub fn lua_isthreadreset(L: *mut lua_State) -> c_int;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_remove(L: *mut lua_State, idx: c_int);
+    pub fn lua_insert(L: *mut lua_State, idx: c_int);
+    pub fn lua_replace(L: *mut lua_State, idx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+    pub fn lua_rawcheckstack(L: *mut lua_State, sz: c_int);
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+    pub fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isLfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_equal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_lessthan(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+
+    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_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;
+    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn lua_tostringatom(L: *mut lua_State, idx: c_int, atom: *mut c_int) -> *const c_char;
+    pub fn lua_namecallatom(L: *mut lua_State, atom: *mut c_int) -> *const c_char;
+    pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
+    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_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;
+
+    //
+    // Push functions (C -> stack)
+    //
+    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);
+    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"]
+    pub fn lua_pushstring_(L: *mut lua_State, s: *const c_char);
+    // lua_pushvfstring
+    #[link_name = "lua_pushfstringL"]
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosurek(
+        L: *mut lua_State,
+        f: lua_CFunction,
+        debugname: *const c_char,
+        nup: c_int,
+        cont: Option<lua_Continuation>,
+    );
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    pub fn lua_pushlightuserdatatagged(L: *mut lua_State, p: *mut c_void, tag: c_int);
+    pub fn lua_newuserdatatagged(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
+    pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Udestructor) -> *mut c_void;
+
+    pub fn lua_newbuffer(L: *mut lua_State, sz: usize) -> *mut c_void;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_rawgetfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
+    #[link_name = "lua_rawgeti"]
+    pub fn lua_rawgeti_(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+
+    pub fn lua_setreadonly(L: *mut lua_State, idx: c_int, enabled: c_int);
+    pub fn lua_getreadonly(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_setsafeenv(L: *mut lua_State, idx: c_int, enabled: c_int);
+
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getfenv(L: *mut lua_State, idx: c_int);
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawseti"]
+    pub fn lua_rawseti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setfenv(L: *mut lua_State, idx: c_int) -> c_int;
+
+    //
+    // `load' and `call' functions (load and run Luau bytecode)
+    //
+    pub fn luau_load(
+        L: *mut lua_State,
+        chunkname: *const c_char,
+        data: *const c_char,
+        size: usize,
+        env: c_int,
+    ) -> 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;
+
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yield(L: *mut lua_State, nresults: c_int) -> c_int;
+    pub fn lua_break(L: *mut lua_State) -> 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_resumeerror(L: *mut lua_State, from: *mut lua_State) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
+    pub fn lua_getthreaddata(L: *mut lua_State) -> *mut c_void;
+    pub fn lua_setthreaddata(L: *mut lua_State, data: *mut c_void);
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCISRUNNING: c_int = 5;
+pub const LUA_GCSTEP: c_int = 6;
+pub const LUA_GCSETGOAL: c_int = 7;
+pub const LUA_GCSETSTEPMUL: c_int = 8;
+pub const LUA_GCSETSTEPSIZE: c_int = 9;
+
+extern "C-unwind" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+//
+// Memory statistics
+//
+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;
+}
+
+//
+// Miscellaneous functions
+//
+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_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_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;
+}
+
+//
+// Reference system, can be used to pin objects
+//
+pub const LUA_NOREF: c_int = -1;
+pub const LUA_REFNIL: c_int = 0;
+
+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);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, 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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tounsigned(L: *mut lua_State, i: c_int) -> lua_Unsigned {
+    lua_tounsignedx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
+    lua_newuserdatatagged(L, sz, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newuserdata_t<T>(L: *mut lua_State) -> *mut T {
+    unsafe extern "C-unwind" fn destructor<T>(ud: *mut c_void) {
+        ptr::drop_in_place(ud as *mut T);
+    }
+
+    lua_newuserdatadtor(L, mem::size_of::<T>(), destructor::<T>) as *mut T
+}
+
+// TODO: lua_strlen
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isvector(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TVECTOR) as c_int
+}
+
+#[inline(always)]
+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
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= LUA_TNIL) as 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())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosurek(L, f, ptr::null(), 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunctiond(L: *mut lua_State, f: lua_CFunction, debugname: *const c_char) {
+    lua_pushcclosurek(L, f, debugname, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, nup: c_int) {
+    lua_pushcclosurek(L, f, ptr::null(), nup, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcclosured(
+    L: *mut lua_State,
+    f: lua_CFunction,
+    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)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
+    lua_getfield(L, LUA_GLOBALSINDEX, var)
+}
+
+#[inline(always)]
+pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua_tolstring(L, i, ptr::null_mut())
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 256;
+
+/// Type for functions to be called on debug events.
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+pub type lua_Coverage = unsafe extern "C-unwind" fn(
+    context: *mut c_void,
+    function: *const c_char,
+    linedefined: c_int,
+    depth: c_int,
+    hits: *const c_int,
+    size: usize,
+);
+
+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_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;
+    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_singlestep(L: *mut lua_State, enabled: c_int);
+    pub fn lua_breakpoint(
+        L: *mut lua_State,
+        funcindex: c_int,
+        line: c_int,
+        enabled: c_int,
+    ) -> c_int;
+
+    pub fn lua_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;
+}
+
+#[repr(C)]
+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 userdata: *mut c_void,
+    pub ssbuf: [c_char; LUA_IDSIZE],
+}
+
+//
+// Callbacks that can be used to reconfigure behavior of the VM dynamically.
+// These are shared between all coroutines.
+//
+
+#[repr(C)]
+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-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-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-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-unwind" fn(s: *const c_char, l: usize) -> i16>,
+
+    /// gets called when BREAK instruction is encountered
+    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-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-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    /// gets called when protected call results in an error
+    pub debugprotectederror: Option<unsafe extern "C-unwind" fn(L: *mut lua_State)>,
+}
+
+extern "C" {
+    pub fn lua_callbacks(L: *mut lua_State) -> *mut lua_Callbacks;
+}

mlua-sys/src/luau/luacode.rs

@@ -0,0 +1,42 @@
+//! 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 vectorType: *const c_char,
+    pub mutableGlobals: *const *const c_char,
+}
+
+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;
+}
+
+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,
+    );
+    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;
+
+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,31 @@
+//! 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_BUFFERLIBNAME: &str = "buffer";
+pub const LUA_UTF8LIBNAME: &str = "utf8";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+
+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;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}

mlua-sys/src/luau/mod.rs

@@ -0,0 +1,15 @@
+//! Low level bindings to Luau.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use luacode::*;
+pub use luacodegen::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod luacode;
+pub mod luacodegen;
+pub mod lualib;

mlua-sys/src/macros.rs

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

mlua_derive/src/from_lua.rs

@@ -0,0 +1,33 @@
+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,
+                message: None,
+            }),
+          }
+        }
+      }
+    }
+    .into()
+}

mlua_derive/src/lib.rs

@@ -1,39 +1,72 @@
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
-use quote::quote_spanned;
-use syn::{parse_macro_input, spanned::Spanned, AttributeArgs, Error, ItemFn};
+use quote::quote;
+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, quote::quote,
+    proc_macro_error::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 item = parse_macro_input!(item as ItemFn);
-
-    if !args.is_empty() {
-        let err = Error::new(Span::call_site(), "the number of arguments must be zero")
-            .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 span = item.span();
-    let item_name = item.sig.ident.clone();
-    let ext_entrypoint_name = Ident::new(&format!("luaopen_{}", item.sig.ident), 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_spanned! { span =>
-        mlua::require_module_feature!();
+    let wrapped = quote! {
+        ::mlua::require_module_feature!();
+
+        #func
 
         #[no_mangle]
-        unsafe extern "C" fn #ext_entrypoint_name(state: *mut mlua::lua_State) -> std::os::raw::c_int {
-            #item
-
-            mlua::Lua::init_from_ptr(state)
-                .entrypoint1(#item_name)
-                .unwrap()
+        unsafe extern "C-unwind" fn #ext_entrypoint_name(state: *mut ::mlua::lua_State) -> ::std::os::raw::c_int {
+            let lua = ::mlua::Lua::init_from_ptr(state);
+            #skip_memory_check
+            lua.entrypoint1(state, #func_name)
         }
     };
 
@@ -62,39 +95,39 @@ 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<'lua, F: FnOnce(&'lua Lua) -> Result<Table<'lua>>>(Cell<Option<F>>, PhantomData<&'lua ()>);
 
-        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<'lua, F> AsChunk<'lua, 'static> for InnerChunk<'lua, F>
         where
-            F: FnOnce(&'lua Lua) -> Result<Value<'lua>>,
+            F: FnOnce(&'lua Lua) -> Result<Table<'lua>>,
         {
-            fn source(&self) -> &[u8] {
-                (#source).as_bytes()
-            }
-
-            fn env(&self, lua: &'lua Lua) -> Option<Result<Value<'lua>>> {
+            fn environment(&self, lua: &'lua Lua) -> Result<Option<Table<'lua>>> {
                 if #caps_len > 0 {
-                    if let Ok(mut make_env) = self.0.lock() {
-                        if let Some(make_env) = make_env.take() {
-                            return Some(make_env(lua));
-                        }
+                    if let Some(make_env) = self.0.take() {
+                        return make_env(lua).map(Some);
                     }
                 }
-                None
+                Ok(None)
             }
 
             fn mode(&self) -> Option<ChunkMode> {
                 Some(ChunkMode::Text)
             }
+
+            fn source(self) -> IoResult<Cow<'static, [u8]>> {
+                Ok(Cow::Borrowed((#source).as_bytes()))
+            }
         }
 
-        let make_env = annotate(move |lua: &Lua| -> Result<Value> {
+        fn annotate<'a, F: FnOnce(&'a Lua) -> Result<Table<'a>>>(f: F) -> F { f }
+
+        let make_env = annotate(move |lua: &Lua| -> Result<Table> {
             let globals = lua.globals();
             let env = lua.create_table()?;
             let meta = lua.create_table()?;
@@ -105,16 +138,24 @@ pub fn chunk(input: TokenStream) -> TokenStream {
             #(#caps)*
 
             env.set_metatable(Some(meta));
-            Ok(Value::Table(env))
+            Ok(env)
         });
 
-        &InnerChunk(Mutex::new(Some(make_env)), PhantomData)
+        InnerChunk(Cell::new(Some(make_env)), PhantomData)
     }};
 
     wrapped_code.into()
 }
 
+#[cfg(feature = "macros")]
+#[proc_macro_derive(FromLua)]
+pub fn from_lua(input: TokenStream) -> TokenStream {
+    from_lua::from_lua(input)
+}
+
 #[cfg(feature = "macros")]
 mod chunk;
 #[cfg(feature = "macros")]
+mod from_lua;
+#[cfg(feature = "macros")]
 mod token;

mlua_derive/src/token.rs

@@ -59,7 +59,7 @@ fn parse_pos(span: &Span) -> Option<(usize, usize)> {
 
     static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"bytes\(([0-9]+)\.\.([0-9]+)\)").unwrap());
 
-    match RE.captures(&format!("{:?}", span)) {
+    match RE.captures(&format!("{span:?}")) {
         Some(caps) => match (caps.get(1), caps.get(2)) {
             (Some(start), Some(end)) => Some((
                 match start.as_str().parse() {
@@ -175,8 +175,7 @@ impl Tokens {
     pub(crate) fn retokenize(tt: TokenStream) -> Tokens {
         Tokens(
             tt.into_iter()
-                .map(Tokens::from)
-                .flatten()
+                .flat_map(Tokens::from)
                 .peekable()
                 .batching(|iter| {
                     // Find variable tokens
@@ -217,7 +216,7 @@ impl From<TokenTree> for Tokens {
 
                 vec![Token::new_delim(b, tt.clone(), true)]
                     .into_iter()
-                    .chain(g.stream().into_iter().map(Tokens::from).flatten())
+                    .chain(g.stream().into_iter().flat_map(Tokens::from))
                     .chain(vec![Token::new_delim(e, tt, false)])
                     .collect()
             }

src/chunk.rs

@@ -0,0 +1,527 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::ffi::CString;
+use std::io::Result as IoResult;
+use std::path::{Path, PathBuf};
+use std::string::String as StdString;
+
+use crate::error::{Error, ErrorContext, Result};
+use crate::function::Function;
+use crate::lua::Lua;
+use crate::table::Table;
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti};
+
+/// Trait for types [loadable by Lua] and convertible to a [`Chunk`]
+///
+/// [loadable by Lua]: https://www.lua.org/manual/5.4/manual.html#3.3.2
+/// [`Chunk`]: crate::Chunk
+pub trait AsChunk<'lua, 'a> {
+    /// Returns optional chunk name
+    fn name(&self) -> Option<StdString> {
+        None
+    }
+
+    /// Returns optional chunk [environment]
+    ///
+    /// [environment]: https://www.lua.org/manual/5.4/manual.html#2.2
+    fn environment(&self, lua: &'lua Lua) -> Result<Option<Table<'lua>>> {
+        let _lua = lua; // suppress warning
+        Ok(None)
+    }
+
+    /// Returns optional chunk mode (text or binary)
+    fn mode(&self) -> Option<ChunkMode> {
+        None
+    }
+
+    /// Returns chunk data (can be text or binary)
+    fn source(self) -> IoResult<Cow<'a, [u8]>>;
+}
+
+impl<'a> AsChunk<'_, 'a> for &'a str {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self.as_ref()))
+    }
+}
+
+impl AsChunk<'_, 'static> for StdString {
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        Ok(Cow::Owned(self.into_bytes()))
+    }
+}
+
+impl<'a> AsChunk<'_, 'a> for &'a StdString {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self.as_bytes()))
+    }
+}
+
+impl<'a> AsChunk<'_, 'a> for &'a [u8] {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self))
+    }
+}
+
+impl AsChunk<'_, 'static> for Vec<u8> {
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        Ok(Cow::Owned(self))
+    }
+}
+
+impl<'a> AsChunk<'_, 'a> for &'a Vec<u8> {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self.as_ref()))
+    }
+}
+
+impl AsChunk<'_, 'static> for &Path {
+    fn name(&self) -> Option<StdString> {
+        Some(format!("@{}", self.display()))
+    }
+
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        std::fs::read(self).map(Cow::Owned)
+    }
+}
+
+impl AsChunk<'_, 'static> for PathBuf {
+    fn name(&self) -> Option<StdString> {
+        Some(format!("@{}", self.display()))
+    }
+
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        std::fs::read(self).map(Cow::Owned)
+    }
+}
+
+/// 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) name: StdString,
+    pub(crate) env: Result<Option<Table<'lua>>>,
+    pub(crate) mode: Option<ChunkMode>,
+    pub(crate) source: IoResult<Cow<'a, [u8]>>,
+    #[cfg(feature = "luau")]
+    pub(crate) compiler: Option<Compiler>,
+}
+
+/// Represents chunk mode (text or binary).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ChunkMode {
+    Text,
+    Binary,
+}
+
+/// Luau compiler
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Debug)]
+pub struct Compiler {
+    optimization_level: u8,
+    debug_level: u8,
+    coverage_level: u8,
+    vector_lib: Option<String>,
+    vector_ctor: Option<String>,
+    vector_type: Option<String>,
+    mutable_globals: Vec<String>,
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Default for Compiler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Compiler {
+    /// Creates Luau compiler instance with default options
+    pub const fn new() -> Self {
+        // Defaults are taken from luacode.h
+        Compiler {
+            optimization_level: 1,
+            debug_level: 1,
+            coverage_level: 0,
+            vector_lib: None,
+            vector_ctor: None,
+            vector_type: None,
+            mutable_globals: Vec::new(),
+        }
+    }
+
+    /// Sets Luau compiler optimization level.
+    ///
+    /// Possible values:
+    /// * 0 - no optimization
+    /// * 1 - baseline optimization level that doesn't prevent debuggability (default)
+    /// * 2 - includes optimizations that harm debuggability such as inlining
+    #[must_use]
+    pub const fn set_optimization_level(mut self, level: u8) -> Self {
+        self.optimization_level = level;
+        self
+    }
+
+    /// Sets Luau compiler debug level.
+    ///
+    /// Possible values:
+    /// * 0 - no debugging support
+    /// * 1 - line info & function names only; sufficient for backtraces (default)
+    /// * 2 - full debug info with local & upvalue names; necessary for debugger
+    #[must_use]
+    pub const fn set_debug_level(mut self, level: u8) -> Self {
+        self.debug_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)
+    #[must_use]
+    pub const fn set_coverage_level(mut self, level: u8) -> Self {
+        self.coverage_level = level;
+        self
+    }
+
+    #[doc(hidden)]
+    #[must_use]
+    pub fn set_vector_lib(mut self, lib: impl Into<String>) -> Self {
+        self.vector_lib = Some(lib.into());
+        self
+    }
+
+    #[doc(hidden)]
+    #[must_use]
+    pub fn set_vector_ctor(mut self, ctor: impl Into<String>) -> Self {
+        self.vector_ctor = Some(ctor.into());
+        self
+    }
+
+    #[doc(hidden)]
+    #[must_use]
+    pub fn set_vector_type(mut self, r#type: impl Into<String>) -> Self {
+        self.vector_type = Some(r#type.into());
+        self
+    }
+
+    /// Sets a list of globals that are mutable.
+    ///
+    /// It disables the import optimization for fields accessed through these.
+    #[must_use]
+    pub fn set_mutable_globals(mut self, globals: Vec<String>) -> Self {
+        self.mutable_globals = globals;
+        self
+    }
+
+    /// Compiles the `source` into bytecode.
+    pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
+        use std::os::raw::c_int;
+        use std::ptr;
+
+        let vector_lib = self.vector_lib.clone();
+        let vector_lib = vector_lib.and_then(|lib| CString::new(lib).ok());
+        let vector_lib = vector_lib.as_ref();
+        let vector_ctor = self.vector_ctor.clone();
+        let vector_ctor = vector_ctor.and_then(|ctor| CString::new(ctor).ok());
+        let vector_ctor = vector_ctor.as_ref();
+        let 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();
+        if !mutable_globals.is_empty() {
+            mutable_globals.push(ptr::null());
+            mutable_globals_ptr = mutable_globals.as_ptr();
+        }
+
+        unsafe {
+            let options = ffi::lua_CompileOptions {
+                optimizationLevel: self.optimization_level as c_int,
+                debugLevel: self.debug_level as c_int,
+                coverageLevel: self.coverage_level as c_int,
+                vectorLib: vector_lib.map_or(ptr::null(), |s| s.as_ptr()),
+                vectorCtor: vector_ctor.map_or(ptr::null(), |s| s.as_ptr()),
+                vectorType: vector_type.map_or(ptr::null(), |s| s.as_ptr()),
+                mutableGlobals: mutable_globals_ptr,
+            };
+            ffi::luau_compile(source.as_ref(), options)
+        }
+    }
+}
+
+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 Into<String>) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    /// 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.
+    ///
+    /// All global variables (including the standard library!) are looked up in `_ENV`, so it may be
+    /// necessary to populate the environment in order for scripts using custom environments to be
+    /// useful.
+    pub fn set_environment<V: IntoLua<'lua>>(mut self, env: V) -> Self {
+        self.env = env
+            .into_lua(self.lua)
+            .and_then(|val| self.lua.unpack(val))
+            .context("bad environment value");
+        self
+    }
+
+    /// Sets whether the chunk is text or binary (autodetected by default).
+    ///
+    /// Be aware, Lua does not check the consistency of the code inside binary chunks.
+    /// Running maliciously crafted bytecode can crash the interpreter.
+    pub fn set_mode(mut self, mode: ChunkMode) -> Self {
+        self.mode = Some(mode);
+        self
+    }
+
+    /// 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 {
+        self.compiler = Some(compiler);
+        self
+    }
+
+    /// Execute this chunk of code.
+    ///
+    /// This is equivalent to calling the chunk function with no arguments and no return values.
+    pub fn exec(self) -> Result<()> {
+        self.call(())?;
+        Ok(())
+    }
+
+    /// Asynchronously execute this chunk of code.
+    ///
+    /// See [`exec`] for more details.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`exec`]: #method.exec
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub async fn exec_async(self) -> Result<()> {
+        self.call_async(()).await
+    }
+
+    /// Evaluate the chunk as either an expression or block.
+    ///
+    /// 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> {
+        // 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
+        // actual lua repl does.
+        if self.detect_mode() == ChunkMode::Binary {
+            self.call(())
+        } else if let Ok(function) = self.to_expression() {
+            function.call(())
+        } else {
+            self.call(())
+        }
+    }
+
+    /// Asynchronously evaluate the chunk as either an expression or block.
+    ///
+    /// See [`eval`] for more details.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`eval`]: #method.eval
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub async fn eval_async<R>(self) -> Result<R>
+    where
+        R: FromLuaMulti<'lua> + 'lua,
+    {
+        if self.detect_mode() == ChunkMode::Binary {
+            self.call_async(()).await
+        } else if let Ok(function) = self.to_expression() {
+            function.call_async(()).await
+        } else {
+            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: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(self, args: A) -> Result<R> {
+        self.into_function()?.call(args)
+    }
+
+    /// Load the chunk function and asynchronously call it with the given arguments.
+    ///
+    /// See [`call`] for more details.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`call`]: #method.call
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub async fn call_async<A, R>(self, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'lua,
+    {
+        self.into_function()?.call_async(args).await
+    }
+
+    /// 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>> {
+        #[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(self.name)?;
+        self.lua
+            .load_chunk(Some(&name), self.env?, self.mode, self.source?.as_ref())
+    }
+
+    /// Compiles the chunk and changes mode to binary.
+    ///
+    /// It does nothing if the chunk is already binary.
+    fn compile(&mut self) {
+        if let Ok(ref source) = self.source {
+            if self.detect_mode() == ChunkMode::Text {
+                #[cfg(feature = "luau")]
+                {
+                    let data = self
+                        .compiler
+                        .get_or_insert_with(Default::default)
+                        .compile(source);
+                    self.source = Ok(Cow::Owned(data));
+                    self.mode = Some(ChunkMode::Binary);
+                }
+                #[cfg(not(feature = "luau"))]
+                if let Ok(func) = self.lua.load_chunk(None, None, None, source.as_ref()) {
+                    let data = func.dump(false);
+                    self.source = Ok(Cow::Owned(data));
+                    self.mode = Some(ChunkMode::Binary);
+                }
+            }
+        }
+    }
+
+    /// Fetches compiled bytecode of this chunk from the cache.
+    ///
+    /// If not found, compiles the source code and stores it on the cache.
+    pub(crate) fn try_cache(mut self) -> Self {
+        struct ChunksCache(HashMap<Vec<u8>, Vec<u8>>);
+
+        // Try to fetch compiled chunk from cache
+        let mut text_source = None;
+        if let Ok(ref source) = self.source {
+            if self.detect_mode() == ChunkMode::Text {
+                if let Some(cache) = self.lua.app_data_ref::<ChunksCache>() {
+                    if let Some(data) = cache.0.get(source.as_ref()) {
+                        self.source = Ok(Cow::Owned(data.clone()));
+                        self.mode = Some(ChunkMode::Binary);
+                        return self;
+                    }
+                }
+                text_source = Some(source.as_ref().to_vec());
+            }
+        }
+
+        // Compile and cache the chunk
+        if let Some(text_source) = text_source {
+            self.compile();
+            if let Ok(ref binary_source) = self.source {
+                if self.detect_mode() == ChunkMode::Binary {
+                    if let Some(mut cache) = self.lua.app_data_mut::<ChunksCache>() {
+                        cache.0.insert(text_source, binary_source.as_ref().to_vec());
+                    } else {
+                        let mut cache = ChunksCache(HashMap::new());
+                        cache.0.insert(text_source, binary_source.as_ref().to_vec());
+                        let _ = self.lua.try_set_app_data(cache);
+                    }
+                }
+            }
+        }
+
+        self
+    }
+
+    fn to_expression(&self) -> Result<Function<'lua>> {
+        // We assume that mode is Text
+        let source = self.source.as_ref();
+        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")]
+        let source = self
+            .compiler
+            .as_ref()
+            .map(|c| c.compile(&source))
+            .unwrap_or(source);
+
+        let name = Self::convert_name(self.name.clone())?;
+        self.lua
+            .load_chunk(Some(&name), self.env.clone()?, 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
+        }
+    }
+
+    fn convert_name(name: String) -> Result<CString> {
+        CString::new(name).map_err(|err| Error::runtime(format!("invalid name: {err}")))
+    }
+
+    fn expression_source(source: &[u8]) -> Vec<u8> {
+        let mut buf = Vec::with_capacity(b"return ".len() + source.len());
+        buf.extend(b"return ");
+        buf.extend(source);
+        buf
+    }
+}

src/error.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as IoError;
@@ -9,6 +7,8 @@ use std::str::Utf8Error;
 use std::string::String as StdString;
 use std::sync::Arc;
 
+use crate::private::Sealed;
+
 /// Error type returned by `mlua` methods.
 #[derive(Debug, Clone)]
 #[non_exhaustive]
@@ -37,7 +37,8 @@ pub enum Error {
     /// Lua garbage collector error, aka `LUA_ERRGCMM`.
     ///
     /// The Lua VM returns this error when there is an error running a `__gc` metamethod.
-    #[cfg(any(feature = "lua53", feature = "lua52"))]
+    #[cfg(any(feature = "lua53", feature = "lua52", doc))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua53", feature = "lua52"))))]
     GarbageCollectorError(StdString),
     /// Potentially unsafe action in safe mode.
     SafetyError(StdString),
@@ -46,11 +47,6 @@ pub enum Error {
     /// This error can only happen when Lua state was not created by us and does not have the
     /// custom allocator attached.
     MemoryLimitNotAvailable,
-    /// Main thread is not available.
-    ///
-    /// This error can only happen in Lua5.1/LuaJIT module mode, when module loaded within a coroutine.
-    /// These Lua versions does not have `LUA_RIDX_MAINTHREAD` registry key.
-    MainThreadNotAvailable,
     /// A mutable callback has triggered Lua code that has called the same mutable callback again.
     ///
     /// This is an error because a mutable callback can only be borrowed mutably once.
@@ -68,8 +64,22 @@ pub enum Error {
     /// called with a huge number of arguments, or a rust callback returns a huge number of return
     /// values.
     StackError,
-    /// Too many arguments to `Function::bind`
+    /// Too many arguments to `Function::bind`.
     BindError,
+    /// Bad argument received from Lua (usually when calling a function).
+    ///
+    /// 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.
@@ -96,8 +106,8 @@ pub enum Error {
     /// [`Thread::status`] can be used to check if the coroutine can be resumed without causing this
     /// error.
     ///
-    /// [`Thread::resume`]: struct.Thread.html#method.resume
-    /// [`Thread::status`]: struct.Thread.html#method.status
+    /// [`Thread::resume`]: crate::Thread::resume
+    /// [`Thread::status`]: crate::Thread::status
     CoroutineInactive,
     /// An [`AnyUserData`] is not the expected type in a borrow.
     ///
@@ -105,47 +115,52 @@ pub enum Error {
     /// metamethods for binary operators. Refer to the documentation of [`UserDataMethods`] for
     /// details.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserDataMethods`]: trait.UserDataMethods.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserDataMethods`]: crate::UserDataMethods
     UserDataTypeMismatch,
     /// An [`AnyUserData`] borrow failed because it has been destructed.
     ///
     /// This error can happen either due to to being destructed in a previous __gc, or due to being
     /// destructed from exiting a `Lua::scope` call.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`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
     /// prevent these errors.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserData`]: trait.UserData.html
+    /// [`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
     /// prevent these errors.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserData`]: trait.UserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserData`]: crate::UserData
     UserDataBorrowMutError,
     /// A [`MetaMethod`] operation is restricted (typically for `__gc` or `__metatable`).
     ///
-    /// [`MetaMethod`]: enum.MetaMethod.html
+    /// [`MetaMethod`]: crate::MetaMethod
     MetaMethodRestricted(StdString),
     /// A [`MetaMethod`] (eg. `__index` or `__newindex`) has invalid type.
     ///
-    /// [`MetaMethod`]: enum.MetaMethod.html
+    /// [`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.
+    /// A [`RegistryKey`] produced from a different Lua state was used.
+    ///
+    /// [`RegistryKey`]: crate::RegistryKey
     MismatchedRegistryKey,
     /// A Rust callback returned `Err`, raising the contained `Error` as a Lua error.
     CallbackError {
@@ -175,32 +190,37 @@ pub enum Error {
     /// error. The Rust code that originally invoked the Lua code then receives a `CallbackError`,
     /// from which the original error (and a stack traceback) can be recovered.
     ExternalError(Arc<dyn StdError + Send + Sync>),
+    /// An error with additional context.
+    WithContext {
+        /// A string containing additional context.
+        context: StdString,
+        /// Underlying error.
+        cause: Arc<Error>,
+    },
 }
 
 /// A specialized `Result` type used by `mlua`'s API.
 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::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {message}"),
+            Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {msg}"),
             Error::MemoryError(ref msg) => {
-                write!(fmt, "memory error: {}", msg)
+                write!(fmt, "memory error: {msg}")
             }
             #[cfg(any(feature = "lua53", feature = "lua52"))]
             Error::GarbageCollectorError(ref msg) => {
-                write!(fmt, "garbage collector error: {}", msg)
+                write!(fmt, "garbage collector error: {msg}")
             }
             Error::SafetyError(ref msg) => {
-                write!(fmt, "safety error: {}", msg)
+                write!(fmt, "safety error: {msg}")
             },
             Error::MemoryLimitNotAvailable => {
                 write!(fmt, "setting memory limit is not available")
             }
-            Error::MainThreadNotAvailable => {
-                write!(fmt, "main thread is not available in Lua 5.1")
-            }
             Error::RecursiveMutCallback => write!(fmt, "mutable callback called recursively"),
             Error::CallbackDestructed => write!(
                 fmt,
@@ -214,51 +234,86 @@ impl fmt::Display for Error {
                 fmt,
                 "too many arguments to Function::bind"
             ),
+            Error::BadArgument { ref to, pos, ref name, ref cause } => {
+                if let Some(name) = name {
+                    write!(fmt, "bad argument `{name}`")?;
+                } else {
+                    write!(fmt, "bad argument #{pos}")?;
+                }
+                if let Some(to) = to {
+                    write!(fmt, " to `{to}`")?;
+                }
+                write!(fmt, ": {cause}")
+            },
             Error::ToLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting {} to Lua {}", from, to)?;
+                write!(fmt, "error converting {from} to Lua {to}")?;
                 match *message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                 }
             }
             Error::FromLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting Lua {} to {}", from, to)?;
+                write!(fmt, "error converting Lua {from} to {to}")?;
                 match *message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                 }
             }
             Error::CoroutineInactive => write!(fmt, "cannot resume inactive coroutine"),
             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::UserDataBorrowError => write!(fmt, "error borrowing userdata"),
+            Error::UserDataBorrowMutError => write!(fmt, "error mutably borrowing userdata"),
+            Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {method} is restricted"),
             Error::MetaMethodTypeError { ref method, type_name, ref message } => {
-                write!(fmt, "metamethod {} has unsupported type {}", method, type_name)?;
+                write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
                 match *message {
                     None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                 }
             }
             Error::MismatchedRegistryKey => {
                 write!(fmt, "RegistryKey used from different Lua state")
             }
-            Error::CallbackError { ref traceback, .. } => {
-                write!(fmt, "callback error\n{}", traceback)
+            Error::CallbackError { ref cause, ref 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 {
+                    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();
+                    // Try to find local traceback within the full traceback
+                    if let Some(pos) = full_traceback.find(traceback) {
+                        write!(fmt, "{}", &full_traceback[..pos])?;
+                        writeln!(fmt, ">{}", &full_traceback[pos..].trim_end())?;
+                    } else {
+                        writeln!(fmt, "{}", full_traceback.trim_end())?;
+                    }
+                } else {
+                    writeln!(fmt, "{}", traceback.trim_end())?;
+                }
+                Ok(())
             }
             Error::PreviouslyResumedPanic => {
                 write!(fmt, "previously resumed panic returned again")
             }
             #[cfg(feature = "serialize")]
             Error::SerializeError(ref err) => {
-                write!(fmt, "serialize error: {}", err)
+                write!(fmt, "serialize error: {err}")
             },
             #[cfg(feature = "serialize")]
             Error::DeserializeError(ref err) => {
-                write!(fmt, "deserialize error: {}", err)
+                write!(fmt, "deserialize error: {err}")
             },
-            Error::ExternalError(ref err) => write!(fmt, "{}", err),
+            Error::ExternalError(ref err) => write!(fmt, "{err}"),
+            Error::WithContext { ref context, ref cause } => {
+                writeln!(fmt, "{context}")?;
+                write!(fmt, "{cause}")
+            }
         }
     }
 }
@@ -266,55 +321,153 @@ impl fmt::Display for Error {
 impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
         match *self {
-            Error::CallbackError { ref cause, .. } => Some(cause.as_ref()),
+            // 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.
+            Error::CallbackError { .. } => None,
             Error::ExternalError(ref err) => err.source(),
+            Error::WithContext { ref cause, .. } => match cause.as_ref() {
+                Error::ExternalError(err) => err.source(),
+                _ => None,
+            },
             _ => None,
         }
     }
 }
 
 impl Error {
-    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<dyn StdError + Send + Sync>>>(err: T) -> Self {
         Error::ExternalError(err.into().into())
     }
+
+    /// Attempts to downcast the external error object to a concrete type by reference.
+    pub fn downcast_ref<T>(&self) -> Option<&T>
+    where
+        T: StdError + 'static,
+    {
+        match self {
+            Error::ExternalError(err) => err.downcast_ref(),
+            Error::WithContext { cause, .. } => match cause.as_ref() {
+                Error::ExternalError(err) => err.downcast_ref(),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    pub(crate) fn bad_self_argument(to: &str, cause: Error) -> Self {
+        Error::BadArgument {
+            to: Some(to.to_string()),
+            pos: 1,
+            name: Some("self".to_string()),
+            cause: Arc::new(cause),
+        }
+    }
+
+    pub(crate) fn from_lua_conversion<'a>(
+        from: &'static str,
+        to: &'static str,
+        message: impl Into<Option<&'a str>>,
+    ) -> Self {
+        Error::FromLuaConversionError {
+            from,
+            to,
+            message: message.into().map(|s| s.into()),
+        }
+    }
 }
 
+/// 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 {
+    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 StdResult<T, Error> {
+    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)
     }

src/ffi/glue/glue.c

@@ -1,289 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <lauxlib.h>
-#include <lua.h>
-#include <lualib.h>
-
-#ifndef LUA_EXTRASPACE
-#define LUA_EXTRASPACE (sizeof(void*))
-#endif
-
-// Macros taken from https://gcc.gnu.org/onlinedocs/cpp/Stringification.html
-#define xstr(s) str(s)
-#define str(s) #s
-
-typedef struct rs_item {
-  int type;
-  const char *name;
-  union {
-    int int_val;
-    const char *str_val;
-    LUA_INTEGER lua_int_val;
-  };
-} rs_item;
-
-
-#define TY_INT 0
-#define RS_INT(name, val)                                                      \
-  { TY_INT, name, .int_val = val }
-
-#if LUA_VERSION_NUM >= 503
-#define TY_LUAINT 1
-#define RS_LUAINT(name, val)                                                   \
-  { TY_LUAINT, name, .lua_int_val = val }
-#endif
-
-#define TY_STR 2
-#define RS_STR(name, val)                                                      \
-  { TY_STR, name, .str_val = val }
-
-#define TY_TYPE 3
-#define RS_TYPE(name, val)                                                     \
-  { TY_TYPE, name, .str_val = val }
-
-#define TY_COMMENT 4
-#define RS_COMMENT(val)                                                        \
-  { TY_COMMENT, NULL, .str_val = val }
-
-#define TY_RAW 5
-#define RS_RAW(val)                                                            \
-  { TY_RAW, NULL, .str_val = val }
-
-const char *rs_int_type(int width) {
-  switch (width) {
-  default:
-  case 2:
-    return "i16";
-  case 4:
-    return "i32";
-  case 8:
-    return "i64";
-  case 16:
-    return "i128";
-  }
-}
-
-const char *rs_uint_type(int width) {
-  switch (width) {
-  default:
-  case 2:
-    return "u16";
-  case 4:
-    return "u32";
-  case 8:
-    return "u64";
-  case 16:
-    return "u128";
-  }
-}
-
-int try_write(char **str, char c, size_t n, size_t *written, size_t szstr) {
-  if (szstr - *written < n) {
-    return 0;
-  }
-  for (; n; n--, *written++)
-    *(*str)++ = c;
-  return 1;
-}
-
-// converts \ in a string to \\ so that it can be used as a rust string literal
-// ensures that `out` will always have a null terminating character
-size_t escape(const char *in, char *out, size_t szout) {
-  size_t written = 0;
-  char cur;
-
-  while ((cur = *in++)) {
-    switch (cur) {
-    case '\\':
-      if (!try_write(&out, cur, 2, &written, szout))
-        goto finalize;
-      break;
-    default:
-      if (!try_write(&out, cur, 1, &written, szout))
-        goto finalize;
-      break;
-    }
-  }
-
-finalize:
-  if (written + 1 <= szout) {
-    *out++ = '\0';
-    written++;
-  }
-  return written;
-}
-
-int write_int_item(FILE *f, const char *name, int value) {
-  return fprintf(f, "pub const %s: c_int = %d;\n", name, value);
-}
-
-#if LUA_VERSION_NUM >= 503
-int write_lua_int_item(FILE *f, const char *name, LUA_INTEGER value) {
-  return fprintf(f, "pub const %s: LUA_INTEGER = " LUA_INTEGER_FMT ";\n", name,
-                 value);
-}
-#endif
-
-int write_str_item(FILE *f, const char *name, const char *value) {
-  size_t len = strlen(value);
-  size_t bufsz = len * 2 + 1;
-  char *buf = malloc(bufsz);
-  int ret;
-  escape(value, buf, bufsz);
-  ret = fprintf(f, "pub const %s: &str = \"%s\";\n", name, buf);
-  free(buf);
-  return ret;
-}
-
-int write_type(FILE *f, const char *name, const char *value) {
-  return fprintf(f, "pub type %s = %s;\n", name, value);
-}
-
-int write_comment(FILE *f, const char *value) {
-  return fprintf(f, "/* %s */\n", value);
-}
-
-int write_raw(FILE *f, const char *value) { return fputs(value, f) >= 0; }
-
-int write_item(FILE *f, const rs_item *c) {
-  switch (c->type) {
-  case TY_INT:
-    return write_int_item(f, c->name, c->int_val);
-#if LUA_VERSION_NUM >= 503
-  case TY_LUAINT:
-    return write_lua_int_item(f, c->name, c->lua_int_val);
-#endif
-  case TY_STR:
-    return write_str_item(f, c->name, c->str_val);
-  case TY_TYPE:
-    return write_type(f, c->name, c->str_val);
-  case TY_COMMENT:
-    return write_comment(f, c->str_val);
-  case TY_RAW:
-    return write_raw(f, c->str_val);
-  default:
-    return 0;
-  }
-}
-
-int write_items_(FILE *f, const rs_item items[], size_t num) {
-  size_t i;
-  for (i = 0; i < num; i++) {
-    if (!write_item(f, &items[i]))
-      return 0;
-  }
-  return 1;
-}
-
-#define write_items(f, cs) write_items_(f, cs, sizeof(cs) / sizeof(cs[0]))
-
-int main(int argc, const char **argv) {
-  if (argc <= 1) {
-    printf("usage: %s <filename>\n", argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  const char *filename = argv[1];
-
-  FILE *f = fopen(filename, "w");
-
-  if (!f) {
-    printf("could not open file: errno = %d\n", errno);
-    return EXIT_FAILURE;
-  }
-
-  const rs_item glue_entries[] = {
-      RS_COMMENT("this file was generated by glue.c; do not modify it by hand"),
-      RS_RAW("use std::os::raw::*;\n"),
-
-      // == luaconf.h ==========================================================
-
-      RS_COMMENT("luaconf.h"),
-      RS_INT("LUA_EXTRASPACE", LUA_EXTRASPACE),
-      RS_INT("LUA_IDSIZE", LUA_IDSIZE),
-      RS_TYPE("LUA_NUMBER",
-              sizeof(LUA_NUMBER) > sizeof(float) ? "c_double" : "c_float"),
-      RS_TYPE("LUA_INTEGER", rs_int_type(sizeof(LUA_INTEGER))),
-#if LUA_VERSION_NUM >= 502
-      RS_TYPE("LUA_UNSIGNED", rs_uint_type(sizeof(LUA_UNSIGNED))),
-#else
-      RS_TYPE("LUA_UNSIGNED", rs_uint_type(sizeof(size_t))),
-#endif
-
-      // == lua.h ==============================================================
-
-      RS_COMMENT("lua.h"),
-      RS_INT("LUA_VERSION_NUM", LUA_VERSION_NUM),
-      RS_INT("LUA_REGISTRYINDEX", LUA_REGISTRYINDEX),
-#if LUA_VERSION_NUM == 501
-      RS_INT("LUA_ENVIRONINDEX", LUA_ENVIRONINDEX),
-      RS_INT("LUA_GLOBALSINDEX", LUA_GLOBALSINDEX),
-#endif
-
-      // == lauxlib.h ==========================================================
-
-      RS_COMMENT("lauxlib.h"),
-#if LUA_VERSION_NUM >= 503
-      RS_INT("LUAL_NUMSIZES", LUAL_NUMSIZES),
-#endif
-
-      // == lualib.h ===========================================================
-
-      RS_COMMENT("lualib.h"),
-      RS_STR("LUA_COLIBNAME", LUA_COLIBNAME),
-      RS_STR("LUA_TABLIBNAME", LUA_TABLIBNAME),
-      RS_STR("LUA_IOLIBNAME", LUA_IOLIBNAME),
-      RS_STR("LUA_OSLIBNAME", LUA_OSLIBNAME),
-      RS_STR("LUA_STRLIBNAME", LUA_STRLIBNAME),
-#ifdef LUA_UTF8LIBNAME
-      RS_STR("LUA_UTF8LIBNAME", LUA_UTF8LIBNAME),
-#endif
-#ifdef LUA_BITLIBNAME
-      RS_STR("LUA_BITLIBNAME", LUA_BITLIBNAME),
-#endif
-      RS_STR("LUA_MATHLIBNAME", LUA_MATHLIBNAME),
-      RS_STR("LUA_DBLIBNAME", LUA_DBLIBNAME),
-      RS_STR("LUA_LOADLIBNAME", LUA_LOADLIBNAME),
-#ifdef LUA_JITLIBNAME
-      RS_STR("LUA_JITLIBNAME", LUA_JITLIBNAME),
-#endif
-#ifdef LUA_FFILIBNAME
-      RS_STR("LUA_FFILIBNAME", LUA_FFILIBNAME),
-#endif
-  };
-
-  if (!write_items(f, glue_entries)) {
-    printf("%s: error generating %s; aborting\n", argv[0], filename);
-    return EXIT_FAILURE;
-  }
-
-  fclose(f);
-
-  return EXIT_SUCCESS;
-}

src/ffi/lauxlib.rs

@@ -1,306 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `lauxlib.h`.
-
-use std::os::raw::{c_char, c_int, c_long, c_void};
-use std::ptr;
-
-use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use super::glue::LUAL_NUMSIZES;
-
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{luaL_getmetafield, luaL_newmetatable, luaL_requiref, luaL_tolstring};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{
-    luaL_checkstack, luaL_checkversion, luaL_getsubtable, luaL_len, luaL_loadbufferx,
-    luaL_setfuncs, luaL_setmetatable, luaL_testudata, luaL_traceback,
-};
-
-// extra error code for 'luaL_load'
-pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
-
-#[repr(C)]
-pub struct luaL_Reg {
-    pub name: *const c_char,
-    pub func: lua_CFunction,
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn luaL_checkversion(L: *mut lua_State) {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    luaL_checkversion_(
-        L,
-        lua::LUA_VERSION_NUM as lua_Number,
-        LUAL_NUMSIZES as usize,
-    );
-    #[cfg(feature = "lua52")]
-    luaL_checkversion_(L, lua::LUA_VERSION_NUM as lua_Number);
-}
-
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
-    #[cfg(feature = "lua52")]
-    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "luaL_getmetafield"]
-    pub fn luaL_getmetafield_old(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;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    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, l: *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_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;
-    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
-    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
-    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "luaL_newmetatable"]
-    pub fn luaL_newmetatable_old(L: *mut lua_State, tname: *const c_char) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
-    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, ...) -> !;
-
-    // TODO: test this
-    pub fn luaL_checkoption(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        lst: *const *const c_char,
-    ) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
-}
-
-// pre-defined references
-pub const LUA_NOREF: c_int = -2;
-pub const LUA_REFNIL: c_int = -1;
-
-extern "C" {
-    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: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn luaL_loadfile(L: *mut lua_State, filename: *const c_char) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
-    luaL_loadfilex(L, f, ptr::null())
-}
-
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_loadbufferx(
-        L: *mut lua_State,
-        buff: *const c_char,
-        sz: usize,
-        name: *const c_char,
-        mode: *const c_char,
-    ) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    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;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
-
-    // TODO (lua54): luaL_addgsub
-
-    pub fn luaL_gsub(
-        L: *mut lua_State,
-        s: *const c_char,
-        p: *const c_char,
-        r: *const c_char,
-    ) -> *const c_char;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
-
-    // Skip Lua 5.2 implementation in favor of the compat53 one
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_requiref(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
-}
-
-#[inline(always)]
-#[allow(unused_variables)]
-pub unsafe fn luaL_newlibtable(L: *mut lua_State, l: *const luaL_Reg) {
-    // TODO: figure out how to pass an appropriate hint for the second param
-    // this involves correcting the second parameter's type; in C this is
-    // sizeof(l)/sizeof(l[0])
-    lua::lua_createtable(L, 0, 0)
-}
-
-#[inline(always)]
-pub unsafe fn luaL_newlib(L: *mut lua_State, l: *const luaL_Reg) {
-    luaL_checkversion(L);
-    luaL_newlibtable(L, l);
-    luaL_setfuncs(L, l, 0)
-}
-
-#[inline(always)]
-pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
-    if cond == 0 {
-        luaL_argerror(L, arg, extramsg);
-    }
-}
-
-#[inline(always)]
-pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
-    luaL_checklstring(L, n, ptr::null_mut())
-}
-
-#[inline(always)]
-pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
-    luaL_optlstring(L, n, d, ptr::null_mut())
-}
-
-// From 5.3 user manual:
-// Macros to project non-default integer types (luaL_checkint, luaL_optint,
-// luaL_checklong, luaL_optlong) were deprecated. Use their equivalent over
-// lua_Integer with a type cast (or, when possible, use lua_Integer in your
-// code).
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_checkint(L: *mut lua_State, n: c_int) -> c_int {
-    luaL_checkinteger(L, n) as c_int
-}
-
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_optint(L: *mut lua_State, n: c_int, d: c_int) -> c_int {
-    luaL_optinteger(L, n, d as lua_Integer) as c_int
-}
-
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_checklong(L: *mut lua_State, n: c_int) -> c_long {
-    luaL_checkinteger(L, n) as c_long
-}
-
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_optlong(L: *mut lua_State, n: c_int, d: c_long) -> c_long {
-    luaL_optinteger(L, n, d as lua_Integer) as c_long
-}
-
-#[inline(always)]
-pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
-    lua::lua_typename(L, lua::lua_type(L, i))
-}
-
-#[inline(always)]
-pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
-    let status = luaL_loadfile(L, filename);
-    if status == 0 {
-        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
-    } else {
-        status
-    }
-}
-
-#[inline(always)]
-pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
-    let status = luaL_loadstring(L, s);
-    if status == 0 {
-        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
-    } else {
-        status
-    }
-}
-
-#[inline(always)]
-pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
-    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
-}
-
-// luaL_opt would be implemented here but it is undocumented, so it's omitted
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-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())
-}
-
-// TODO: Add buffer API
-
-// omitted: old module system compatibility (removed in 5.4)

src/ffi/lua.rs

@@ -1,825 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `lua.h`.
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-use std::os::raw::c_uchar;
-use std::os::raw::{c_char, c_int, c_void};
-#[cfg(feature = "lua54")]
-use std::os::raw::{c_uint, c_ushort};
-use std::ptr;
-
-use super::luaconf;
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use super::glue::{LUA_ENVIRONINDEX, LUA_GLOBALSINDEX};
-pub use super::glue::{LUA_REGISTRYINDEX, LUA_VERSION_NUM};
-
-#[cfg(not(feature = "luajit"))]
-pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
-#[cfg(feature = "luajit")]
-pub const LUA_SIGNATURE: &[u8] = b"\x1bLJ";
-
-// option for multiple returns in 'lua_pcall' and 'lua_call'
-pub const LUA_MULTRET: c_int = -1;
-
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{
-    lua_dump, lua_getextraspace, lua_getfield, lua_geti, lua_gettable, lua_getuservalue,
-    lua_isinteger, lua_pushlstring, lua_rawget, lua_rawgeti, lua_rawgetp, lua_rotate, lua_seti,
-    lua_stringtonumber, lua_tointegerx,
-};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{
-    lua_absindex, lua_arith, lua_compare, lua_copy, lua_len, lua_pushglobaltable, lua_pushstring,
-    lua_rawlen, lua_rawsetp, lua_resume as lua_resume_53, lua_setuservalue, lua_tonumberx,
-    lua_upvalueindex,
-};
-
-#[cfg(feature = "lua52")]
-pub use super::compat53::lua_getglobal;
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub fn lua_upvalueindex(i: c_int) -> c_int {
-    LUA_REGISTRYINDEX - i
-}
-
-// thread status
-pub const LUA_OK: c_int = 0;
-pub const LUA_YIELD: c_int = 1;
-pub const LUA_ERRRUN: c_int = 2;
-pub const LUA_ERRSYNTAX: c_int = 3;
-pub const LUA_ERRMEM: c_int = 4;
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub const LUA_ERRGCMM: c_int = 5;
-#[cfg(any(feature = "lua54", feature = "lua51", feature = "luajit"))]
-pub const LUA_ERRERR: c_int = 5;
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub const LUA_ERRERR: c_int = 6;
-
-pub type lua_State = c_void;
-
-// basic types
-pub const LUA_TNONE: c_int = -1;
-
-pub const LUA_TNIL: c_int = 0;
-pub const LUA_TBOOLEAN: c_int = 1;
-pub const LUA_TLIGHTUSERDATA: c_int = 2;
-pub const LUA_TNUMBER: c_int = 3;
-pub const LUA_TSTRING: c_int = 4;
-pub const LUA_TTABLE: c_int = 5;
-pub const LUA_TFUNCTION: c_int = 6;
-pub const LUA_TUSERDATA: c_int = 7;
-pub const LUA_TTHREAD: c_int = 8;
-
-#[cfg(feature = "lua54")]
-pub const LUA_NUMTYPES: c_int = 9;
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub const LUA_NUMTAGS: c_int = 9;
-
-// minimum stack available to a C function
-pub const LUA_MINSTACK: c_int = 20;
-
-// predefined values in the registry
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
-
-/// A Lua number, usually equivalent to `f64`.
-pub type lua_Number = luaconf::LUA_NUMBER;
-
-/// A Lua integer, usually equivalent to `i64`.
-pub type lua_Integer = luaconf::LUA_INTEGER;
-
-// unsigned integer type
-pub type lua_Unsigned = luaconf::LUA_UNSIGNED;
-
-// type for continuation-function contexts
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub type lua_KContext = luaconf::LUA_KCONTEXT;
-
-/// Type for native functions that can be passed to Lua.
-pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
-
-// Type for continuation functions
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub type lua_KFunction =
-    unsafe extern "C" 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
-pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
-pub type lua_Writer =
-    unsafe extern "C" 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 warning functions
-#[cfg(feature = "lua54")]
-pub type lua_WarnFunction =
-    unsafe extern "C" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
-
-extern "C" {
-    // 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;
-
-    #[cfg(feature = "lua54")]
-    #[link_name = "lua_resetthread"]
-    pub fn lua_resetthread_54(L: *mut lua_State) -> c_int;
-    #[cfg(all(feature = "luajit", feature = "vendored"))]
-    #[link_name = "lua_resetthread"]
-    pub fn lua_resetthread_jit(L: *mut lua_State, th: *mut lua_State);
-
-    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_version(L: *mut lua_State) -> lua_Number;
-    #[cfg(feature = "lua53")]
-    pub fn lua_version(L: *mut lua_State) -> *const lua_Number;
-
-    // basic stack manipulation
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_gettop(L: *mut lua_State) -> c_int;
-    pub fn lua_settop(L: *mut lua_State, idx: c_int);
-    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    pub fn lua_remove(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    pub fn lua_insert(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    pub fn lua_replace(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rotate(L: *mut lua_State, idx: c_int, n: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
-    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
-
-    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
-
-    // access functions (stack -> C)
-    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
-
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_tonumber(L: *mut lua_State, idx: c_int) -> lua_Number;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_tointeger(L: *mut lua_State, idx: c_int) -> lua_Integer;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    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;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize;
-    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> 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;
-}
-
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
-pub unsafe fn lua_resetthread(_L: *mut lua_State, th: *mut lua_State) -> c_int {
-    #[cfg(all(feature = "luajit", feature = "vendored"))]
-    {
-        lua_resetthread_jit(_L, th);
-        LUA_OK
-    }
-    #[cfg(feature = "lua54")]
-    lua_resetthread_54(th)
-}
-
-// Comparison and arithmetic functions
-pub const LUA_OPADD: c_int = 0;
-pub const LUA_OPSUB: c_int = 1;
-pub const LUA_OPMUL: c_int = 2;
-
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPDIV: c_int = 3;
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPMOD: c_int = 4;
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPPOW: c_int = 5;
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPUNM: c_int = 6;
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPMOD: c_int = 3;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPPOW: c_int = 4;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPDIV: c_int = 5;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPIDIV: c_int = 6;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBAND: c_int = 7;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBOR: c_int = 8;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBXOR: c_int = 9;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPSHL: c_int = 10;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPSHR: c_int = 11;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPUNM: c_int = 12;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBNOT: c_int = 13;
-
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    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(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_equal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
-    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_lessthan(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
-}
-
-// push functions (C -> stack)
-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);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_pushlstring"]
-    pub fn lua_pushlstring_old(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_pushstring"]
-    pub fn lua_pushstring_old(L: *mut lua_State, s: *const c_char) -> *const c_char;
-
-    // TODO: omitted:
-    // lua_pushvfstring
-    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
-    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
-    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
-    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
-    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
-}
-
-// get functions (Lua -> stack)
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int;
-    #[cfg(feature = "lua52")]
-    #[link_name = "lua_getglobal"]
-    pub fn lua_getglobal_old(L: *mut lua_State, var: *const c_char);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_gettable"]
-    pub fn lua_gettable_old(L: *mut lua_State, idx: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_getfield"]
-    pub fn lua_getfield_old(L: *mut lua_State, idx: c_int, k: *const c_char);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_geti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_rawget"]
-    pub fn lua_rawget_old(L: *mut lua_State, idx: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_rawgeti"]
-    pub fn lua_rawgeti_old(L: *mut lua_State, idx: c_int, n: lua_Integer);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int;
-    #[cfg(feature = "lua52")]
-    #[link_name = "lua_rawgetp"]
-    pub fn lua_rawgetp_old(L: *mut lua_State, idx: c_int, p: *const c_void);
-
-    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
-    #[cfg(feature = "lua54")]
-    pub fn lua_newuserdatauv(L: *mut lua_State, sz: usize, nuvalue: c_int) -> *mut c_void;
-    #[cfg(any(
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit"
-    ))]
-    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
-    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_getiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
-    #[cfg(feature = "lua53")]
-    pub fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(feature = "lua52")]
-    #[link_name = "lua_getuservalue"]
-    pub fn lua_getuservalue_old(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_getfenv(L: *mut lua_State, idx: c_int);
-}
-
-#[cfg(feature = "lua54")]
-#[inline(always)]
-pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
-    lua_newuserdatauv(L, sz, 1)
-}
-
-#[cfg(feature = "lua54")]
-#[inline(always)]
-pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_getiuservalue(L, idx, 1)
-}
-
-// set functions (stack -> Lua)
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_setglobal(L: *mut lua_State, var: *const c_char);
-    pub fn lua_settable(L: *mut lua_State, idx: c_int);
-    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_seti(L: *mut lua_State, idx: c_int, n: lua_Integer);
-    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
-    pub fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
-    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
-    #[cfg(feature = "lua54")]
-    pub fn lua_setiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
-    #[cfg(any(feature = "lua53", feature = "lua52"))]
-    pub fn lua_setuservalue(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_setfenv(L: *mut lua_State, idx: c_int) -> c_int;
-}
-
-#[cfg(feature = "lua54")]
-#[inline(always)]
-pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) {
-    lua_setiuservalue(L, idx, 1);
-}
-
-// 'load' and 'call' functions (load and run Lua code)
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_callk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        ctx: lua_KContext,
-        k: Option<lua_KFunction>,
-    );
-    #[cfg(feature = "lua52")]
-    pub fn lua_callk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    );
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_pcallk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        errfunc: c_int,
-        ctx: lua_KContext,
-        k: Option<lua_KFunction>,
-    ) -> c_int;
-    #[cfg(feature = "lua52")]
-    pub fn lua_pcallk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        errfunc: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    ) -> c_int;
-
-    #[cfg(feature = "lua52")]
-    pub fn lua_getctx(L: *mut lua_State, ctx: *mut c_int) -> c_int;
-
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_call(L: *mut lua_State, nargs: c_int, nresults: c_int);
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_pcall(L: *mut lua_State, nargs: c_int, nresults: c_int, errfunc: c_int) -> c_int;
-
-    // TODO
-    pub fn lua_load(
-        L: *mut lua_State,
-        reader: lua_Reader,
-        dt: *mut c_void,
-        chunkname: *const c_char,
-        mode: *const c_char,
-    ) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_dump(
-        L: *mut lua_State,
-        writer: lua_Writer,
-        data: *mut c_void,
-        strip: c_int,
-    ) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_dump"]
-    pub fn lua_dump_old(L: *mut lua_State, writer: lua_Writer, data: *mut c_void) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
-    lua_callk(L, n, r, 0, None)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
-    lua_pcallk(L, n, r, f, 0, None)
-}
-
-// coroutine functions
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_yieldk(
-        L: *mut lua_State,
-        nresults: c_int,
-        ctx: lua_KContext,
-        k: Option<lua_KFunction>,
-    ) -> c_int;
-    #[cfg(feature = "lua52")]
-    pub fn lua_yieldk(
-        L: *mut lua_State,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    ) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_yield(L: *mut lua_State, nresults: c_int) -> c_int;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_resume(
-        L: *mut lua_State,
-        from: *mut lua_State,
-        narg: c_int,
-        nres: *mut c_int,
-    ) -> c_int;
-    #[cfg(any(feature = "lua53", feature = "lua52"))]
-    #[link_name = "lua_resume"]
-    pub fn lua_resume_53(L: *mut lua_State, from: *mut lua_State, narg: c_int) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_resume"]
-    pub fn lua_resume_old(L: *mut lua_State, narg: c_int) -> c_int;
-
-    pub fn lua_status(L: *mut lua_State) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
-    lua_yieldk(L, n, 0, None)
-}
-
-#[cfg(any(
-    feature = "lua53",
-    feature = "lua52",
-    feature = "lua51",
-    feature = "luajit"
-))]
-#[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_53(L, from, narg);
-    if ret == LUA_OK || ret == LUA_YIELD {
-        *nres = lua_gettop(L);
-    }
-    ret
-}
-
-// warning-related functions
-#[cfg(feature = "lua54")]
-extern "C" {
-    pub fn lua_setwarnf(L: *mut lua_State, f: lua_WarnFunction, ud: *mut c_void);
-    pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
-}
-
-// garbage-collection function and options
-pub const LUA_GCSTOP: c_int = 0;
-pub const LUA_GCRESTART: c_int = 1;
-pub const LUA_GCCOLLECT: c_int = 2;
-pub const LUA_GCCOUNT: c_int = 3;
-pub const LUA_GCCOUNTB: c_int = 4;
-pub const LUA_GCSTEP: c_int = 5;
-pub const LUA_GCSETPAUSE: c_int = 6;
-pub const LUA_GCSETSTEPMUL: c_int = 7;
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_GCISRUNNING: c_int = 9;
-#[cfg(feature = "lua54")]
-pub const LUA_GCGEN: c_int = 10;
-#[cfg(feature = "lua54")]
-pub const LUA_GCINC: c_int = 11;
-
-extern "C" {
-    #[cfg(feature = "lua54")]
-    pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
-    #[cfg(any(
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit"
-    ))]
-    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) -> !;
-    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_concat(L: *mut lua_State, n: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_len(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize;
-    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);
-    #[cfg(feature = "lua54")]
-    pub fn lua_toclose(L: *mut lua_State, idx: c_int);
-}
-
-// some useful macros
-// here, implemented as Rust functions
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
-    L.offset(-super::glue::LUA_EXTRASPACE as isize) as *mut c_void
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
-    lua_tonumberx(L, i, ptr::null_mut())
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
-    lua_tointegerx(L, i, ptr::null_mut())
-}
-
-#[inline(always)]
-pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
-    lua_settop(L, -n - 1)
-}
-
-#[inline(always)]
-pub unsafe fn lua_newtable(L: *mut lua_State) {
-    lua_createtable(L, 0, 0)
-}
-
-#[inline(always)]
-pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
-    lua_pushcfunction(L, f);
-    lua_setglobal(L, n)
-}
-
-#[inline(always)]
-pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
-    lua_pushcclosure(L, f, 0)
-}
-
-#[inline(always)]
-pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TFUNCTION) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TTABLE) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TNIL) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
-}
-
-#[inline(always)]
-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_isnone(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TNONE) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) <= 0) as 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())
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
-    lua_setfield(L, LUA_GLOBALSINDEX, var)
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
-    lua_getfield(L, LUA_GLOBALSINDEX, var)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-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_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
-    lua_tolstring(L, i, ptr::null_mut())
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_insert(L: *mut lua_State, idx: c_int) {
-    lua_rotate(L, idx, 1)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_remove(L: *mut lua_State, idx: c_int) {
-    lua_rotate(L, idx, -1);
-    lua_pop(L, 1)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
-    lua_copy(L, -1, idx);
-    lua_pop(L, 1)
-}
-
-// Debug API
-// Event codes
-pub const LUA_HOOKCALL: c_int = 0;
-pub const LUA_HOOKRET: c_int = 1;
-pub const LUA_HOOKLINE: c_int = 2;
-pub const LUA_HOOKCOUNT: c_int = 3;
-pub const LUA_HOOKTAILCALL: c_int = 4;
-
-// Event masks
-pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
-pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
-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);
-
-extern "C" {
-    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;
-    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
-    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;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    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_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;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_setcstacklimit(L: *mut lua_State, limit: c_uint) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[repr(C)]
-pub struct lua_Debug {
-    pub event: c_int,
-    pub name: *const c_char,
-    pub namewhat: *const c_char,
-    pub what: *const c_char,
-    pub source: *const c_char,
-    #[cfg(feature = "lua54")]
-    pub srclen: usize,
-    pub currentline: c_int,
-    pub linedefined: c_int,
-    pub lastlinedefined: c_int,
-    pub nups: c_uchar,
-    pub nparams: c_uchar,
-    pub isvararg: c_char,
-    pub istailcall: c_char,
-    #[cfg(feature = "lua54")]
-    pub ftransfer: c_ushort,
-    #[cfg(feature = "lua54")]
-    pub ntransfer: c_ushort,
-    pub short_src: [c_char; luaconf::LUA_IDSIZE as usize],
-    // lua.h mentions this is for private use
-    i_ci: *mut c_void,
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[repr(C)]
-pub struct lua_Debug {
-    pub event: c_int,
-    pub name: *const c_char,
-    pub namewhat: *const c_char,
-    pub what: *const c_char,
-    pub source: *const c_char,
-    pub currentline: c_int,
-    pub nups: c_int,
-    pub linedefined: c_int,
-    pub lastlinedefined: c_int,
-    pub short_src: [c_char; luaconf::LUA_IDSIZE as usize],
-    // lua.h mentions this is for private use
-    i_ci: c_int,
-}

src/ffi/luaconf.rs

@@ -1,36 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `luaconf.h`.
-
-pub use super::glue::LUA_INTEGER;
-pub use super::glue::LUA_NUMBER;
-pub use super::glue::LUA_UNSIGNED;
-
-pub use super::glue::LUA_IDSIZE;
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use super::glue::LUAL_NUMSIZES;
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub type LUA_KCONTEXT = isize; // intptr_t

src/ffi/lualib.rs

@@ -1,67 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `lualib.h`.
-
-use std::os::raw::c_int;
-
-use super::lua::lua_State;
-
-pub use super::glue::{
-    LUA_COLIBNAME, LUA_DBLIBNAME, LUA_IOLIBNAME, LUA_LOADLIBNAME, LUA_MATHLIBNAME, LUA_OSLIBNAME,
-    LUA_STRLIBNAME, LUA_TABLIBNAME,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use super::glue::LUA_UTF8LIBNAME;
-
-#[cfg(any(feature = "lua52", feature = "luajit"))]
-pub use super::glue::LUA_BITLIBNAME;
-
-#[cfg(feature = "luajit")]
-pub use super::glue::{LUA_FFILIBNAME, LUA_JITLIBNAME};
-
-extern "C" {
-    pub fn luaopen_base(L: *mut lua_State) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    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;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
-    #[cfg(feature = "lua52")]
-    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;
-    #[cfg(feature = "luajit")]
-    pub fn luaopen_bit(L: *mut lua_State) -> c_int;
-    #[cfg(feature = "luajit")]
-    pub fn luaopen_jit(L: *mut lua_State) -> c_int;
-    #[cfg(feature = "luajit")]
-    pub fn luaopen_ffi(L: *mut lua_State) -> c_int;
-
-    pub fn luaL_openlibs(L: *mut lua_State);
-}

src/ffi/mod.rs

@@ -1,297 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Low level bindings to Lua.
-
-#![allow(non_camel_case_types, non_snake_case, dead_code)]
-
-use std::os::raw::c_int;
-
-// This is more or less in the order it appears in the Lua manual, with the
-// exception of constants, which appear scattered throughout the manual text.
-
-// C API types
-pub use self::lua::{
-    lua_Alloc, lua_CFunction, lua_Debug, lua_Hook, lua_Integer, lua_Number, lua_Reader, lua_State,
-    lua_Unsigned, lua_Writer,
-};
-
-#[cfg(feature = "lua54")]
-pub use self::lua::lua_WarnFunction;
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lua::{lua_KContext, lua_KFunction};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use self::lua::{lua_getfenv, lua_setfenv};
-
-// C API functions
-pub use self::lua::{
-    lua_absindex,
-    lua_arith,
-    lua_atpanic,
-    lua_call,
-    lua_checkstack,
-    lua_close,
-    lua_compare,
-    lua_concat,
-    lua_copy,
-    lua_createtable,
-    lua_dump,
-    lua_error,
-    lua_gc,
-    lua_getallocf,
-    lua_getextraspace,
-    lua_getfield,
-    lua_getglobal,
-    lua_gethook,
-    lua_gethookcount,
-    lua_gethookmask,
-    lua_geti,
-    lua_getinfo,
-    lua_getlocal,
-    lua_getmetatable,
-    lua_getstack,
-    lua_gettable,
-    lua_gettop,
-    lua_getupvalue,
-    lua_getuservalue,
-    lua_insert,
-    lua_isboolean,
-    lua_iscfunction,
-    lua_isfunction,
-    lua_isinteger,
-    lua_islightuserdata,
-    lua_isnil,
-    lua_isnone,
-    lua_isnoneornil,
-    lua_isnumber,
-    lua_isstring,
-    lua_istable,
-    lua_isthread,
-    lua_isuserdata,
-    lua_len,
-    lua_load,
-    lua_newstate,
-    lua_newtable,
-    lua_newthread,
-    lua_newuserdata,
-    lua_next,
-    lua_pcall,
-    lua_pop,
-    lua_pushboolean,
-    lua_pushcclosure,
-    lua_pushcfunction,
-    lua_pushfstring,
-    lua_pushglobaltable,
-    lua_pushinteger,
-    lua_pushlightuserdata,
-    lua_pushliteral,
-    lua_pushlstring,
-    lua_pushnil,
-    lua_pushnumber,
-    lua_pushstring,
-    lua_pushthread,
-    lua_pushvalue,
-    // omitted: lua_pushvfstring
-    lua_rawequal,
-    lua_rawget,
-    lua_rawgeti,
-    lua_rawgetp,
-    lua_rawlen,
-    lua_rawset,
-    lua_rawseti,
-    lua_rawsetp,
-    lua_register,
-    lua_remove,
-    lua_replace,
-    lua_resume,
-    lua_rotate,
-    lua_setallocf,
-    lua_setfield,
-    lua_setglobal,
-    lua_sethook,
-    lua_seti,
-    lua_setlocal,
-    lua_setmetatable,
-    lua_settable,
-    lua_settop,
-    lua_setupvalue,
-    lua_setuservalue,
-    lua_status,
-    lua_stringtonumber,
-    lua_toboolean,
-    lua_tocfunction,
-    lua_tointeger,
-    lua_tointegerx,
-    lua_tolstring,
-    lua_tonumber,
-    lua_tonumberx,
-    lua_topointer,
-    lua_tostring,
-    lua_tothread,
-    lua_touserdata,
-    lua_type,
-    lua_typename,
-    lua_upvalueindex,
-    lua_xmove,
-    lua_yield,
-};
-
-#[cfg(feature = "lua54")]
-pub use self::lua::{
-    lua_getiuservalue, lua_newuserdatauv, lua_setcstacklimit, lua_setiuservalue, lua_setwarnf,
-    lua_toclose, lua_warning,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lua::{lua_isyieldable, lua_version};
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub use self::lua::{lua_callk, lua_pcallk, lua_upvalueid, lua_upvaluejoin, lua_yieldk};
-
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
-pub use self::lua::lua_resetthread;
-
-// auxiliary library types
-pub use self::lauxlib::luaL_Reg;
-
-// auxiliary library functions
-pub use self::lauxlib::{
-    luaL_argcheck, luaL_argerror, luaL_callmeta, luaL_checkany, luaL_checkint, luaL_checkinteger,
-    luaL_checklong, luaL_checklstring, luaL_checknumber, luaL_checkoption, luaL_checkstack,
-    luaL_checkstring, luaL_checktype, luaL_checkudata, luaL_checkversion, luaL_dofile,
-    luaL_dostring, luaL_error, luaL_getmetafield, luaL_getmetatable, luaL_getsubtable, luaL_gsub,
-    luaL_len, luaL_loadbuffer, luaL_loadbufferx, luaL_loadfile, luaL_loadstring, luaL_newlib,
-    luaL_newlibtable, luaL_newmetatable, luaL_newstate, luaL_optint, luaL_optinteger, luaL_optlong,
-    luaL_optlstring, luaL_optnumber, luaL_optstring, luaL_ref, luaL_requiref, luaL_setfuncs,
-    luaL_setmetatable, luaL_testudata, luaL_tolstring, luaL_traceback, luaL_typename, luaL_unref,
-    luaL_where,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub use self::lauxlib::{luaL_execresult, luaL_fileresult, luaL_loadfilex};
-
-// lualib.h functions
-pub use self::lualib::{
-    luaL_openlibs, luaopen_base, luaopen_debug, luaopen_io, luaopen_math, luaopen_os,
-    luaopen_package, luaopen_string, luaopen_table,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lualib::{luaopen_coroutine, luaopen_utf8};
-
-#[cfg(feature = "lua52")]
-pub use self::lualib::{luaopen_bit32, luaopen_coroutine};
-
-#[cfg(feature = "luajit")]
-pub use self::lualib::{luaopen_bit, luaopen_ffi, luaopen_jit};
-
-// constants from lua.h
-pub use self::lua::{
-    LUA_ERRERR, LUA_ERRMEM, LUA_ERRRUN, LUA_ERRSYNTAX, LUA_GCCOLLECT, LUA_GCCOUNT, LUA_GCCOUNTB,
-    LUA_GCRESTART, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL, LUA_GCSTEP, LUA_GCSTOP, LUA_HOOKCALL,
-    LUA_HOOKCOUNT, LUA_HOOKLINE, LUA_HOOKRET, LUA_HOOKTAILCALL, LUA_MASKCALL, LUA_MASKCOUNT,
-    LUA_MASKLINE, LUA_MASKRET, LUA_MINSTACK, LUA_MULTRET, LUA_OK, LUA_OPADD, LUA_OPDIV, LUA_OPEQ,
-    LUA_OPLE, LUA_OPLT, LUA_OPMOD, LUA_OPMUL, LUA_OPPOW, LUA_OPSUB, LUA_OPUNM, LUA_REGISTRYINDEX,
-    LUA_SIGNATURE, LUA_TBOOLEAN, LUA_TFUNCTION, LUA_TLIGHTUSERDATA, LUA_TNIL, LUA_TNONE,
-    LUA_TNUMBER, LUA_TSTRING, LUA_TTABLE, LUA_TTHREAD, LUA_TUSERDATA, LUA_YIELD,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lua::{
-    LUA_OPBAND, LUA_OPBNOT, LUA_OPBOR, LUA_OPBXOR, LUA_OPIDIV, LUA_OPSHL, LUA_OPSHR,
-};
-
-#[cfg(feature = "lua54")]
-pub use self::lua::{LUA_GCGEN, LUA_GCINC};
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub use self::lua::{LUA_GCISRUNNING, LUA_RIDX_GLOBALS, LUA_RIDX_MAINTHREAD};
-
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub use self::lua::LUA_ERRGCMM;
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use self::lua::{LUA_ENVIRONINDEX, LUA_GLOBALSINDEX};
-
-// constants from lauxlib.h
-pub use self::lauxlib::{LUA_ERRFILE, LUA_NOREF, LUA_REFNIL};
-
-// constants from lualib.h
-pub use self::lualib::{
-    LUA_COLIBNAME, LUA_DBLIBNAME, LUA_IOLIBNAME, LUA_LOADLIBNAME, LUA_MATHLIBNAME, LUA_OSLIBNAME,
-    LUA_STRLIBNAME, LUA_TABLIBNAME,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lualib::LUA_UTF8LIBNAME;
-
-#[cfg(any(feature = "lua52", feature = "luajit"))]
-pub use self::lualib::LUA_BITLIBNAME;
-
-#[cfg(feature = "luajit")]
-pub use self::lualib::{LUA_FFILIBNAME, LUA_JITLIBNAME};
-
-// Not actually defined in lua.h / luaconf.h
-pub const LUA_MAX_UPVALUES: c_int = 255;
-
-// 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",
-    target_arch = "riscv32"
-)))]
-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"
-)))]
-pub const SYS_MIN_ALIGN: usize = 16;
-
-#[allow(unused_imports, dead_code, non_camel_case_types)]
-#[allow(clippy::unreadable_literal)]
-mod glue {
-    include!(concat!(env!("OUT_DIR"), "/glue.rs"));
-}
-
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-mod compat53;
-
-mod lauxlib;
-mod lua;
-mod luaconf;
-mod lualib;
-
-pub mod safe;

src/ffi/safe.rs

@@ -1,278 +0,0 @@
-use std::ffi::CString;
-use std::os::raw::{c_char, c_int, c_void};
-
-use crate::error::Result;
-use crate::util::protect_lua;
-
-use super::lua::{lua_CFunction, lua_Debug, lua_Integer, lua_State};
-
-extern "C" {
-    #[link_name = "MLUA_WRAPPED_ERROR_SIZE"]
-    pub static mut WRAPPED_ERROR_SIZE: usize;
-    #[link_name = "MLUA_WRAPPED_PANIC_SIZE"]
-    pub static mut WRAPPED_PANIC_SIZE: usize;
-    #[link_name = "MLUA_WRAPPED_ERROR_KEY"]
-    pub static mut WRAPPED_ERROR_KEY: *const c_void;
-    #[link_name = "MLUA_WRAPPED_PANIC_KEY"]
-    pub static mut WRAPPED_PANIC_KEY: *const c_void;
-
-    pub fn lua_call_mlua_hook_proc(L: *mut lua_State, ar: *mut lua_Debug);
-
-    pub fn meta_index_impl(state: *mut lua_State) -> c_int;
-    pub fn meta_newindex_impl(state: *mut lua_State) -> c_int;
-    pub fn bind_call_impl(state: *mut lua_State) -> c_int;
-    pub fn error_traceback(state: *mut lua_State) -> c_int;
-    pub fn lua_nopanic_pcall(state: *mut lua_State) -> c_int;
-    pub fn lua_nopanic_xpcall(state: *mut lua_State) -> c_int;
-
-    fn lua_gc_s(L: *mut lua_State) -> c_int;
-    fn luaL_ref_s(L: *mut lua_State) -> c_int;
-    fn lua_pushlstring_s(L: *mut lua_State) -> c_int;
-    fn lua_tolstring_s(L: *mut lua_State) -> c_int;
-    fn lua_newthread_s(L: *mut lua_State) -> c_int;
-    fn lua_newuserdata_s(L: *mut lua_State) -> c_int;
-    fn lua_newwrappederror_s(L: *mut lua_State) -> c_int;
-    fn lua_pushcclosure_s(L: *mut lua_State) -> c_int;
-    fn lua_pushrclosure_s(L: *mut lua_State) -> c_int;
-    fn luaL_requiref_s(L: *mut lua_State) -> c_int;
-    fn error_traceback_s(L: *mut lua_State) -> c_int;
-
-    fn lua_newtable_s(L: *mut lua_State) -> c_int;
-    fn lua_createtable_s(L: *mut lua_State) -> c_int;
-    fn lua_gettable_s(L: *mut lua_State) -> c_int;
-    fn lua_settable_s(L: *mut lua_State) -> c_int;
-    fn lua_geti_s(L: *mut lua_State) -> c_int;
-    fn lua_rawset_s(L: *mut lua_State) -> c_int;
-    fn lua_rawseti_s(L: *mut lua_State) -> c_int;
-    fn lua_rawsetp_s(L: *mut lua_State) -> c_int;
-    fn lua_rawsetfield_s(L: *mut lua_State) -> c_int;
-    fn lua_rawinsert_s(L: *mut lua_State) -> c_int;
-    fn lua_rawremove_s(L: *mut lua_State) -> c_int;
-    fn luaL_len_s(L: *mut lua_State) -> c_int;
-    fn lua_next_s(L: *mut lua_State) -> c_int;
-}
-
-#[repr(C)]
-struct StringArg {
-    data: *const c_char,
-    len: usize,
-}
-
-//
-// Common functions
-//
-
-// Uses 4 stack spaces
-pub unsafe fn lua_gc(state: *mut lua_State, what: c_int, data: c_int) -> Result<c_int> {
-    super::lua_pushinteger(state, what as lua_Integer);
-    super::lua_pushinteger(state, data as lua_Integer);
-    protect_lua(state, 2, lua_gc_s)?;
-    let ret = super::lua_tointeger(state, -1) as c_int;
-    super::lua_pop(state, 1);
-    Ok(ret)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn luaL_ref(state: *mut lua_State, table: c_int) -> Result<c_int> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -2, 1);
-    protect_lua(state, 2, luaL_ref_s)?;
-    let ret = super::lua_tointeger(state, -1) as c_int;
-    super::lua_pop(state, 1);
-    Ok(ret)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_pushstring<S: AsRef<[u8]> + ?Sized>(state: *mut lua_State, s: &S) -> Result<()> {
-    let s = s.as_ref();
-    let s = StringArg {
-        data: s.as_ptr() as *const c_char,
-        len: s.len(),
-    };
-    super::lua_pushlightuserdata(state, &s as *const StringArg as *mut c_void);
-    protect_lua(state, 1, lua_pushlstring_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_tolstring(
-    state: *mut lua_State,
-    index: c_int,
-    len: *mut usize,
-) -> Result<*const c_char> {
-    let index = super::lua_absindex(state, index);
-    super::lua_pushvalue(state, index);
-    super::lua_pushlightuserdata(state, len as *mut c_void);
-    protect_lua(state, 2, lua_tolstring_s)?;
-    let s = super::lua_touserdata(state, -1);
-    super::lua_pop(state, 1);
-    super::lua_replace(state, index);
-    Ok(s as *const c_char)
-}
-
-// Uses 2 stack spaces
-pub unsafe fn lua_newthread(state: *mut lua_State) -> Result<*mut lua_State> {
-    protect_lua(state, 0, lua_newthread_s)?;
-    Ok(super::lua_tothread(state, -1))
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_newuserdata(state: *mut lua_State, size: usize) -> Result<*mut c_void> {
-    super::lua_pushinteger(state, size as lua_Integer);
-    protect_lua(state, 1, lua_newuserdata_s)?;
-    Ok(super::lua_touserdata(state, -1))
-}
-
-// Uses 2 stack spaces
-pub unsafe fn lua_newwrappederror(state: *mut lua_State) -> Result<*mut c_void> {
-    protect_lua(state, 0, lua_newwrappederror_s)?;
-    Ok(super::lua_touserdata(state, -1))
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_pushcclosure(state: *mut lua_State, f: lua_CFunction, n: c_int) -> Result<()> {
-    super::lua_pushlightuserdata(state, f as *mut c_void);
-    protect_lua(state, n + 1, lua_pushcclosure_s)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_pushrclosure(state: *mut lua_State, f: lua_CFunction, n: c_int) -> Result<()> {
-    super::lua_pushlightuserdata(state, f as *mut c_void);
-    if n > 0 {
-        super::lua_rotate(state, -n - 1, 1);
-    }
-    protect_lua(state, n + 1, lua_pushrclosure_s)
-}
-
-// Uses 5 stack spaces
-pub unsafe fn luaL_requiref<S: AsRef<[u8]> + ?Sized>(
-    state: *mut lua_State,
-    modname: &S,
-    openf: lua_CFunction,
-    glb: c_int,
-) -> Result<()> {
-    let modname = mlua_expect!(CString::new(modname.as_ref()), "modname contains nil bytes");
-    super::lua_pushlightuserdata(state, modname.as_ptr() as *mut c_void);
-    super::lua_pushlightuserdata(state, openf as *mut c_void);
-    super::lua_pushinteger(state, glb as lua_Integer);
-    protect_lua(state, 3, luaL_requiref_s)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn error_traceback2(state: *mut lua_State, state2: *mut lua_State) -> Result<()> {
-    mlua_assert!(
-        state != state2,
-        "error_traceback2 must be used with two different states"
-    );
-    super::lua_pushlightuserdata(state, state2);
-    protect_lua(state, 1, error_traceback_s)
-}
-
-//
-// Table functions
-//
-
-// Uses 2 stack spaces
-pub unsafe fn lua_newtable(state: *mut lua_State) -> Result<()> {
-    protect_lua(state, 0, lua_newtable_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_createtable(state: *mut lua_State, narr: c_int, nrec: c_int) -> Result<()> {
-    super::lua_pushinteger(state, narr as lua_Integer);
-    super::lua_pushinteger(state, nrec as lua_Integer);
-    protect_lua(state, 2, lua_createtable_s)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_gettable(state: *mut lua_State, table: c_int) -> Result<()> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -2, 1);
-    protect_lua(state, 2, lua_gettable_s)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_settable(state: *mut lua_State, table: c_int) -> Result<()> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -3, 1);
-    protect_lua(state, 3, lua_settable_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_geti(state: *mut lua_State, table: c_int, i: lua_Integer) -> Result<c_int> {
-    super::lua_pushvalue(state, table);
-    super::lua_pushinteger(state, i);
-    protect_lua(state, 2, lua_geti_s).map(|_| super::lua_type(state, -1))
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_rawset(state: *mut lua_State, table: c_int) -> Result<()> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -3, 1);
-    protect_lua(state, 3, lua_rawset_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_rawseti(state: *mut lua_State, table: c_int, i: lua_Integer) -> Result<()> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -2, 1);
-    super::lua_pushinteger(state, i);
-    protect_lua(state, 3, lua_rawseti_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_rawsetp(state: *mut lua_State, table: c_int, ptr: *const c_void) -> Result<()> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -2, 1);
-    super::lua_pushlightuserdata(state, ptr as *mut c_void);
-    protect_lua(state, 3, lua_rawsetp_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_rawsetfield<S>(state: *mut lua_State, table: c_int, field: &S) -> Result<()>
-where
-    S: AsRef<[u8]> + ?Sized,
-{
-    let field = field.as_ref();
-    let s = StringArg {
-        data: field.as_ptr() as *const c_char,
-        len: field.len(),
-    };
-    super::lua_pushvalue(state, table);
-    super::lua_pushlightuserdata(state, &s as *const StringArg as *mut c_void);
-    super::lua_rotate(state, -3, 2);
-    protect_lua(state, 3, lua_rawsetfield_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_rawinsert(state: *mut lua_State, table: c_int, i: lua_Integer) -> Result<()> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -2, 1);
-    super::lua_pushinteger(state, i);
-    protect_lua(state, 3, lua_rawinsert_s)
-}
-
-// Uses 4 stack spaces
-pub unsafe fn lua_rawremove(state: *mut lua_State, table: c_int, i: lua_Integer) -> Result<()> {
-    super::lua_pushvalue(state, table);
-    super::lua_pushinteger(state, i);
-    protect_lua(state, 2, lua_rawremove_s)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn luaL_len(state: *mut lua_State, table: c_int) -> Result<lua_Integer> {
-    super::lua_pushvalue(state, table);
-    protect_lua(state, 1, luaL_len_s)?;
-    let ret = super::lua_tointeger(state, -1);
-    super::lua_pop(state, 1);
-    Ok(ret)
-}
-
-// Uses 3 stack spaces
-pub unsafe fn lua_next(state: *mut lua_State, table: c_int) -> Result<lua_Integer> {
-    super::lua_pushvalue(state, table);
-    super::lua_rotate(state, -2, 1);
-    protect_lua(state, 2, lua_next_s)?;
-    let ret = super::lua_tointeger(state, -1);
-    super::lua_pop(state, 1);
-    Ok(ret)
-}

src/ffi/shim/compat-5.3.c

@@ -1,953 +0,0 @@
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-#include <stdio.h>
-#include "compat-5.3.h"
-
-/* don't compile it again if it already is included via compat53.h */
-#ifndef COMPAT53_C_
-#define COMPAT53_C_
-
-
-
-/* definitions for Lua 5.1 only */
-#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
-
-#ifndef COMPAT53_FOPEN_NO_LOCK
-#  if defined(_MSC_VER)
-#    define COMPAT53_FOPEN_NO_LOCK 1
-#  else /* otherwise */
-#    define COMPAT53_FOPEN_NO_LOCK 0
-#  endif /* VC++ only so far */
-#endif /* No-lock fopen_s usage if possible */
-
-#if defined(_MSC_VER) && COMPAT53_FOPEN_NO_LOCK
-#  include <share.h>
-#endif /* VC++ _fsopen for share-allowed file read */
-
-#ifndef COMPAT53_HAVE_STRERROR_R
-#  if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
-      (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600) || \
-      defined(__APPLE__)
-#    define COMPAT53_HAVE_STRERROR_R 1
-#  else /* none of the defines matched: define to 0 */
-#    define COMPAT53_HAVE_STRERROR_R 0
-#  endif /* have strerror_r of some form */
-#endif /* strerror_r */
-
-#ifndef COMPAT53_HAVE_STRERROR_S
-#  if defined(_MSC_VER) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \
-      defined(__STDC_LIB_EXT1__) && __STDC_LIB_EXT1__)
-#    define COMPAT53_HAVE_STRERROR_S 1
-#  else /* not VC++ or C11 */
-#    define COMPAT53_HAVE_STRERROR_S 0
-#  endif /* strerror_s from VC++ or C11 */
-#endif /* strerror_s */
-
-#ifndef COMPAT53_LUA_FILE_BUFFER_SIZE
-#  define COMPAT53_LUA_FILE_BUFFER_SIZE 4096
-#endif /* Lua File Buffer Size */
-
-
-static char* compat53_strerror (int en, char* buff, size_t sz) {
-#if COMPAT53_HAVE_STRERROR_R
-  /* use strerror_r here, because it's available on these specific platforms */
-  if (sz > 0) {
-    buff[0] = '\0';
-    /* we don't care whether the GNU version or the XSI version is used: */
-    if (strerror_r(en, buff, sz)) {
-      /* Yes, we really DO want to ignore the return value!
-       * GCC makes that extra hard, not even a (void) cast will do. */
-    }
-    if (buff[0] == '\0') {
-      /* Buffer is unchanged, so we probably have called GNU strerror_r which
-       * returned a static constant string. Chances are that strerror will
-       * return the same static constant string and therefore be thread-safe. */
-      return strerror(en);
-    }
-  }
-  return buff; /* sz is 0 *or* strerror_r wrote into the buffer */
-#elif COMPAT53_HAVE_STRERROR_S
-  /* for MSVC and other C11 implementations, use strerror_s since it's
-   * provided by default by the libraries */
-  strerror_s(buff, sz, en);
-  return buff;
-#else
-  /* fallback, but strerror is not guaranteed to be threadsafe due to modifying
-   * errno itself and some impls not locking a static buffer for it ... but most
-   * known systems have threadsafe errno: this might only change if the locale
-   * is changed out from under someone while this function is being called */
-  (void)buff;
-  (void)sz;
-  return strerror(en);
-#endif
-}
-
-
-COMPAT53_API int lua_absindex (lua_State *L, int i) {
-  if (i < 0 && i > LUA_REGISTRYINDEX)
-    i += lua_gettop(L) + 1;
-  return i;
-}
-
-
-static void compat53_call_lua (lua_State *L, char const code[], size_t len,
-                               int nargs, int nret) {
-  lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
-  if (lua_type(L, -1) != LUA_TFUNCTION) {
-    lua_pop(L, 1);
-    if (luaL_loadbuffer(L, code, len, "=none"))
-      lua_error(L);
-    lua_pushvalue(L, -1);
-    lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
-  }
-  lua_insert(L, -nargs-1);
-  lua_call(L, nargs, nret);
-}
-
-
-static const char compat53_arith_code[] =
-  "local op,a,b=...\n"
-  "if op==0 then return a+b\n"
-  "elseif op==1 then return a-b\n"
-  "elseif op==2 then return a*b\n"
-  "elseif op==3 then return a/b\n"
-  "elseif op==4 then return a%b\n"
-  "elseif op==5 then return a^b\n"
-  "elseif op==6 then return -a\n"
-  "end\n";
-
-COMPAT53_API void lua_arith (lua_State *L, int op) {
-  if (op < LUA_OPADD || op > LUA_OPUNM)
-    luaL_error(L, "invalid 'op' argument for lua_arith");
-  luaL_checkstack(L, 5, "not enough stack slots");
-  if (op == LUA_OPUNM)
-    lua_pushvalue(L, -1);
-  lua_pushnumber(L, op);
-  lua_insert(L, -3);
-  compat53_call_lua(L, compat53_arith_code,
-                    sizeof(compat53_arith_code)-1, 3, 1);
-}
-
-
-static const char compat53_compare_code[] =
-  "local a,b=...\n"
-  "return a<=b\n";
-
-COMPAT53_API int lua_compare (lua_State *L, int idx1, int idx2, int op) {
-  int result = 0;
-  switch (op) {
-    case LUA_OPEQ:
-      return lua_equal(L, idx1, idx2);
-    case LUA_OPLT:
-      return lua_lessthan(L, idx1, idx2);
-    case LUA_OPLE:
-      luaL_checkstack(L, 5, "not enough stack slots");
-      idx1 = lua_absindex(L, idx1);
-      idx2 = lua_absindex(L, idx2);
-      lua_pushvalue(L, idx1);
-      lua_pushvalue(L, idx2);
-      compat53_call_lua(L, compat53_compare_code,
-                        sizeof(compat53_compare_code)-1, 2, 1);
-      result = lua_toboolean(L, -1);
-      lua_pop(L, 1);
-      return result;
-    default:
-      luaL_error(L, "invalid 'op' argument for lua_compare");
-  }
-  return 0;
-}
-
-
-COMPAT53_API void lua_copy (lua_State *L, int from, int to) {
-  int abs_to = lua_absindex(L, to);
-  luaL_checkstack(L, 1, "not enough stack slots");
-  lua_pushvalue(L, from);
-  lua_replace(L, abs_to);
-}
-
-
-COMPAT53_API void lua_len (lua_State *L, int i) {
-  switch (lua_type(L, i)) {
-    case LUA_TSTRING:
-      lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
-      break;
-    case LUA_TTABLE:
-      if (!luaL_callmeta(L, i, "__len"))
-        lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
-      break;
-    case LUA_TUSERDATA:
-      if (luaL_callmeta(L, i, "__len"))
-        break;
-      /* FALLTHROUGH */
-    default:
-      luaL_error(L, "attempt to get length of a %s value",
-                 lua_typename(L, lua_type(L, i)));
-  }
-}
-
-
-COMPAT53_API int lua_rawgetp (lua_State *L, int i, const void *p) {
-  int abs_i = lua_absindex(L, i);
-  lua_pushlightuserdata(L, (void*)p);
-  lua_rawget(L, abs_i);
-  return lua_type(L, -1);
-}
-
-COMPAT53_API void lua_rawsetp (lua_State *L, int i, const void *p) {
-  int abs_i = lua_absindex(L, i);
-  luaL_checkstack(L, 1, "not enough stack slots");
-  lua_pushlightuserdata(L, (void*)p);
-  lua_insert(L, -2);
-  lua_rawset(L, abs_i);
-}
-
-
-COMPAT53_API lua_Number lua_tonumberx (lua_State *L, int i, int *isnum) {
-  lua_Number n = lua_tonumber(L, i);
-  if (isnum != NULL) {
-    *isnum = (n != 0 || lua_isnumber(L, i));
-  }
-  return n;
-}
-
-
-COMPAT53_API void luaL_checkversion (lua_State *L) {
-  (void)L;
-}
-
-
-COMPAT53_API void luaL_checkstack (lua_State *L, int sp, const char *msg) {
-  if (!lua_checkstack(L, sp+LUA_MINSTACK)) {
-    if (msg != NULL)
-      luaL_error(L, "stack overflow (%s)", msg);
-    else {
-      lua_pushliteral(L, "stack overflow");
-      lua_error(L);
-    }
-  }
-}
-
-
-COMPAT53_API int luaL_getsubtable (lua_State *L, int i, const char *name) {
-  int abs_i = lua_absindex(L, i);
-  luaL_checkstack(L, 3, "not enough stack slots");
-  lua_pushstring(L, name);
-  lua_gettable(L, abs_i);
-  if (lua_istable(L, -1))
-    return 1;
-  lua_pop(L, 1);
-  lua_newtable(L);
-  lua_pushstring(L, name);
-  lua_pushvalue(L, -2);
-  lua_settable(L, abs_i);
-  return 0;
-}
-
-
-COMPAT53_API lua_Integer luaL_len (lua_State *L, int i) {
-  lua_Integer res = 0;
-  int isnum = 0;
-  luaL_checkstack(L, 1, "not enough stack slots");
-  lua_len(L, i);
-  res = lua_tointegerx(L, -1, &isnum);
-  lua_pop(L, 1);
-  if (!isnum)
-    luaL_error(L, "object length is not an integer");
-  return res;
-}
-
-
-COMPAT53_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
-  luaL_checkstack(L, nup+1, "too many upvalues");
-  for (; l->name != NULL; l++) {  /* fill the table with given functions */
-    int i;
-    lua_pushstring(L, l->name);
-    for (i = 0; i < nup; i++)  /* copy upvalues to the top */
-      lua_pushvalue(L, -(nup + 1));
-    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
-    lua_settable(L, -(nup + 3)); /* table must be below the upvalues, the name and the closure */
-  }
-  lua_pop(L, nup);  /* remove upvalues */
-}
-
-
-COMPAT53_API void luaL_setmetatable (lua_State *L, const char *tname) {
-  luaL_checkstack(L, 1, "not enough stack slots");
-  luaL_getmetatable(L, tname);
-  lua_setmetatable(L, -2);
-}
-
-
-COMPAT53_API void *luaL_testudata (lua_State *L, int i, const char *tname) {
-  void *p = lua_touserdata(L, i);
-  luaL_checkstack(L, 2, "not enough stack slots");
-  if (p == NULL || !lua_getmetatable(L, i))
-    return NULL;
-  else {
-    int res = 0;
-    luaL_getmetatable(L, tname);
-    res = lua_rawequal(L, -1, -2);
-    lua_pop(L, 2);
-    if (!res)
-      p = NULL;
-  }
-  return p;
-}
-
-
-static int compat53_countlevels (lua_State *L) {
-  lua_Debug ar;
-  int li = 1, le = 1;
-  /* find an upper bound */
-  while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }
-  /* do a binary search */
-  while (li < le) {
-    int m = (li + le)/2;
-    if (lua_getstack(L, m, &ar)) li = m + 1;
-    else le = m;
-  }
-  return le - 1;
-}
-
-static int compat53_findfield (lua_State *L, int objidx, int level) {
-  if (level == 0 || !lua_istable(L, -1))
-    return 0;  /* not found */
-  lua_pushnil(L);  /* start 'next' loop */
-  while (lua_next(L, -2)) {  /* for each pair in table */
-    if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
-      if (lua_rawequal(L, objidx, -1)) {  /* found object? */
-        lua_pop(L, 1);  /* remove value (but keep name) */
-        return 1;
-      }
-      else if (compat53_findfield(L, objidx, level - 1)) {  /* try recursively */
-        lua_remove(L, -2);  /* remove table (but keep name) */
-        lua_pushliteral(L, ".");
-        lua_insert(L, -2);  /* place '.' between the two names */
-        lua_concat(L, 3);
-        return 1;
-      }
-    }
-    lua_pop(L, 1);  /* remove value */
-  }
-  return 0;  /* not found */
-}
-
-static int compat53_pushglobalfuncname (lua_State *L, lua_Debug *ar) {
-  int top = lua_gettop(L);
-  lua_getinfo(L, "f", ar);  /* push function */
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  if (compat53_findfield(L, top + 1, 2)) {
-    lua_copy(L, -1, top + 1);  /* move name to proper place */
-    lua_pop(L, 2);  /* remove pushed values */
-    return 1;
-  }
-  else {
-    lua_settop(L, top);  /* remove function and global table */
-    return 0;
-  }
-}
-
-static void compat53_pushfuncname (lua_State *L, lua_Debug *ar) {
-  if (*ar->namewhat != '\0')  /* is there a name? */
-    lua_pushfstring(L, "function " LUA_QS, ar->name);
-  else if (*ar->what == 'm')  /* main? */
-      lua_pushliteral(L, "main chunk");
-  else if (*ar->what == 'C') {
-    if (compat53_pushglobalfuncname(L, ar)) {
-      lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
-      lua_remove(L, -2);  /* remove name */
-    }
-    else
-      lua_pushliteral(L, "?");
-  }
-  else
-    lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
-}
-
-#define COMPAT53_LEVELS1 12  /* size of the first part of the stack */
-#define COMPAT53_LEVELS2 10  /* size of the second part of the stack */
-
-COMPAT53_API void luaL_traceback (lua_State *L, lua_State *L1,
-                                  const char *msg, int level) {
-  lua_Debug ar;
-  int top = lua_gettop(L);
-  int numlevels = compat53_countlevels(L1);
-  int mark = (numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2) ? COMPAT53_LEVELS1 : 0;
-  if (msg) lua_pushfstring(L, "%s\n", msg);
-  lua_pushliteral(L, "stack traceback:");
-  while (lua_getstack(L1, level++, &ar)) {
-    if (level == mark) {  /* too many levels? */
-      lua_pushliteral(L, "\n\t...");  /* add a '...' */
-      level = numlevels - COMPAT53_LEVELS2;  /* and skip to last ones */
-    }
-    else {
-      lua_getinfo(L1, "Slnt", &ar);
-      lua_pushfstring(L, "\n\t%s:", ar.short_src);
-      if (ar.currentline > 0)
-        lua_pushfstring(L, "%d:", ar.currentline);
-      lua_pushliteral(L, " in ");
-      compat53_pushfuncname(L, &ar);
-      lua_concat(L, lua_gettop(L) - top);
-    }
-  }
-  lua_concat(L, lua_gettop(L) - top);
-}
-
-
-COMPAT53_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
-  const char *serr = NULL;
-  int en = errno;  /* calls to Lua API may change this value */
-  char buf[512] = { 0 };
-  if (stat) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);
-    serr = compat53_strerror(en, buf, sizeof(buf));
-    if (fname)
-      lua_pushfstring(L, "%s: %s", fname, serr);
-    else
-      lua_pushstring(L, serr);
-    lua_pushnumber(L, (lua_Number)en);
-    return 3;
-  }
-}
-
-
-static int compat53_checkmode (lua_State *L, const char *mode, const char *modename, int err) {
-  if (mode && strchr(mode, modename[0]) == NULL) {
-    lua_pushfstring(L, "attempt to load a %s chunk (mode is '%s')", modename, mode);
-    return err;
-  }
-  return LUA_OK;
-}
-
-
-typedef struct {
-  lua_Reader reader;
-  void *ud;
-  int has_peeked_data;
-  const char *peeked_data;
-  size_t peeked_data_size;
-} compat53_reader_data;
-
-
-static const char *compat53_reader (lua_State *L, void *ud, size_t *size) {
-  compat53_reader_data *data = (compat53_reader_data *)ud;
-  if (data->has_peeked_data) {
-    data->has_peeked_data = 0;
-    *size = data->peeked_data_size;
-    return data->peeked_data;
-  } else
-    return data->reader(L, data->ud, size);
-}
-
-
-COMPAT53_API int lua_load (lua_State *L, lua_Reader reader, void *data, const char *source, const char *mode) {
-  int status = LUA_OK;
-  compat53_reader_data compat53_data = { 0, NULL, 1, 0, 0 };
-  compat53_data.reader = reader;
-  compat53_data.ud = data;
-  compat53_data.peeked_data = reader(L, data, &(compat53_data.peeked_data_size));
-  if (compat53_data.peeked_data && compat53_data.peeked_data_size &&
-      compat53_data.peeked_data[0] == LUA_SIGNATURE[0]) /* binary file? */
-      status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
-  else
-      status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
-  if (status != LUA_OK)
-    return status;
-  /* we need to call the original 5.1 version of lua_load! */
-#undef lua_load
-  return lua_load(L, compat53_reader, &compat53_data, source);
-#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
-}
-
-
-typedef struct {
-  int n;  /* number of pre-read characters */
-  FILE *f;  /* file being read */
-  char buff[COMPAT53_LUA_FILE_BUFFER_SIZE];  /* area for reading file */
-} compat53_LoadF;
-
-
-static const char *compat53_getF (lua_State *L, void *ud, size_t *size) {
-  compat53_LoadF *lf = (compat53_LoadF *)ud;
-  (void)L;  /* not used */
-  if (lf->n > 0) {  /* are there pre-read characters to be read? */
-    *size = lf->n;  /* return them (chars already in buffer) */
-    lf->n = 0;  /* no more pre-read characters */
-  }
-  else {  /* read a block from file */
-    /* 'fread' can return > 0 *and* set the EOF flag. If next call to
-       'compat53_getF' called 'fread', it might still wait for user input.
-       The next check avoids this problem. */
-    if (feof(lf->f)) return NULL;
-    *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);  /* read block */
-  }
-  return lf->buff;
-}
-
-
-static int compat53_errfile (lua_State *L, const char *what, int fnameindex) {
-  char buf[512] = {0};
-  const char *serr = compat53_strerror(errno, buf, sizeof(buf));
-  const char *filename = lua_tostring(L, fnameindex) + 1;
-  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
-  lua_remove(L, fnameindex);
-  return LUA_ERRFILE;
-}
-
-
-static int compat53_skipBOM (compat53_LoadF *lf) {
-  const char *p = "\xEF\xBB\xBF";  /* UTF-8 BOM mark */
-  int c;
-  lf->n = 0;
-  do {
-    c = getc(lf->f);
-    if (c == EOF || c != *(const unsigned char *)p++) return c;
-    lf->buff[lf->n++] = (char)c;  /* to be read by the parser */
-  } while (*p != '\0');
-  lf->n = 0;  /* prefix matched; discard it */
-  return getc(lf->f);  /* return next character */
-}
-
-
-/*
-** reads the first character of file 'f' and skips an optional BOM mark
-** in its beginning plus its first line if it starts with '#'. Returns
-** true if it skipped the first line.  In any case, '*cp' has the
-** first "valid" character of the file (after the optional BOM and
-** a first-line comment).
-*/
-static int compat53_skipcomment (compat53_LoadF *lf, int *cp) {
-  int c = *cp = compat53_skipBOM(lf);
-  if (c == '#') {  /* first line is a comment (Unix exec. file)? */
-    do {  /* skip first line */
-      c = getc(lf->f);
-    } while (c != EOF && c != '\n');
-    *cp = getc(lf->f);  /* skip end-of-line, if present */
-    return 1;  /* there was a comment */
-  }
-  else return 0;  /* no comment */
-}
-
-
-COMPAT53_API int luaL_loadfilex (lua_State *L, const char *filename, const char *mode) {
-  compat53_LoadF lf;
-  int status, readstatus;
-  int c;
-  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
-  if (filename == NULL) {
-    lua_pushliteral(L, "=stdin");
-    lf.f = stdin;
-  }
-  else {
-    lua_pushfstring(L, "@%s", filename);
-#if defined(_MSC_VER)
-    /* This code is here to stop a deprecation error that stops builds
-     * if a certain macro is defined. While normally not caring would
-     * be best, some header-only libraries and builds can't afford to
-     * dictate this to the user. A quick check shows that fopen_s this
-     * goes back to VS 2005, and _fsopen goes back to VS 2003 .NET,
-     * possibly even before that so we don't need to do any version
-     * number checks, since this has been there since forever.  */
-
-    /* TO USER: if you want the behavior of typical fopen_s/fopen,
-     * which does lock the file on VC++, define the macro used below to 0 */
-#if COMPAT53_FOPEN_NO_LOCK
-    lf.f = _fsopen(filename, "r", _SH_DENYNO); /* do not lock the file in any way */
-    if (lf.f == NULL)
-      return compat53_errfile(L, "open", fnameindex);
-#else /* use default locking version */
-    if (fopen_s(&lf.f, filename, "r") != 0)
-      return compat53_errfile(L, "open", fnameindex);
-#endif /* Locking vs. No-locking fopen variants */
-#else
-    lf.f = fopen(filename, "r"); /* default stdlib doesn't forcefully lock files here */
-    if (lf.f == NULL) return compat53_errfile(L, "open", fnameindex);
-#endif
-  }
-  if (compat53_skipcomment(&lf, &c))  /* read initial portion */
-    lf.buff[lf.n++] = '\n';  /* add line to correct line numbers */
-  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
-#if defined(_MSC_VER)
-    if (freopen_s(&lf.f, filename, "rb", lf.f) != 0)
-      return compat53_errfile(L, "reopen", fnameindex);
-#else
-    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
-    if (lf.f == NULL) return compat53_errfile(L, "reopen", fnameindex);
-#endif
-    compat53_skipcomment(&lf, &c);  /* re-read initial portion */
-  }
-  if (c != EOF)
-    lf.buff[lf.n++] = (char)c;  /* 'c' is the first character of the stream */
-  status = lua_load(L, &compat53_getF, &lf, lua_tostring(L, -1), mode);
-  readstatus = ferror(lf.f);
-  if (filename) fclose(lf.f);  /* close file (even in case of errors) */
-  if (readstatus) {
-    lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */
-    return compat53_errfile(L, "read", fnameindex);
-  }
-  lua_remove(L, fnameindex);
-  return status;
-}
-
-
-COMPAT53_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t sz, const char *name, const char *mode) {
-  int status = LUA_OK;
-  if (sz > 0 && buff[0] == LUA_SIGNATURE[0]) {
-    status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
-  }
-  else {
-    status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
-  }
-  if (status != LUA_OK)
-    return status;
-  return luaL_loadbuffer(L, buff, sz, name);
-}
-
-
-#if !defined(l_inspectstat) && \
-    (defined(unix) || defined(__unix) || defined(__unix__) || \
-     defined(__TOS_AIX__) || defined(_SYSTYPE_BSD) || \
-     (defined(__APPLE__) && defined(__MACH__)))
-/* some form of unix; check feature macros in unistd.h for details */
-#  include <unistd.h>
-/* check posix version; the relevant include files and macros probably
- * were available before 2001, but I'm not sure */
-#  if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L
-#    include <sys/wait.h>
-#    define l_inspectstat(stat,what) \
-  if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \
-  else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }
-#  endif
-#endif
-
-/* provide default (no-op) version */
-#if !defined(l_inspectstat)
-#  define l_inspectstat(stat,what) ((void)0)
-#endif
-
-
-COMPAT53_API int luaL_execresult (lua_State *L, int stat) {
-  const char *what = "exit";
-  if (stat == -1)
-    return luaL_fileresult(L, 0, NULL);
-  else {
-    l_inspectstat(stat, what);
-    if (*what == 'e' && stat == 0)
-      lua_pushboolean(L, 1);
-    else
-      lua_pushnil(L);
-    lua_pushstring(L, what);
-    lua_pushinteger(L, stat);
-    return 3;
-  }
-}
-
-
-COMPAT53_API void luaL_buffinit (lua_State *L, luaL_Buffer_53 *B) {
-  /* make it crash if used via pointer to a 5.1-style luaL_Buffer */
-  B->b.p = NULL;
-  B->b.L = NULL;
-  B->b.lvl = 0;
-  /* reuse the buffer from the 5.1-style luaL_Buffer though! */
-  B->ptr = B->b.buffer;
-  B->capacity = LUAL_BUFFERSIZE;
-  B->nelems = 0;
-  B->L2 = L;
-}
-
-
-COMPAT53_API char *luaL_prepbuffsize (luaL_Buffer_53 *B, size_t s) {
-  if (B->capacity - B->nelems < s) { /* needs to grow */
-    char* newptr = NULL;
-    size_t newcap = B->capacity * 2;
-    if (newcap - B->nelems < s)
-      newcap = B->nelems + s;
-    if (newcap < B->capacity) /* overflow */
-      luaL_error(B->L2, "buffer too large");
-    newptr = (char*)lua_newuserdata(B->L2, newcap);
-    memcpy(newptr, B->ptr, B->nelems);
-    if (B->ptr != B->b.buffer)
-      lua_replace(B->L2, -2); /* remove old buffer */
-    B->ptr = newptr;
-    B->capacity = newcap;
-  }
-  return B->ptr+B->nelems;
-}
-
-
-COMPAT53_API void luaL_addlstring (luaL_Buffer_53 *B, const char *s, size_t l) {
-  memcpy(luaL_prepbuffsize(B, l), s, l);
-  luaL_addsize(B, l);
-}
-
-
-COMPAT53_API void luaL_addvalue (luaL_Buffer_53 *B) {
-  size_t len = 0;
-  const char *s = lua_tolstring(B->L2, -1, &len);
-  if (!s)
-    luaL_error(B->L2, "cannot convert value to string");
-  if (B->ptr != B->b.buffer)
-    lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
-  luaL_addlstring(B, s, len);
-  lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
-}
-
-
-void luaL_pushresult (luaL_Buffer_53 *B) {
-  lua_pushlstring(B->L2, B->ptr, B->nelems);
-  if (B->ptr != B->b.buffer)
-    lua_replace(B->L2, -2); /* remove userdata buffer */
-}
-
-
-#endif /* Lua 5.1 */
-
-
-
-/* definitions for Lua 5.1 and Lua 5.2 */
-#if defined( LUA_VERSION_NUM ) && LUA_VERSION_NUM <= 502
-
-
-COMPAT53_API int lua_geti (lua_State *L, int index, lua_Integer i) {
-  index = lua_absindex(L, index);
-  lua_pushinteger(L, i);
-  lua_gettable(L, index);
-  return lua_type(L, -1);
-}
-
-
-#ifndef LUA_EXTRASPACE
-#define LUA_EXTRASPACE (sizeof(void*))
-#endif
-
-COMPAT53_API void *lua_getextraspace (lua_State *L) {
-  int is_main = 0;
-  void *ptr = NULL;
-  luaL_checkstack(L, 4, "not enough stack slots available");
-  lua_pushliteral(L, "__compat53_extraspace");
-  lua_pushvalue(L, -1);
-  lua_rawget(L, LUA_REGISTRYINDEX);
-  if (!lua_istable(L, -1)) {
-    lua_pop(L, 1);
-    lua_createtable(L, 0, 2);
-    lua_createtable(L, 0, 1);
-    lua_pushliteral(L, "k");
-    lua_setfield(L, -2, "__mode");
-    lua_setmetatable(L, -2);
-    lua_pushvalue(L, -2);
-    lua_pushvalue(L, -2);
-    lua_rawset(L, LUA_REGISTRYINDEX);
-  }
-  lua_replace(L, -2);
-  is_main = lua_pushthread(L);
-  lua_rawget(L, -2);
-  ptr = lua_touserdata(L, -1);
-  if (!ptr) {
-    lua_pop(L, 1);
-    ptr = lua_newuserdata(L, LUA_EXTRASPACE);
-    if (is_main) {
-      memset(ptr, '\0', LUA_EXTRASPACE);
-      lua_pushthread(L);
-      lua_pushvalue(L, -2);
-      lua_rawset(L, -4);
-      lua_pushboolean(L, 1);
-      lua_pushvalue(L, -2);
-      lua_rawset(L, -4);
-    } else {
-      void* mptr = NULL;
-      lua_pushboolean(L, 1);
-      lua_rawget(L, -3);
-      mptr = lua_touserdata(L, -1);
-      if (mptr)
-        memcpy(ptr, mptr, LUA_EXTRASPACE);
-      else
-        memset(ptr, '\0', LUA_EXTRASPACE);
-      lua_pop(L, 1);
-      lua_pushthread(L);
-      lua_pushvalue(L, -2);
-      lua_rawset(L, -4);
-    }
-  }
-  lua_pop(L, 2);
-  return ptr;
-}
-
-
-COMPAT53_API int lua_isinteger (lua_State *L, int index) {
-  if (lua_type(L, index) == LUA_TNUMBER) {
-    lua_Number n = lua_tonumber(L, index);
-    lua_Integer i = lua_tointeger(L, index);
-    if (i == n)
-      return 1;
-  }
-  return 0;
-}
-
-
-COMPAT53_API lua_Integer lua_tointegerx (lua_State *L, int i, int *isnum) {
-  int ok = 0;
-  lua_Number n = lua_tonumberx(L, i, &ok);
-  if (ok) {
-    if (n == (lua_Integer)n) {
-      if (isnum)
-        *isnum = 1;
-      return (lua_Integer)n;
-    }
-  }
-  if (isnum)
-    *isnum = 0;
-  return 0;
-}
-
-
-static void compat53_reverse (lua_State *L, int a, int b) {
-  for (; a < b; ++a, --b) {
-    lua_pushvalue(L, a);
-    lua_pushvalue(L, b);
-    lua_replace(L, a);
-    lua_replace(L, b);
-  }
-}
-
-
-COMPAT53_API void lua_rotate (lua_State *L, int idx, int n) {
-  int n_elems = 0;
-  idx = lua_absindex(L, idx);
-  n_elems = lua_gettop(L)-idx+1;
-  if (n < 0)
-    n += n_elems;
-  if ( n > 0 && n < n_elems) {
-    luaL_checkstack(L, 2, "not enough stack slots available");
-    n = n_elems - n;
-    compat53_reverse(L, idx, idx+n-1);
-    compat53_reverse(L, idx+n, idx+n_elems-1);
-    compat53_reverse(L, idx, idx+n_elems-1);
-  }
-}
-
-
-COMPAT53_API void lua_seti (lua_State *L, int index, lua_Integer i) {
-  luaL_checkstack(L, 1, "not enough stack slots available");
-  index = lua_absindex(L, index);
-  lua_pushinteger(L, i);
-  lua_insert(L, -2);
-  lua_settable(L, index);
-}
-
-
-#if !defined(lua_str2number)
-#  define lua_str2number(s, p)  strtod((s), (p))
-#endif
-
-COMPAT53_API size_t lua_stringtonumber (lua_State *L, const char *s) {
-  char* endptr;
-  lua_Number n = lua_str2number(s, &endptr);
-  if (endptr != s) {
-    while (*endptr != '\0' && isspace((unsigned char)*endptr))
-      ++endptr;
-    if (*endptr == '\0') {
-      lua_pushnumber(L, n);
-      return endptr - s + 1;
-    }
-  }
-  return 0;
-}
-
-
-COMPAT53_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
-  if (!luaL_callmeta(L, idx, "__tostring")) {
-    int t = lua_type(L, idx), tt = 0;
-    char const* name = NULL;
-    switch (t) {
-      case LUA_TNIL:
-        lua_pushliteral(L, "nil");
-        break;
-      case LUA_TSTRING:
-      case LUA_TNUMBER:
-        lua_pushvalue(L, idx);
-        break;
-      case LUA_TBOOLEAN:
-        if (lua_toboolean(L, idx))
-          lua_pushliteral(L, "true");
-        else
-          lua_pushliteral(L, "false");
-        break;
-      default:
-        tt = luaL_getmetafield(L, idx, "__name");
-        name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
-        lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
-        if (tt != LUA_TNIL)
-          lua_replace(L, -2);
-        break;
-    }
-  } else {
-    if (!lua_isstring(L, -1))
-      luaL_error(L, "'__tostring' must return a string");
-  }
-  return lua_tolstring(L, -1, len);
-}
-
-
-COMPAT53_API void luaL_requiref (lua_State *L, const char *modname,
-                                 lua_CFunction openf, int glb) {
-  luaL_checkstack(L, 3, "not enough stack slots available");
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
-  if (lua_getfield(L, -1, modname) == LUA_TNIL) {
-    lua_pop(L, 1);
-    lua_pushcfunction(L, openf);
-    lua_pushstring(L, modname);
-#ifndef COMPAT53_LUAJIT
-    lua_call(L, 1, 1);
-    lua_pushvalue(L, -1);
-    lua_setfield(L, -3, modname);
-#else
-    lua_call(L, 1, 0);
-    lua_getfield(L, -1, modname);
-#endif /* COMPAT53_LUAJIT */
-  }
-  if (glb) {
-    lua_pushvalue(L, -1);
-    lua_setglobal(L, modname);
-  }
-  lua_replace(L, -2);
-}
-
-
-#endif /* Lua 5.1 and 5.2 */
-
-
-#endif /* COMPAT53_C_ */
-
-
-/*********************************************************************
-* This file contains parts of Lua 5.2's and Lua 5.3's source code:
-*
-* Copyright (C) 1994-2014 Lua.org, PUC-Rio.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*********************************************************************/
-

src/ffi/shim/compat-5.3.h

@@ -1,424 +0,0 @@
-#ifndef COMPAT53_H_
-#define COMPAT53_H_
-
-#include <stddef.h>
-#include <limits.h>
-#include <string.h>
-#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
-extern "C" {
-#endif
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
-}
-#endif
-
-
-#undef COMPAT53_INCLUDE_SOURCE
-#if defined(COMPAT53_PREFIX)
-/* - change the symbol names of functions to avoid linker conflicts
- * - compat-5.3.c needs to be compiled (and linked) separately
- */
-#  if !defined(COMPAT53_API)
-#    define COMPAT53_API extern
-#  endif
-#else /* COMPAT53_PREFIX */
-/* - make all functions static and include the source.
- * - compat-5.3.c doesn't need to be compiled (and linked) separately
- */
-#  define COMPAT53_PREFIX compat53
-#  undef COMPAT53_API
-#  if defined(__GNUC__) || defined(__clang__)
-#    define COMPAT53_API __attribute__((__unused__)) static
-#  else
-#    define COMPAT53_API static
-#  endif
-#  define COMPAT53_INCLUDE_SOURCE
-#endif /* COMPAT53_PREFIX */
-
-#define COMPAT53_CONCAT_HELPER(a, b) a##b
-#define COMPAT53_CONCAT(a, b) COMPAT53_CONCAT_HELPER(a, b)
-
-
-
-/* declarations for Lua 5.1 */
-#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
-
-/* XXX not implemented:
- * lua_arith (new operators)
- * lua_upvalueid
- * lua_upvaluejoin
- * lua_version
- * lua_yieldk
- */
-
-#ifndef LUA_OK
-#  define LUA_OK 0
-#endif
-#ifndef LUA_OPADD
-#  define LUA_OPADD 0
-#endif
-#ifndef LUA_OPSUB
-#  define LUA_OPSUB 1
-#endif
-#ifndef LUA_OPMUL
-#  define LUA_OPMUL 2
-#endif
-#ifndef LUA_OPDIV
-#  define LUA_OPDIV 3
-#endif
-#ifndef LUA_OPMOD
-#  define LUA_OPMOD 4
-#endif
-#ifndef LUA_OPPOW
-#  define LUA_OPPOW 5
-#endif
-#ifndef LUA_OPUNM
-#  define LUA_OPUNM 6
-#endif
-#ifndef LUA_OPEQ
-#  define LUA_OPEQ 0
-#endif
-#ifndef LUA_OPLT
-#  define LUA_OPLT 1
-#endif
-#ifndef LUA_OPLE
-#  define LUA_OPLE 2
-#endif
-
-/* LuaJIT/Lua 5.1 does not have the updated
- * error codes for thread status/function returns (but some patched versions do)
- * define it only if it's not found
- */
-#if !defined(LUA_ERRGCMM)
-/* Use + 2 because in some versions of Lua (Lua 5.1)
- * LUA_ERRFILE is defined as (LUA_ERRERR+1)
- * so we need to avoid it (LuaJIT might have something at this
- * integer value too)
- */
-#  define LUA_ERRGCMM (LUA_ERRERR + 2)
-#endif /* LUA_ERRGCMM define */
-
-typedef size_t lua_Unsigned;
-
-typedef struct luaL_Buffer_53 {
-  luaL_Buffer b; /* make incorrect code crash! */
-  char *ptr;
-  size_t nelems;
-  size_t capacity;
-  lua_State *L2;
-} luaL_Buffer_53;
-#define luaL_Buffer luaL_Buffer_53
-
-/* In PUC-Rio 5.1, userdata is a simple FILE*
- * In LuaJIT, it's a struct where the first member is a FILE*
- * We can't support the `closef` member
- */
-typedef struct luaL_Stream {
-  FILE *f;
-} luaL_Stream;
-
-#define lua_absindex COMPAT53_CONCAT(COMPAT53_PREFIX, _absindex)
-COMPAT53_API int lua_absindex (lua_State *L, int i);
-
-#define lua_arith COMPAT53_CONCAT(COMPAT53_PREFIX, _arith)
-COMPAT53_API void lua_arith (lua_State *L, int op);
-
-#define lua_compare COMPAT53_CONCAT(COMPAT53_PREFIX, _compare)
-COMPAT53_API int lua_compare (lua_State *L, int idx1, int idx2, int op);
-
-#define lua_copy COMPAT53_CONCAT(COMPAT53_PREFIX, _copy)
-COMPAT53_API void lua_copy (lua_State *L, int from, int to);
-
-#define lua_getuservalue(L, i) \
-  (lua_getfenv((L), (i)), lua_type((L), -1))
-#define lua_setuservalue(L, i) \
-  (luaL_checktype((L), -1, LUA_TTABLE), lua_setfenv((L), (i)))
-
-#define lua_len COMPAT53_CONCAT(COMPAT53_PREFIX, _len)
-COMPAT53_API void lua_len (lua_State *L, int i);
-
-#define lua_pushstring(L, s) \
-  (lua_pushstring((L), (s)), lua_tostring((L), -1))
-
-#define lua_pushlstring(L, s, len) \
-  ((((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len))), lua_tostring((L), -1))
-
-#ifndef luaL_newlibtable
-#  define luaL_newlibtable(L, l) \
-  (lua_createtable((L), 0, sizeof((l))/sizeof(*(l))-1))
-#endif
-#ifndef luaL_newlib
-#  define luaL_newlib(L, l) \
-  (luaL_newlibtable((L), (l)), luaL_register((L), NULL, (l)))
-#endif
-
-#define lua_pushglobaltable(L) \
-  lua_pushvalue((L), LUA_GLOBALSINDEX)
-
-#define lua_rawgetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawgetp)
-COMPAT53_API int lua_rawgetp (lua_State *L, int i, const void *p);
-
-#define lua_rawsetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawsetp)
-COMPAT53_API void lua_rawsetp(lua_State *L, int i, const void *p);
-
-#define lua_rawlen(L, i) lua_objlen((L), (i))
-
-#define lua_tointeger(L, i) lua_tointegerx((L), (i), NULL)
-
-#define lua_tonumberx COMPAT53_CONCAT(COMPAT53_PREFIX, _tonumberx)
-COMPAT53_API lua_Number lua_tonumberx (lua_State *L, int i, int *isnum);
-
-#define luaL_checkversion COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkversion)
-COMPAT53_API void luaL_checkversion (lua_State *L);
-
-#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
-COMPAT53_API int lua_load (lua_State *L, lua_Reader reader, void *data, const char* source, const char* mode);
-
-#define luaL_loadfilex COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadfilex)
-COMPAT53_API int luaL_loadfilex (lua_State *L, const char *filename, const char *mode);
-
-#define luaL_loadbufferx COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadbufferx)
-COMPAT53_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t sz, const char *name, const char *mode);
-
-#define luaL_checkstack COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkstack_53)
-COMPAT53_API void luaL_checkstack (lua_State *L, int sp, const char *msg);
-
-#define luaL_getsubtable COMPAT53_CONCAT(COMPAT53_PREFIX, L_getsubtable)
-COMPAT53_API int luaL_getsubtable (lua_State* L, int i, const char *name);
-
-#define luaL_len COMPAT53_CONCAT(COMPAT53_PREFIX, L_len)
-COMPAT53_API lua_Integer luaL_len (lua_State *L, int i);
-
-#define luaL_setfuncs COMPAT53_CONCAT(COMPAT53_PREFIX, L_setfuncs)
-COMPAT53_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);
-
-#define luaL_setmetatable COMPAT53_CONCAT(COMPAT53_PREFIX, L_setmetatable)
-COMPAT53_API void luaL_setmetatable (lua_State *L, const char *tname);
-
-#define luaL_testudata COMPAT53_CONCAT(COMPAT53_PREFIX, L_testudata)
-COMPAT53_API void *luaL_testudata (lua_State *L, int i, const char *tname);
-
-#define luaL_traceback COMPAT53_CONCAT(COMPAT53_PREFIX, L_traceback)
-COMPAT53_API void luaL_traceback (lua_State *L, lua_State *L1, const char *msg, int level);
-
-#define luaL_fileresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_fileresult)
-COMPAT53_API int luaL_fileresult (lua_State *L, int stat, const char *fname);
-
-#define luaL_execresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_execresult)
-COMPAT53_API int luaL_execresult (lua_State *L, int stat);
-
-#define lua_callk(L, na, nr, ctx, cont) \
-  ((void)(ctx), (void)(cont), lua_call((L), (na), (nr)))
-#define lua_pcallk(L, na, nr, err, ctx, cont) \
-  ((void)(ctx), (void)(cont), lua_pcall((L), (na), (nr), (err)))
-
-#define lua_resume(L, from, nargs) \
-  ((void)(from), lua_resume((L), (nargs)))
-
-#define luaL_buffinit COMPAT53_CONCAT(COMPAT53_PREFIX, _buffinit_53)
-COMPAT53_API void luaL_buffinit (lua_State *L, luaL_Buffer_53 *B);
-
-#define luaL_prepbuffsize COMPAT53_CONCAT(COMPAT53_PREFIX, _prepbufsize_53)
-COMPAT53_API char *luaL_prepbuffsize (luaL_Buffer_53 *B, size_t s);
-
-#define luaL_addlstring COMPAT53_CONCAT(COMPAT53_PREFIX, _addlstring_53)
-COMPAT53_API void luaL_addlstring (luaL_Buffer_53 *B, const char *s, size_t l);
-
-#define luaL_addvalue COMPAT53_CONCAT(COMPAT53_PREFIX, _addvalue_53)
-COMPAT53_API void luaL_addvalue (luaL_Buffer_53 *B);
-
-#define luaL_pushresult COMPAT53_CONCAT(COMPAT53_PREFIX, _pushresult_53)
-COMPAT53_API void luaL_pushresult (luaL_Buffer_53 *B);
-
-#undef luaL_buffinitsize
-#define luaL_buffinitsize(L, B, s) \
-  (luaL_buffinit((L), (B)), luaL_prepbuffsize((B), (s)))
-
-#undef luaL_prepbuffer
-#define luaL_prepbuffer(B) \
-  luaL_prepbuffsize((B), LUAL_BUFFERSIZE)
-
-#undef luaL_addchar
-#define luaL_addchar(B, c) \
-  ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize((B), 1)), \
-   ((B)->ptr[(B)->nelems++] = (c)))
-
-#undef luaL_addsize
-#define luaL_addsize(B, s) \
-  ((B)->nelems += (s))
-
-#undef luaL_addstring
-#define luaL_addstring(B, s) \
-  luaL_addlstring((B), (s), strlen((s)))
-
-#undef luaL_pushresultsize
-#define luaL_pushresultsize(B, s) \
-  (luaL_addsize((B), (s)), luaL_pushresult((B)))
-
-#if defined(LUA_COMPAT_APIINTCASTS)
-#define lua_pushunsigned(L, n) \
-  lua_pushinteger((L), (lua_Integer)(n))
-#define lua_tounsignedx(L, i, is) \
-  ((lua_Unsigned)lua_tointegerx((L), (i), (is)))
-#define lua_tounsigned(L, i) \
-  lua_tounsignedx((L), (i), NULL)
-#define luaL_checkunsigned(L, a) \
-  ((lua_Unsigned)luaL_checkinteger((L), (a)))
-#define luaL_optunsigned(L, a, d) \
-  ((lua_Unsigned)luaL_optinteger((L), (a), (lua_Integer)(d)))
-#endif
-
-#endif /* Lua 5.1 only */
-
-
-
-/* declarations for Lua 5.1 and 5.2 */
-#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
-
-typedef int lua_KContext;
-
-typedef int (*lua_KFunction)(lua_State *L, int status, lua_KContext ctx);
-
-#define lua_dump(L, w, d, s) \
-  ((void)(s), lua_dump((L), (w), (d)))
-
-#define lua_getfield(L, i, k) \
-  (lua_getfield((L), (i), (k)), lua_type((L), -1))
-
-#define lua_gettable(L, i) \
-  (lua_gettable((L), (i)), lua_type((L), -1))
-
-#define lua_geti COMPAT53_CONCAT(COMPAT53_PREFIX, _geti)
-COMPAT53_API int lua_geti (lua_State *L, int index, lua_Integer i);
-
-#define lua_getextraspace COMPAT53_CONCAT(COMPAT53_PREFIX, _getextraspace)
-COMPAT53_API void *lua_getextraspace (lua_State *L);
-
-#define lua_isinteger COMPAT53_CONCAT(COMPAT53_PREFIX, _isinteger)
-COMPAT53_API int lua_isinteger (lua_State *L, int index);
-
-#define lua_tointegerx COMPAT53_CONCAT(COMPAT53_PREFIX, _tointegerx_53)
-COMPAT53_API lua_Integer lua_tointegerx (lua_State *L, int i, int *isnum);
-
-#define lua_numbertointeger(n, p) \
-  ((*(p) = (lua_Integer)(n)), 1)
-
-#define lua_rawget(L, i) \
-  (lua_rawget((L), (i)), lua_type((L), -1))
-
-#define lua_rawgeti(L, i, n) \
-  (lua_rawgeti((L), (i), (n)), lua_type((L), -1))
-
-#define lua_rotate COMPAT53_CONCAT(COMPAT53_PREFIX, _rotate)
-COMPAT53_API void lua_rotate (lua_State *L, int idx, int n);
-
-#define lua_seti COMPAT53_CONCAT(COMPAT53_PREFIX, _seti)
-COMPAT53_API void lua_seti (lua_State *L, int index, lua_Integer i);
-
-#define lua_stringtonumber COMPAT53_CONCAT(COMPAT53_PREFIX, _stringtonumber)
-COMPAT53_API size_t lua_stringtonumber (lua_State *L, const char *s);
-
-#define luaL_tolstring COMPAT53_CONCAT(COMPAT53_PREFIX, L_tolstring)
-COMPAT53_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len);
-
-#define luaL_getmetafield(L, o, e) \
-  (luaL_getmetafield((L), (o), (e)) ? lua_type((L), -1) : LUA_TNIL)
-
-#define luaL_newmetatable(L, tn) \
-  (luaL_newmetatable((L), (tn)) ? (lua_pushstring((L), (tn)), lua_setfield((L), -2, "__name"), 1) : 0)
-
-#define luaL_requiref COMPAT53_CONCAT(COMPAT53_PREFIX, L_requiref_53)
-COMPAT53_API void luaL_requiref (lua_State *L, const char *modname,
-                                 lua_CFunction openf, int glb );
-
-#endif /* Lua 5.1 and Lua 5.2 */
-
-
-
-/* declarations for Lua 5.2 */
-#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 502
-
-/* XXX not implemented:
- * lua_isyieldable
- * lua_arith (new operators)
- * lua_pushfstring (new formats)
- */
-
-#define lua_getglobal(L, n) \
-  (lua_getglobal((L), (n)), lua_type((L), -1))
-
-#define lua_getuservalue(L, i) \
-  (lua_getuservalue((L), (i)), lua_type((L), -1))
-
-#define lua_pushlstring(L, s, len) \
-  (((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len)))
-
-#define lua_rawgetp(L, i, p) \
-  (lua_rawgetp((L), (i), (p)), lua_type((L), -1))
-
-#define LUA_KFUNCTION(_name) \
-  static int (_name)(lua_State *L, int status, lua_KContext ctx); \
-  static int (_name ## _52)(lua_State *L) { \
-    lua_KContext ctx; \
-    int status = lua_getctx(L, &ctx); \
-    return (_name)(L, status, ctx); \
-  } \
-  static int (_name)(lua_State *L, int status, lua_KContext ctx)
-
-#define lua_pcallk(L, na, nr, err, ctx, cont) \
-  lua_pcallk((L), (na), (nr), (err), (ctx), cont ## _52)
-
-#define lua_callk(L, na, nr, ctx, cont) \
-  lua_callk((L), (na), (nr), (ctx), cont ## _52)
-
-#define lua_yieldk(L, nr, ctx, cont) \
-  lua_yieldk((L), (nr), (ctx), cont ## _52)
-
-#ifdef lua_call
-#  undef lua_call
-#  define lua_call(L, na, nr) \
-  (lua_callk)((L), (na), (nr), 0, NULL)
-#endif
-
-#ifdef lua_pcall
-#  undef lua_pcall
-#  define lua_pcall(L, na, nr, err) \
-  (lua_pcallk)((L), (na), (nr), (err), 0, NULL)
-#endif
-
-#ifdef lua_yield
-#  undef lua_yield
-#  define lua_yield(L, nr) \
-  (lua_yieldk)((L), (nr), 0, NULL)
-#endif
-
-#endif /* Lua 5.2 only */
-
-
-
-/* other Lua versions */
-#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 || LUA_VERSION_NUM > 504
-
-#  error "unsupported Lua version (i.e. not Lua 5.1, 5.2, 5.3, or 5.4)"
-
-#endif /* other Lua versions except 5.1, 5.2, 5.3, and 5.4 */
-
-
-
-/* helper macro for defining continuation functions (for every version
- * *except* Lua 5.2) */
-#ifndef LUA_KFUNCTION
-#define LUA_KFUNCTION(_name) \
-  static int (_name)(lua_State *L, int status, lua_KContext ctx)
-#endif
-
-
-#if defined(COMPAT53_INCLUDE_SOURCE)
-#  include "compat-5.3.c"
-#endif
-
-
-#endif /* COMPAT53_H_ */
-

src/ffi/shim/shim.c

@@ -1,515 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include <lauxlib.h>
-#include <lua.h>
-
-#include "compat-5.3.h"
-
-size_t MLUA_WRAPPED_ERROR_SIZE = 0;
-size_t MLUA_WRAPPED_PANIC_SIZE = 0;
-
-const void *MLUA_WRAPPED_ERROR_KEY = NULL;
-const void *MLUA_WRAPPED_PANIC_KEY = NULL;
-
-extern void wrapped_error_traceback(lua_State *L, int error_idx,
-                                    int traceback_idx);
-
-extern int mlua_hook_proc(lua_State *L, lua_Debug *ar);
-
-#define max(a, b) (a > b ? a : b)
-
-// I believe luaL_traceback < 5.4 requires this much free stack to not error.
-// 5.4 uses luaL_Buffer
-const int LUA_TRACEBACK_STACK = 11;
-
-typedef struct {
-  const char *data;
-  size_t len;
-} StringArg;
-
-static void handle_wrapped_error(lua_State *L) {
-  if (lua_checkstack(L, LUA_TRACEBACK_STACK) != 0) {
-    luaL_traceback(L, L, NULL, 0);
-    // Convert to CallbackError and attach traceback
-    wrapped_error_traceback(L, -2, -1);
-    lua_pop(L, 1);
-  } else {
-    // Convert to CallbackError with error message as a traceback
-    wrapped_error_traceback(L, -1, 0);
-  }
-}
-
-// A wrapper around Rust function to protect from triggering longjmp in Rust.
-// Rust callback expected to return positive number of output values or
-// -1 in case of error, -2 in case of panic.
-static int lua_call_rust(lua_State *L) {
-  int nargs = lua_gettop(L);
-
-  // We need one extra stack space to store preallocated memory, and at least 2
-  // stack spaces overall for handling error metatables in rust fn
-  int extra_stack = 1;
-  if (nargs < 2) {
-    extra_stack = 2 - nargs;
-  }
-
-  luaL_checkstack(L, extra_stack,
-                  "not enough stack space for callback error handling");
-
-  // We cannot shadow rust errors with Lua ones, we pre-allocate enough memory
-  // to store a wrapped error or panic *before* we proceed.
-  lua_newuserdata(L, max(MLUA_WRAPPED_ERROR_SIZE, MLUA_WRAPPED_PANIC_SIZE));
-  lua_rotate(L, 1, 1);
-
-  lua_CFunction rust_callback = lua_touserdata(L, lua_upvalueindex(1));
-
-  int ret = rust_callback(L);
-  if (ret < 0) {
-    if (ret == -1 /* WrappedError */) {
-      handle_wrapped_error(L);
-    }
-    lua_error(L);
-  }
-
-  return ret;
-}
-
-void lua_call_mlua_hook_proc(lua_State *L, lua_Debug *ar) {
-  luaL_checkstack(L, 2, "not enough stack space for callback error handling");
-  lua_newuserdata(L, max(MLUA_WRAPPED_ERROR_SIZE, MLUA_WRAPPED_PANIC_SIZE));
-  lua_rotate(L, 1, 1);
-  int ret = mlua_hook_proc(L, ar);
-  if (ret < 0) {
-    if (ret == -1 /* WrappedError */) {
-      handle_wrapped_error(L);
-    }
-    lua_error(L);
-  }
-}
-
-static inline lua_Integer lua_popinteger(lua_State *L) {
-  lua_Integer index = lua_tointeger(L, -1);
-  lua_pop(L, 1);
-  return index;
-}
-
-//
-// Common functions
-//
-
-int lua_gc_s(lua_State *L) {
-  int data = lua_popinteger(L);
-  int what = lua_popinteger(L);
-  int ret = lua_gc(L, what, data);
-  lua_pushinteger(L, ret);
-  return 1;
-}
-
-int luaL_ref_s(lua_State *L) {
-  int ret = luaL_ref(L, -2);
-  lua_pushinteger(L, ret);
-  return 1;
-}
-
-int lua_pushlstring_s(lua_State *L) {
-  StringArg *s = lua_touserdata(L, -1);
-  lua_pop(L, 1);
-  lua_pushlstring(L, s->data, s->len);
-  return 1;
-}
-
-int lua_tolstring_s(lua_State *L) {
-  void *len = lua_touserdata(L, -1);
-  lua_pop(L, 1);
-  const char *s = lua_tolstring(L, -1, len);
-  lua_pushlightuserdata(L, (void *)s);
-  return 2;
-}
-
-int lua_newthread_s(lua_State *L) {
-  lua_newthread(L);
-  return 1;
-}
-
-int lua_newuserdata_s(lua_State *L) {
-  size_t size = lua_tointeger(L, -1);
-  lua_pop(L, 1);
-  lua_newuserdata(L, size);
-  return 1;
-}
-
-int lua_newwrappederror_s(lua_State *L) {
-  lua_newuserdata(L, MLUA_WRAPPED_ERROR_SIZE);
-  return 1;
-}
-
-int lua_pushcclosure_s(lua_State *L) {
-  int n = lua_gettop(L) - 1;
-  lua_CFunction fn = lua_touserdata(L, -1);
-  lua_pop(L, 1);
-  lua_pushcclosure(L, fn, n);
-  return 1;
-}
-
-int lua_pushrclosure_s(lua_State *L) {
-  int n = lua_gettop(L);
-  lua_pushcclosure(L, lua_call_rust, n);
-  return 1;
-}
-
-int luaL_requiref_s(lua_State *L) {
-  const char *modname = lua_touserdata(L, -3);
-  lua_CFunction openf = lua_touserdata(L, -2);
-  int glb = lua_tointeger(L, -1);
-  lua_pop(L, 3);
-  luaL_requiref(L, modname, openf, glb);
-  return 1;
-}
-
-//
-// Table functions
-//
-
-int lua_newtable_s(lua_State *L) {
-  lua_createtable(L, 0, 0);
-  return 1;
-}
-
-int lua_createtable_s(lua_State *L) {
-  int nrec = lua_popinteger(L);
-  int narr = lua_popinteger(L);
-  lua_createtable(L, narr, nrec);
-  return 1;
-}
-
-int lua_gettable_s(lua_State *L) {
-  lua_gettable(L, -2);
-  return 1;
-}
-
-int lua_settable_s(lua_State *L) {
-  lua_settable(L, -3);
-  return 0;
-}
-
-int lua_geti_s(lua_State *L) {
-  lua_Integer index = lua_popinteger(L);
-  lua_geti(L, -1, index);
-  return 1;
-}
-
-int lua_rawset_s(lua_State *L) {
-  lua_rawset(L, -3);
-  return 0;
-}
-
-int lua_rawseti_s(lua_State *L) {
-  lua_Integer index = lua_popinteger(L);
-  lua_rawseti(L, -2, index);
-  return 0;
-}
-
-int lua_rawsetp_s(lua_State *L) {
-  void *p = lua_touserdata(L, -1);
-  lua_pop(L, 1);
-  lua_rawsetp(L, -2, p);
-  return 0;
-}
-
-int lua_rawsetfield_s(lua_State *L) {
-  StringArg *s = lua_touserdata(L, -2);
-  lua_pushlstring(L, s->data, s->len);
-  lua_replace(L, -3);
-  lua_rawset(L, -3);
-  return 0;
-}
-
-int lua_rawinsert_s(lua_State *L) {
-  lua_Integer index = lua_popinteger(L);
-  lua_Integer size = lua_rawlen(L, -2);
-
-  for (lua_Integer i = size; i >= index; i--) {
-    // table[i+1] = table[i]
-    lua_rawgeti(L, -2, i);
-    lua_rawseti(L, -3, i + 1);
-  }
-  lua_rawseti(L, -2, index);
-
-  return 0;
-}
-
-int lua_rawremove_s(lua_State *L) {
-  lua_Integer index = lua_popinteger(L);
-  lua_Integer size = lua_rawlen(L, -1);
-
-  for (lua_Integer i = index; i < size; i++) {
-    lua_rawgeti(L, -1, i + 1);
-    lua_rawseti(L, -2, i);
-  }
-  lua_pushnil(L);
-  lua_rawseti(L, -2, size);
-
-  return 0;
-}
-
-int luaL_len_s(lua_State *L) {
-  lua_pushinteger(L, luaL_len(L, -1));
-  return 1;
-}
-
-int lua_next_s(lua_State *L) {
-  int ret = lua_next(L, -2);
-  lua_pushinteger(L, ret);
-  return ret == 0 ? 1 : 3;
-}
-
-//
-// Moved from Rust to C
-//
-
-// Wrapper to lookup in `field_getters` first, then `methods`, ending
-// original `__index`. Used only if `field_getters` or `methods` set.
-int meta_index_impl(lua_State *state) {
-  // stack: self, key
-  luaL_checkstack(state, 2, NULL);
-
-  // lookup in `field_getters` table
-  if (lua_isnil(state, lua_upvalueindex(2)) == 0) {
-    lua_pushvalue(state, -1); // `key` arg
-    if (lua_rawget(state, lua_upvalueindex(2)) != LUA_TNIL) {
-      lua_insert(state, -3); // move function
-      lua_pop(state, 1);     // remove `key`
-      lua_call(state, 1, 1);
-      return 1;
-    }
-    lua_pop(state, 1); // pop the nil value
-  }
-  // lookup in `methods` table
-  if (lua_isnil(state, lua_upvalueindex(3)) == 0) {
-    lua_pushvalue(state, -1); // `key` arg
-    if (lua_rawget(state, lua_upvalueindex(3)) != LUA_TNIL) {
-      lua_insert(state, -3);
-      lua_pop(state, 2);
-      return 1;
-    }
-    lua_pop(state, 1); // pop the nil value
-  }
-
-  // lookup in `__index`
-  lua_pushvalue(state, lua_upvalueindex(1));
-  switch (lua_type(state, -1)) {
-  case LUA_TNIL:
-    lua_pop(state, 1); // pop the nil value
-    const char *field = lua_tostring(state, -1);
-    luaL_error(state, "attempt to get an unknown field '%s'", field);
-    break;
-
-  case LUA_TTABLE:
-    lua_insert(state, -2);
-    lua_gettable(state, -2);
-    break;
-
-  case LUA_TFUNCTION:
-    lua_insert(state, -3);
-    lua_call(state, 2, 1);
-    break;
-  }
-
-  return 1;
-}
-
-// Similar to `meta_index_impl`, checks `field_setters` table first, then
-// `__newindex` metamethod. Used only if `field_setters` set.
-int meta_newindex_impl(lua_State *state) {
-  // stack: self, key, value
-  luaL_checkstack(state, 2, NULL);
-
-  // lookup in `field_setters` table
-  lua_pushvalue(state, -2); // `key` arg
-  if (lua_rawget(state, lua_upvalueindex(2)) != LUA_TNIL) {
-    lua_remove(state, -3); // remove `key`
-    lua_insert(state, -3); // move function
-    lua_call(state, 2, 0);
-    return 0;
-  }
-  lua_pop(state, 1); // pop the nil value
-
-  // lookup in `__newindex`
-  lua_pushvalue(state, lua_upvalueindex(1));
-  switch (lua_type(state, -1)) {
-  case LUA_TNIL:
-    lua_pop(state, 1); // pop the nil value
-    const char *field = lua_tostring(state, -2);
-    luaL_error(state, "attempt to set an unknown field '%s'", field);
-    break;
-
-  case LUA_TTABLE:
-    lua_insert(state, -3);
-    lua_settable(state, -3);
-    break;
-
-  case LUA_TFUNCTION:
-    lua_insert(state, -4);
-    lua_call(state, 3, 0);
-    break;
-  }
-
-  return 0;
-}
-
-// See Function::bind
-int bind_call_impl(lua_State *state) {
-  int nargs = lua_gettop(state);
-  int nbinds = lua_tointeger(state, lua_upvalueindex(2));
-  luaL_checkstack(state, nbinds + 2, NULL);
-
-  lua_settop(state, nargs + nbinds + 1);
-  lua_rotate(state, -(nargs + nbinds + 1), nbinds + 1);
-
-  lua_pushvalue(state, lua_upvalueindex(1));
-  lua_replace(state, 1);
-
-  for (int i = 0; i < nbinds; i++) {
-    lua_pushvalue(state, lua_upvalueindex(i + 3));
-    lua_replace(state, i + 2);
-  }
-
-  lua_call(state, nargs + nbinds, LUA_MULTRET);
-  return lua_gettop(state);
-}
-
-// Returns 1 if a value at index `index` is a special wrapped struct identified
-// by `key`
-int is_wrapped_struct(lua_State *state, int index, const void *key) {
-  if (key == NULL) {
-    // Not yet initialized?
-    return 0;
-  }
-
-  void *ud = lua_touserdata(state, index);
-  if (ud == NULL || lua_getmetatable(state, index) == 0) {
-    return 0;
-  }
-  lua_rawgetp(state, LUA_REGISTRYINDEX, key);
-  int res = lua_rawequal(state, -1, -2);
-  lua_pop(state, 2);
-  return res;
-}
-
-// Takes an error at the top of the stack and converts Lua errors into a string
-// with attached traceback. If the error is a WrappedError or WrappedPanic, does
-// not modify it. This function does its best to avoid triggering another error
-// and shadowing previous rust errors.
-int error_traceback(lua_State *state) {
-  if (lua_checkstack(state, 2) == 0) {
-    // If we don't have enough stack space to even check the error type, do
-    // nothing so we don't risk shadowing a rust panic.
-    return 1;
-  }
-
-  if (MLUA_WRAPPED_PANIC_KEY == NULL ||
-      is_wrapped_struct(state, -1, MLUA_WRAPPED_PANIC_KEY) ||
-      is_wrapped_struct(state, -1, MLUA_WRAPPED_ERROR_KEY)) {
-    return 1;
-  }
-
-  const char *s = luaL_tolstring(state, -1, NULL);
-  if (lua_checkstack(state, LUA_TRACEBACK_STACK) != 0) {
-    luaL_traceback(state, state, s, 1);
-    lua_remove(state, -2);
-  }
-
-  return 1;
-}
-
-int error_traceback_s(lua_State *L) {
-  lua_State *L1 = lua_touserdata(L, -1);
-  lua_pop(L, 1);
-  return error_traceback(L1);
-}
-
-// A `pcall` implementation that does not allow Lua to catch Rust panics.
-// Instead, panics automatically resumed.
-int lua_nopanic_pcall(lua_State *state) {
-  luaL_checkstack(state, 2, NULL);
-
-  int top = lua_gettop(state);
-  if (top == 0) {
-    lua_pushstring(state, "not enough arguments to pcall");
-    lua_error(state);
-  }
-
-  if (lua_pcall(state, top - 1, LUA_MULTRET, 0) == LUA_OK) {
-    lua_pushboolean(state, 1);
-    lua_insert(state, 1);
-    return lua_gettop(state);
-  }
-
-  if (is_wrapped_struct(state, -1, MLUA_WRAPPED_PANIC_KEY)) {
-    lua_error(state);
-  }
-  lua_pushboolean(state, 0);
-  lua_insert(state, -2);
-  return 2;
-}
-
-// A `xpcall` implementation that does not allow Lua to catch Rust panics.
-// Instead, panics automatically resumed.
-
-static int xpcall_msgh(lua_State *state) {
-  luaL_checkstack(state, 2, NULL);
-  if (is_wrapped_struct(state, -1, MLUA_WRAPPED_PANIC_KEY)) {
-    return 1;
-  }
-  lua_pushvalue(state, lua_upvalueindex(1));
-  lua_insert(state, 1);
-  lua_call(state, lua_gettop(state) - 1, LUA_MULTRET);
-  return lua_gettop(state);
-}
-
-int lua_nopanic_xpcall(lua_State *state) {
-  luaL_checkstack(state, 2, NULL);
-
-  int top = lua_gettop(state);
-  if (top < 2) {
-    lua_pushstring(state, "not enough arguments to xpcall");
-    lua_error(state);
-  }
-
-  lua_pushvalue(state, 2);
-  lua_pushcclosure(state, xpcall_msgh, 1);
-  lua_copy(state, 1, 2);
-  lua_replace(state, 1);
-
-  if (lua_pcall(state, lua_gettop(state) - 2, LUA_MULTRET, 1) == LUA_OK) {
-    lua_pushboolean(state, 1);
-    lua_insert(state, 2);
-    return lua_gettop(state) - 1;
-  }
-
-  if (is_wrapped_struct(state, -1, MLUA_WRAPPED_PANIC_KEY)) {
-    lua_error(state);
-  }
-  lua_pushboolean(state, 0);
-  lua_insert(state, -2);
-  return 2;
-}

src/function.rs

@@ -1,19 +1,86 @@
+use std::cell::RefCell;
+use std::mem;
 use std::os::raw::{c_int, c_void};
+use std::ptr;
 use std::slice;
 
 use crate::error::{Error, Result};
-use crate::ffi;
-use crate::types::LuaRef;
-use crate::util::{assert_stack, check_stack, pop_error, StackGuard};
-use crate::value::{FromLuaMulti, MultiValue, ToLuaMulti};
+use crate::lua::Lua;
+use crate::table::Table;
+use crate::types::{Callback, LuaRef, MaybeSend};
+use crate::util::{
+    assert_stack, check_stack, linenumber_to_usize, pop_error, ptr_to_lossy_str, ptr_to_str,
+    StackGuard,
+};
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti, Value};
 
 #[cfg(feature = "async")]
-use {futures_core::future::LocalBoxFuture, futures_util::future};
+use {
+    crate::types::AsyncCallback,
+    futures_util::future::{self, Future},
+};
 
 /// Handle to an internal Lua function.
 #[derive(Clone, Debug)]
 pub struct Function<'lua>(pub(crate) LuaRef<'lua>);
 
+/// Owned handle to an internal Lua function.
+///
+/// The owned handle holds a *strong* reference to the current Lua instance.
+/// Be warned, if you place it into a Lua type (eg. [`UserData`] or a Rust callback), it is *very easy*
+/// to accidentally cause reference cycles that would prevent destroying Lua instance.
+///
+/// [`UserData`]: crate::UserData
+#[cfg(feature = "unstable")]
+#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
+#[derive(Clone, Debug)]
+pub struct OwnedFunction(pub(crate) crate::types::LuaOwnedRef);
+
+#[cfg(feature = "unstable")]
+impl OwnedFunction {
+    /// Get borrowed handle to the underlying Lua function.
+    #[cfg_attr(feature = "send", allow(unused))]
+    pub const fn to_ref(&self) -> Function {
+        Function(self.0.to_ref())
+    }
+}
+
+/// 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 {
+    /// 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.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CoverageInfo {
+    pub function: Option<String>,
+    pub line_defined: i32,
+    pub depth: i32,
+    pub hits: Vec<i32>,
+}
+
 impl<'lua> Function<'lua> {
     /// Calls the function, passing `args` as function arguments.
     ///
@@ -55,39 +122,31 @@ impl<'lua> Function<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
+    pub fn call<A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
         let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
 
-        let 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, ffi::safe::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 {
-                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 = MultiValue::new();
-            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`].
@@ -98,14 +157,13 @@ impl<'lua> Function<'lua> {
     ///
     /// ```
     /// use std::time::Duration;
-    /// use futures_timer::Delay;
     /// # use mlua::{Lua, Result};
     /// # #[tokio::main]
     /// # async fn main() -> Result<()> {
     /// # let lua = Lua::new();
     ///
     /// let sleep = lua.create_async_function(move |_lua, n: u64| async move {
-    ///     Delay::new(Duration::from_millis(n)).await;
+    ///     tokio::time::sleep(Duration::from_millis(n)).await;
     ///     Ok(())
     /// })?;
     ///
@@ -115,20 +173,21 @@ impl<'lua> Function<'lua> {
     /// # }
     /// ```
     ///
-    /// [`AsyncThread`]: struct.AsyncThread.html
+    /// [`AsyncThread`]: crate::AsyncThread
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    pub fn call_async<A, R>(&self, args: A) -> impl Future<Output = Result<R>> + 'lua
     where
-        'lua: 'fut,
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'lua,
     {
         let lua = self.0.lua;
-        match lua.create_thread(self.clone()) {
-            Ok(t) => Box::pin(t.into_async(args)),
-            Err(e) => Box::pin(future::err(e)),
-        }
+        let thread_res = lua.create_recycled_thread(self).map(|th| {
+            let mut th = th.into_async(args);
+            th.set_recyclable(true);
+            th
+        });
+        async move { thread_res?.await }
     }
 
     /// Returns a function that, when called, calls `self`, passing `args` as the first set of
@@ -158,28 +217,188 @@ impl<'lua> Function<'lua> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
-        let lua = self.0.lua;
+    pub fn bind<A: IntoLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
+        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());
 
-        let args = args.to_lua_multi(lua)?;
+            for i in 0..nbinds {
+                ffi::lua_pushvalue(state, ffi::lua_upvalueindex(i + 2));
+            }
+            if nargs > 0 {
+                ffi::lua_rotate(state, 1, nbinds);
+            }
+
+            nargs + nbinds
+        }
+
+        let lua = self.0.lua;
+        let state = lua.state();
+
+        let args = args.into_lua_multi(lua)?;
         let nargs = args.len() as c_int;
 
-        if nargs + 2 > ffi::LUA_MAX_UPVALUES {
+        if nargs == 0 {
+            return Ok(self.clone());
+        }
+
+        if nargs + 1 > ffi::LUA_MAX_UPVALUES {
             return Err(Error::BindError);
         }
 
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, nargs + 5)?;
+        let args_wrapper = unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, nargs + 3)?;
 
-            lua.push_ref(&self.0);
-            ffi::lua_pushinteger(lua.state, nargs as ffi::lua_Integer);
+            ffi::lua_pushinteger(state, nargs as ffi::lua_Integer);
             for arg in args {
                 lua.push_value(arg)?;
             }
-            ffi::safe::lua_pushcclosure(lua.state, ffi::safe::bind_call_impl, nargs + 2)?;
+            protect_lua!(state, nargs + 1, 1, fn(state) {
+                ffi::lua_pushcclosure(state, args_wrapper_impl, ffi::lua_gettop(state));
+            })?;
 
-            Ok(Function(lua.pop_ref()))
+            Function(lua.pop_ref())
+        };
+
+        lua.load(
+            r#"
+            local func, args_wrapper = ...
+            return function(...)
+                return func(args_wrapper(...))
+            end
+            "#,
+        )
+        .try_cache()
+        .set_name("__mlua_bind")
+        .call((self.clone(), args_wrapper))
+    }
+
+    /// Returns the environment of the Lua function.
+    ///
+    /// By default Lua functions shares a global environment.
+    ///
+    /// This function always returns `None` for Rust/C functions.
+    pub fn environment(&self) -> Option<Table> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return None;
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            ffi::lua_getfenv(state, -1);
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                // Traverse upvalues until we find the _ENV one
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => break,
+                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => break,
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            if ffi::lua_type(state, -1) != ffi::LUA_TTABLE {
+                return None;
+            }
+            Some(Table(lua.pop_ref()))
+        }
+    }
+
+    /// Sets the environment of the Lua function.
+    ///
+    /// The environment is a table that is used as the global environment for the function.
+    /// Returns `true` if environment successfully changed, `false` otherwise.
+    ///
+    /// This function does nothing for Rust/C functions.
+    pub fn set_environment(&self, env: Table) -> Result<bool> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return Ok(false);
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            {
+                lua.push_ref(&env.0);
+                ffi::lua_setfenv(state, -2);
+            }
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => return Ok(false),
+                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => {
+                        ffi::lua_pop(state, 1);
+                        // Create an anonymous function with the new environment
+                        let f_with_env = lua
+                            .load("return _ENV")
+                            .set_environment(env)
+                            .try_cache()
+                            .into_function()?;
+                        lua.push_ref(&f_with_env.0);
+                        ffi::lua_upvaluejoin(state, -2, i, -1, 1);
+                        break;
+                    }
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            Ok(true)
+        }
+    }
+
+    /// Returns information about the function.
+    ///
+    /// Corresponds to the `>Sn` what mask for [`lua_getinfo`] when applied to the function.
+    ///
+    /// [`lua_getinfo`]: https://www.lua.org/manual/5.4/manual.html#lua_getinfo
+    pub fn info(&self) -> FunctionInfo {
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            let mut ar: ffi::lua_Debug = mem::zeroed();
+            lua.push_ref(&self.0);
+            #[cfg(not(feature = "luau"))]
+            let res = ffi::lua_getinfo(state, cstr!(">Sn"), &mut ar);
+            #[cfg(feature = "luau")]
+            let res = ffi::lua_getinfo(state, -1, cstr!("sn"), &mut ar);
+            mlua_assert!(res != 0, "lua_getinfo failed with `>Sn`");
+
+            FunctionInfo {
+                name: ptr_to_lossy_str(ar.name).map(|s| s.into_owned()),
+                #[cfg(not(feature = "luau"))]
+                name_what: match ptr_to_str(ar.namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
+                #[cfg(feature = "luau")]
+                name_what: None,
+                what: ptr_to_str(ar.what).unwrap_or("main"),
+                source: ptr_to_lossy_str(ar.source).map(|s| s.into_owned()),
+                #[cfg(not(feature = "luau"))]
+                short_src: ptr_to_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,
+            }
         }
     }
 
@@ -187,8 +406,14 @@ impl<'lua> Function<'lua> {
     ///
     /// If `strip` is true, the binary representation may not include all debug information
     /// about the function, to save space.
+    ///
+    /// For Luau a [Compiler] can be used to compile Lua chunks to bytecode.
+    ///
+    /// [Compiler]: crate::chunk::Compiler
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
     pub fn dump(&self, strip: bool) -> Vec<u8> {
-        unsafe extern "C" fn writer(
+        unsafe extern "C-unwind" fn writer(
             _state: *mut ffi::lua_State,
             buf: *const c_void,
             buf_len: usize,
@@ -201,20 +426,81 @@ impl<'lua> Function<'lua> {
         }
 
         let lua = self.0.lua;
+        let state = lua.state();
         let mut data: Vec<u8> = Vec::new();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
 
             lua.push_ref(&self.0);
             let data_ptr = &mut data as *mut Vec<u8> as *mut c_void;
-            let strip = if strip { 1 } else { 0 };
-            ffi::lua_dump(lua.state, writer, data_ptr, strip);
-            ffi::lua_pop(lua.state, 1);
+            ffi::lua_dump(state, writer, data_ptr, strip as i32);
+            ffi::lua_pop(state, 1);
         }
 
         data
     }
+
+    /// Retrieves recorded coverage information about this Lua function including inner calls.
+    ///
+    /// This function takes a callback as an argument and calls it providing [`CoverageInfo`] snapshot
+    /// per each executed inner function.
+    ///
+    /// Recording of coverage information is controlled by [`Compiler::set_coverage_level`] option.
+    ///
+    /// Requires `feature = "luau"`
+    ///
+    /// [`Compiler::set_coverage_level`]: crate::chunk::Compiler::set_coverage_level
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn coverage<F>(&self, mut func: F)
+    where
+        F: FnMut(CoverageInfo),
+    {
+        use std::ffi::CStr;
+        use std::os::raw::c_char;
+
+        unsafe extern "C-unwind" fn callback<F: FnMut(CoverageInfo)>(
+            data: *mut c_void,
+            function: *const c_char,
+            line_defined: c_int,
+            depth: c_int,
+            hits: *const c_int,
+            size: usize,
+        ) {
+            let function = if !function.is_null() {
+                Some(CStr::from_ptr(function).to_string_lossy().to_string())
+            } else {
+                None
+            };
+            let rust_callback = &mut *(data as *mut F);
+            rust_callback(CoverageInfo {
+                function,
+                line_defined,
+                depth,
+                hits: slice::from_raw_parts(hits, size).to_vec(),
+            });
+        }
+
+        let lua = self.0.lua;
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            lua.push_ref(&self.0);
+            let func_ptr = &mut func as *mut F as *mut c_void;
+            ffi::lua_getcoverage(state, -1, func_ptr, callback::<F>);
+        }
+    }
+
+    /// Convert this handle to owned version.
+    #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+    #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+    #[inline]
+    pub fn into_owned(self) -> OwnedFunction {
+        OwnedFunction(self.0.into_owned())
+    }
 }
 
 impl<'lua> PartialEq for Function<'lua> {
@@ -222,3 +508,118 @@ impl<'lua> PartialEq for Function<'lua> {
         self.0 == other.0
     }
 }
+
+// Additional shortcuts
+#[cfg(feature = "unstable")]
+impl OwnedFunction {
+    /// Calls the function, passing `args` as function arguments.
+    ///
+    /// This is a shortcut for [`Function::call()`].
+    #[inline]
+    pub fn call<'lua, A, R>(&'lua self, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua>,
+    {
+        self.to_ref().call(args)
+    }
+
+    /// Returns a future that, when polled, calls `self`, passing `args` as function arguments,
+    /// and drives the execution.
+    ///
+    /// This is a shortcut for [`Function::call_async()`].
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    #[inline]
+    pub async fn call_async<'lua, A, R>(&'lua self, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'lua,
+    {
+        self.to_ref().call_async(args).await
+    }
+}
+
+pub(crate) struct WrappedFunction<'lua>(pub(crate) Callback<'lua, 'static>);
+
+#[cfg(feature = "async")]
+pub(crate) struct WrappedAsyncFunction<'lua>(pub(crate) AsyncCallback<'lua, 'static>);
+
+impl<'lua> Function<'lua> {
+    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`] trait.
+    #[inline]
+    pub fn wrap<A, R, F>(func: F) -> impl IntoLua<'lua>
+    where
+        A: FromLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
+        F: Fn(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
+    {
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func(lua, args)?.push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
+    #[inline]
+    pub fn wrap_mut<A, R, F>(func: F) -> impl IntoLua<'lua>
+    where
+        A: FromLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
+        F: FnMut(&'lua Lua, A) -> Result<R> + MaybeSend + 'static,
+    {
+        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(lua, args)?.push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust async function or closure, returning an opaque type that implements [`IntoLua`] trait.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn wrap_async<A, R, F, FR>(func: F) -> impl IntoLua<'lua>
+    where
+        A: FromLuaMulti<'lua>,
+        R: IntoLuaMulti<'lua>,
+        F: Fn(&'lua Lua, A) -> FR + MaybeSend + 'static,
+        FR: Future<Output = Result<R>> + 'lua,
+    {
+        WrappedAsyncFunction(Box::new(move |lua, args| unsafe {
+            let args = match A::from_lua_args(args, 1, None, lua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::err(e)),
+            };
+            let fut = func(lua, args);
+            Box::pin(async move { fut.await?.push_into_stack_multi(lua) })
+        }))
+    }
+}
+
+impl<'lua> IntoLua<'lua> for WrappedFunction<'lua> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.create_callback(self.0).map(Value::Function)
+    }
+}
+
+#[cfg(feature = "async")]
+impl<'lua> IntoLua<'lua> for WrappedAsyncFunction<'lua> {
+    #[inline]
+    fn into_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        lua.create_async_callback(self.0).map(Value::Function)
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(Function: Send);
+
+    #[cfg(all(feature = "unstable", not(feature = "send")))]
+    static_assertions::assert_not_impl_any!(OwnedFunction: Send);
+}

src/hook.rs

@@ -1,55 +1,122 @@
-use std::ffi::CStr;
-use std::marker::PhantomData;
-use std::os::raw::{c_char, c_int};
+use std::borrow::Cow;
+use std::cell::UnsafeCell;
+#[cfg(not(feature = "luau"))]
+use std::ops::{BitOr, BitOrAssign};
+use std::os::raw::c_int;
+
+use ffi::lua_Debug;
 
-use crate::ffi::{self, lua_Debug, lua_State};
 use crate::lua::Lua;
-use crate::util::callback_error;
+use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};
 
 /// 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 5.3 documentation][lua_doc].
+/// found in the Lua [documentation][lua_doc].
 ///
-/// [lua_doc]: https://www.lua.org/manual/5.3/manual.html#lua_Debug
-/// [`Lua::set_hook`]: struct.Lua.html#method.set_hook
-#[derive(Clone)]
-pub struct Debug<'a> {
-    ar: *mut lua_Debug,
-    state: *mut lua_State,
-    _phantom: PhantomData<&'a ()>,
+/// [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<'a> Debug<'a> {
-    /// Corresponds to the `n` what mask.
-    pub fn names(&self) -> DebugNames<'a> {
+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 {
+        unsafe {
+            #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.state, cstr!("n"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("n"), self.ar.get()) != 0,
                 "lua_getinfo failed with `n`"
             );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("n"), self.ar.get()) != 0,
+                "lua_getinfo failed with `n`"
+            );
+
             DebugNames {
-                name: ptr_to_str((*self.ar).name),
-                name_what: ptr_to_str((*self.ar).namewhat),
+                name: ptr_to_lossy_str((*self.ar.get()).name),
+                #[cfg(not(feature = "luau"))]
+                name_what: match ptr_to_str((*self.ar.get()).namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
+                #[cfg(feature = "luau")]
+                name_what: None,
             }
         }
     }
 
     /// Corresponds to the `S` what mask.
-    pub fn source(&self) -> DebugSource<'a> {
+    pub fn source(&self) -> DebugSource {
         unsafe {
+            #[cfg(not(feature = "luau"))]
             mlua_assert!(
-                ffi::lua_getinfo(self.state, cstr!("S"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("S"), self.ar.get()) != 0,
                 "lua_getinfo failed with `S`"
             );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("s"), self.ar.get()) != 0,
+                "lua_getinfo failed with `s`"
+            );
+
             DebugSource {
-                source: ptr_to_str((*self.ar).source),
-                short_src: ptr_to_str((*self.ar).short_src.as_ptr()),
-                line_defined: (*self.ar).linedefined as i32,
-                last_line_defined: (*self.ar).lastlinedefined as i32,
-                what: ptr_to_str((*self.ar).what),
+                source: ptr_to_lossy_str((*self.ar.get()).source),
+                #[cfg(not(feature = "luau"))]
+                short_src: ptr_to_lossy_str((*self.ar.get()).short_src.as_ptr()),
+                #[cfg(feature = "luau")]
+                short_src: ptr_to_lossy_str((*self.ar.get()).short_src),
+                line_defined: linenumber_to_usize((*self.ar.get()).linedefined),
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: linenumber_to_usize((*self.ar.get()).lastlinedefined),
+                #[cfg(feature = "luau")]
+                last_line_defined: None,
+                what: ptr_to_str((*self.ar.get()).what).unwrap_or("main"),
             }
         }
     }
@@ -57,71 +124,144 @@ impl<'a> Debug<'a> {
     /// 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.state, cstr!("l"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("l"), self.ar.get()) != 0,
                 "lua_getinfo failed with `l`"
             );
-            (*self.ar).currentline as i32
+            #[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
         }
     }
 
     /// 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.state, cstr!("t"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("t"), self.ar.get()) != 0,
                 "lua_getinfo failed with `t`"
             );
-            (*self.ar).currentline != 0
+            (*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.state, cstr!("u"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("u"), self.ar.get()) != 0,
                 "lua_getinfo failed with `u`"
             );
-            DebugStack {
-                num_ups: (*self.ar).nups as i32,
+            #[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 _,
                 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar).nparams as i32,
+                num_params: (*self.ar.get()).nparams as _,
                 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                is_vararg: (*self.ar).isvararg != 0,
-            }
+                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]>,
+    /// A (reasonable) name of the function (`None` if the name cannot be found).
+    pub name: Option<Cow<'a, str>>,
+    /// Explains the `name` field (can be `global`/`local`/`method`/`field`/`upvalue`/etc).
+    ///
+    /// Always `None` for Luau.
+    pub name_what: Option<&'static str>,
 }
 
 #[derive(Clone, Debug)]
 pub struct DebugSource<'a> {
-    pub source: Option<&'a [u8]>,
-    pub short_src: Option<&'a [u8]>,
-    pub line_defined: i32,
-    pub last_line_defined: i32,
-    pub what: Option<&'a [u8]>,
+    /// Source of the chunk that created the function.
+    pub source: Option<Cow<'a, str>>,
+    /// A "printable" version of `source`, to be used in error messages.
+    pub short_src: Option<Cow<'a, str>>,
+    /// The line number where the definition of the function starts.
+    pub line_defined: Option<usize>,
+    /// The line number where the definition of the function ends (not set by Luau).
+    pub last_line_defined: Option<usize>,
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is the main part of a chunk.
+    pub what: &'static str,
 }
 
 #[derive(Copy, Clone, Debug)]
 pub struct DebugStack {
     pub num_ups: i32,
-    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    /// 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"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    /// 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.
@@ -139,9 +279,61 @@ pub struct HookTriggers {
     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) fn mask(&self) -> c_int {
+    pub(crate) const fn mask(&self) -> c_int {
         let mut mask: c_int = 0;
         if self.on_calls {
             mask |= ffi::LUA_MASKCALL
@@ -160,37 +352,32 @@ impl HookTriggers {
 
     // 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
+    pub(crate) const fn count(&self) -> c_int {
+        match self.every_nth_instruction {
+            Some(n) => n as c_int,
+            None => 0,
+        }
     }
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn mlua_hook_proc(state: *mut lua_State, ar: *mut lua_Debug) -> c_int {
-    callback_error(state, |_| {
-        let debug = Debug {
-            ar,
-            state,
-            _phantom: PhantomData,
-        };
+#[cfg(not(feature = "luau"))]
+impl BitOr for HookTriggers {
+    type Output = Self;
 
-        let lua = mlua_expect!(Lua::make_from_ptr(state), "cannot make Lua instance");
-        let hook_cb = mlua_expect!(lua.hook_callback(), "no hook callback set in hook_proc");
-
-        #[allow(clippy::match_wild_err_arm)]
-        match hook_cb.try_borrow_mut() {
-            Ok(mut b) => (&mut *b)(&lua, debug),
-            Err(_) => mlua_panic!("Lua should not allow hooks to be called within another hook"),
-        }?;
-
-        Ok(0)
-    })
-}
-
-unsafe fn ptr_to_str<'a>(input: *const c_char) -> Option<&'a [u8]> {
-    if input.is_null() {
-        None
-    } else {
-        Some(CStr::from_ptr(input).to_bytes())
+    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
@@ -50,29 +50,27 @@
 //! to [`Function`]s and [`UserData`].
 //!
 //! [Lua programming language]: https://www.lua.org/
-//! [`Lua`]: struct.Lua.html
-//! [executing]: struct.Chunk.html#method.exec
-//! [evaluating]: struct.Chunk.html#method.eval
-//! [globals]: struct.Lua.html#method.globals
-//! [`ToLua`]: trait.ToLua.html
-//! [`FromLua`]: trait.FromLua.html
-//! [`ToLuaMulti`]: trait.ToLuaMulti.html
-//! [`FromLuaMulti`]: trait.FromLuaMulti.html
-//! [`Function`]: struct.Function.html
-//! [`UserData`]: trait.UserData.html
-//! [`UserDataFields`]: trait.UserDataFields.html
-//! [`UserDataMethods`]: trait.UserDataMethods.html
-//! [`LuaSerdeExt`]: serde/trait.LuaSerdeExt.html
-//! [`Value`]: enum.Value.html
-//! [`create_async_function`]: struct.Lua.html#method.create_async_function
-//! [`call_async`]: struct.Function.html#method.call_async
-//! [`AsyncThread`]: struct.AsyncThread.html
-//! [`Future`]: ../futures_core/future/trait.Future.html
+//! [`Lua`]: crate::Lua
+//! [executing]: crate::Chunk::exec
+//! [evaluating]: crate::Chunk::eval
+//! [globals]: crate::Lua::globals
+//! [`IntoLua`]: crate::IntoLua
+//! [`FromLua`]: crate::FromLua
+//! [`IntoLuaMulti`]: crate::IntoLuaMulti
+//! [`FromLuaMulti`]: crate::FromLuaMulti
+//! [`Function`]: crate::Function
+//! [`UserData`]: crate::UserData
+//! [`UserDataFields`]: crate::UserDataFields
+//! [`UserDataMethods`]: crate::UserDataMethods
+//! [`LuaSerdeExt`]: crate::LuaSerdeExt
+//! [`Value`]: crate::Value
+//! [`create_async_function`]: crate::Lua::create_async_function
+//! [`call_async`]: crate::Function::call_async
+//! [`AsyncThread`]: crate::AsyncThread
+//! [`Future`]: std::future::Future
 //! [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
-// mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.6.0-beta.3")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]
@@ -81,12 +79,15 @@
 #[macro_use]
 mod macros;
 
+mod chunk;
 mod conversion;
 mod error;
-mod ffi;
 mod function;
 mod hook;
 mod lua;
+#[cfg(feature = "luau")]
+mod luau;
+mod memory;
 mod multi;
 mod scope;
 mod stdlib;
@@ -95,53 +96,79 @@ mod table;
 mod thread;
 mod types;
 mod userdata;
+mod userdata_ext;
+mod userdata_impl;
 mod util;
 mod value;
 
-#[doc(hidden)]
-pub use crate::ffi::lua_State;
+pub mod prelude;
 
-pub use crate::error::{Error, ExternalError, ExternalResult, Result};
-pub use crate::function::Function;
-pub use crate::hook::{Debug, DebugNames, DebugSource, DebugStack, HookTriggers};
-pub use crate::lua::{AsChunk, Chunk, ChunkMode, GCMode, Lua, LuaOptions};
+pub use ffi::{self, lua_CFunction, lua_State};
+
+pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
+pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
+pub use crate::function::{Function, FunctionInfo};
+pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
+pub use crate::lua::{GCMode, Lua, LuaOptions};
 pub use crate::multi::Variadic;
 pub use crate::scope::Scope;
 pub use crate::stdlib::StdLib;
 pub use crate::string::String;
 pub use crate::table::{Table, TableExt, TablePairs, TableSequence};
 pub use crate::thread::{Thread, ThreadStatus};
-pub use crate::types::{Integer, LightUserData, Number, RegistryKey};
+pub use crate::types::{AppDataRef, AppDataRefMut, Integer, LightUserData, Number, RegistryKey};
 pub use crate::userdata::{
     AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
+    UserDataRef, UserDataRefMut,
+};
+pub use crate::userdata_ext::AnyUserDataExt;
+pub use crate::userdata_impl::UserDataRegistry;
+pub use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, Value};
+
+#[cfg(not(feature = "luau"))]
+pub use crate::hook::HookTriggers;
+
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub use crate::{
+    chunk::Compiler,
+    function::CoverageInfo,
+    types::{Vector, VmState},
 };
-pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
 
 #[cfg(feature = "async")]
 pub use crate::thread::AsyncThread;
 
 #[cfg(feature = "serialize")]
 #[doc(inline)]
-pub use crate::serde::{ser::Options as SerializeOptions, LuaSerdeExt};
+pub use crate::serde::{
+    de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt,
+};
 
-pub mod prelude;
 #[cfg(feature = "serialize")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 pub mod serde;
 
-#[cfg(any(feature = "mlua_derive"))]
+#[cfg(feature = "mlua_derive")]
 #[allow(unused_imports)]
 #[macro_use]
 extern crate mlua_derive;
 
+// Unstable features
+#[cfg(feature = "unstable")]
+pub use crate::{
+    function::OwnedFunction, string::OwnedString, table::OwnedTable, thread::OwnedThread,
+    userdata::OwnedAnyUserData,
+};
+
 /// Create a type that implements [`AsChunk`] and can capture Rust variables.
 ///
 /// This macro allows to write Lua code directly in Rust code.
 ///
 /// Rust variables can be referenced from Lua using `$` prefix, as shown in the example below.
-/// User 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.
+/// Captured variables are **moved** into the chunk.
 ///
 /// ```
 /// use mlua::{Lua, Result, chunk};
@@ -165,24 +192,93 @@ extern crate mlua_derive;
 ///   (Single quoted strings only work if they contain a single character, since in Rust,
 ///   `'a'` is a character literal).
 ///
+/// - Using Lua comments `--` is not desirable in **stable** Rust and can have bad side effects.
+///
+///   This is because procedural macros have Line/Column information available only in
+///   **nightly** Rust. Instead, Lua chunks represented as a big single line of code in stable Rust.
+///
+///   As workaround, Rust comments `//` can be used.
+///
 /// Other minor limitations:
 ///
-/// - Certain escape codes in string literals.
+/// - 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`
+///   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`]: trait.AsChunk.html
-/// [`UserData`]: trait.UserData.html
-/// [`ToLua`]: trait.ToLua.html
-#[cfg(any(feature = "macros"))]
+/// [`AsChunk`]: crate::AsChunk
+/// [`UserData`]: crate::UserData
+/// [`IntoLua`]: crate::IntoLua
+#[cfg(feature = "macros")]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
 
-#[cfg(any(feature = "module"))]
+/// 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.
+///
+/// ```
+/// use mlua::{Lua, Result, Table};
+///
+/// #[mlua::lua_module]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     let exports = lua.create_table()?;
+///     exports.set("hello", "world")?;
+///     Ok(exports)
+/// }
+/// ```
+///
+/// Internally in the code above the compiler defines C function `luaopen_my_module`.
+///
+/// You can also pass options to the attribute:
+///
+/// * name - name of the module, defaults to the name of the function
+///
+/// ```ignore
+/// #[mlua::lua_module(name = "alt_module")]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     ...
+/// }
+/// ```
+///
+/// * skip_memory_check - skip memory allocation checks for some operations.
+///
+/// In module mode, mlua runs in unknown environment and cannot say are there any memory
+/// limits or not. As result, some operations that require memory allocation runs in
+/// protected mode. Setting this attribute will improve performance of such operations
+/// with risk of having uncaught exceptions and memory leaks.
+///
+/// ```ignore
+/// #[mlua::lua_module(skip_memory_check)]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     ...
+/// }
+/// ```
+///
+#[cfg(any(feature = "module", docsrs))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;
+
+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/mod.rs

@@ -0,0 +1,88 @@
+use std::ffi::CStr;
+use std::os::raw::{c_float, c_int};
+
+use crate::error::Result;
+use crate::lua::Lua;
+
+// Since Luau has some missing standard functions, we re-implement them here
+
+impl Lua {
+    pub(crate) unsafe fn configure_luau(&self) -> Result<()> {
+        let globals = self.globals();
+
+        globals.raw_set(
+            "collectgarbage",
+            self.create_c_function(lua_collectgarbage)?,
+        )?;
+        globals.raw_set("vector", self.create_c_function(lua_vector)?)?;
+
+        // 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}"))?;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn disable_c_modules(&self) -> Result<()> {
+        package::disable_dylibs(self);
+        Ok(())
+    }
+}
+
+unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
+    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")),
+    }
+}
+
+// Luau vector datatype constructor
+unsafe extern "C-unwind" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
+    let x = ffi::luaL_checknumber(state, 1) as c_float;
+    let y = ffi::luaL_checknumber(state, 2) as c_float;
+    let z = ffi::luaL_checknumber(state, 3) as c_float;
+    #[cfg(feature = "luau-vector4")]
+    let w = ffi::luaL_checknumber(state, 4) as c_float;
+
+    #[cfg(not(feature = "luau-vector4"))]
+    ffi::lua_pushvector(state, x, y, z);
+    #[cfg(feature = "luau-vector4")]
+    ffi::lua_pushvector(state, x, y, z, w);
+    1
+}
+
+pub(crate) use package::register_package_module;
+
+mod package;

src/luau/package.rs

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

src/macros.rs

@@ -17,19 +17,19 @@ macro_rules! cstr {
 
 macro_rules! mlua_panic {
     ($msg:expr) => {
-        panic!(bug_msg!($msg));
+        panic!(bug_msg!($msg))
     };
 
     ($msg:expr,) => {
-        mlua_panic!($msg);
+        mlua_panic!($msg)
     };
 
     ($msg:expr, $($arg:expr),+) => {
-        panic!(bug_msg!($msg), $($arg),+);
+        panic!(bug_msg!($msg), $($arg),+)
     };
 
     ($msg:expr, $($arg:expr),+,) => {
-        mlua_panic!($msg, $($arg),+);
+        mlua_panic!($msg, $($arg),+)
     };
 }
 
@@ -94,3 +94,24 @@ macro_rules! require_module_feature {
         compile_error!("Feature `module` must be enabled in the `mlua` crate");
     };
 }
+
+macro_rules! protect_lua {
+    ($state:expr, $nargs:expr, $nresults:expr, $f:expr) => {
+        crate::util::protect_lua_closure($state, $nargs, $nresults, $f)
+    };
+
+    ($state:expr, $nargs:expr, $nresults:expr, fn($state_inner:ident) $code:expr) => {{
+        use ::std::os::raw::c_int;
+        unsafe extern "C-unwind" fn do_call($state_inner: *mut ffi::lua_State) -> c_int {
+            $code;
+            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,147 @@
+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 {
+    #[inline]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        #[cfg(feature = "luau")]
+        {
+            ffi::lua_getallocf(state, &mut mem_state);
+            mlua_assert!(!mem_state.is_null(), "Luau state has no allocator userdata");
+        }
+        #[cfg(not(feature = "luau"))]
+        if ffi::lua_getallocf(state, &mut mem_state) != ALLOCATOR {
+            mem_state = ptr::null_mut();
+        }
+        mem_state as *mut MemoryState
+    }
+
+    #[inline]
+    pub(crate) fn used_memory(&self) -> usize {
+        self.used_memory as usize
+    }
+
+    #[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-unwind" 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,52 +1,107 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::iter::FromIterator;
 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::util::check_stack;
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil};
 
 /// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
 /// on success, or in the case of an error, returning `nil` and an error message.
-impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E> {
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut result = MultiValue::new();
-
+impl<'lua, T: IntoLua<'lua>, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<T, E> {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        let mut result = MultiValue::with_lua_and_capacity(lua, 2);
         match self {
-            Ok(v) => result.push_front(v.to_lua(lua)?),
+            Ok(v) => result.push_front(v.into_lua(lua)?),
             Err(e) => {
-                result.push_front(e.to_lua(lua)?);
+                result.push_front(e.into_lua(lua)?);
                 result.push_front(Nil);
             }
         }
-
         Ok(result)
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut v = MultiValue::new();
-        v.push_front(self.to_lua(lua)?);
+impl<'lua, E: IntoLua<'lua>> IntoLuaMulti<'lua> for StdResult<(), E> {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        match self {
+            Ok(_) => return Ok(MultiValue::new()),
+            Err(e) => {
+                let mut result = MultiValue::with_lua_and_capacity(lua, 2);
+                result.push_front(e.into_lua(lua)?);
+                result.push_front(Nil);
+                Ok(result)
+            }
+        }
+    }
+}
+
+impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for T {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        let mut v = MultiValue::with_lua_and_capacity(lua, 1);
+        v.push_front(self.into_lua(lua)?);
         Ok(v)
     }
+
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> Result<c_int> {
+        self.push_into_stack(lua)?;
+        Ok(1)
+    }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
+    #[inline]
     fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
         T::from_lua(values.pop_front().unwrap_or(Nil), lua)
     }
+
+    #[inline]
+    fn from_lua_args(
+        mut args: MultiValue<'lua>,
+        i: usize,
+        to: Option<&str>,
+        lua: &'lua Lua,
+    ) -> Result<Self> {
+        T::from_lua_arg(args.pop_front().unwrap_or(Nil), i, to, lua)
+    }
+
+    #[inline]
+    unsafe fn from_stack_multi(nvals: c_int, lua: &'lua Lua) -> Result<Self> {
+        if nvals == 0 {
+            return T::from_lua(Nil, lua);
+        }
+        T::from_stack(-nvals, lua)
+    }
+
+    #[inline]
+    unsafe fn from_stack_args(
+        nargs: c_int,
+        i: usize,
+        to: Option<&str>,
+        lua: &'lua Lua,
+    ) -> Result<Self> {
+        if nargs == 0 {
+            return T::from_lua_arg(Nil, i, to, lua);
+        }
+        T::from_stack_arg(-nargs, i, to, lua)
+    }
 }
 
-impl<'lua> ToLuaMulti<'lua> for MultiValue<'lua> {
-    fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
+impl<'lua> IntoLuaMulti<'lua> for MultiValue<'lua> {
+    #[inline]
+    fn into_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
         Ok(self)
     }
 }
 
 impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
+    #[inline]
     fn from_lua_multi(values: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
         Ok(values)
     }
@@ -76,14 +131,14 @@ impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
 /// # }
 /// ```
 ///
-/// [`FromLua`]: trait.FromLua.html
-/// [`MultiValue`]: struct.MultiValue.html
+/// [`FromLua`]: crate::FromLua
+/// [`MultiValue`]: crate::MultiValue
 #[derive(Debug, Clone)]
 pub struct Variadic<T>(Vec<T>);
 
 impl<T> Variadic<T> {
     /// Creates an empty `Variadic` wrapper containing no values.
-    pub fn new() -> Variadic<T> {
+    pub const fn new() -> Variadic<T> {
         Variadic(Vec::new())
     }
 }
@@ -123,16 +178,20 @@ impl<T> DerefMut for Variadic<T> {
     }
 }
 
-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        self.0.into_iter().map(|e| e.to_lua(lua)).collect()
+impl<'lua, T: IntoLua<'lua>> IntoLuaMulti<'lua> for Variadic<T> {
+    #[inline]
+    fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+        let mut values = MultiValue::with_lua_and_capacity(lua, self.0.len());
+        values.refill(self.0.into_iter().map(|e| e.into_lua(lua)))?;
+        Ok(values)
     }
 }
 
 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
-    fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+    #[inline]
+    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
         values
-            .into_iter()
+            .drain_all()
             .map(|e| T::from_lua(e, lua))
             .collect::<Result<Vec<T>>>()
             .map(Variadic)
@@ -141,45 +200,119 @@ impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
 
 macro_rules! impl_tuple {
     () => (
-        impl<'lua> ToLuaMulti<'lua> for () {
-            fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
-                Ok(MultiValue::new())
+        impl<'lua> IntoLuaMulti<'lua> for () {
+            #[inline]
+            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+                Ok(MultiValue::with_lua_and_capacity(lua, 0))
+            }
+
+            #[inline]
+            unsafe fn push_into_stack_multi(self, _lua: &'lua Lua) -> Result<c_int> {
+                Ok(0)
             }
         }
 
         impl<'lua> FromLuaMulti<'lua> for () {
-            fn from_lua_multi(_: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
+            #[inline]
+            fn from_lua_multi(_values: MultiValue<'lua>, _lua: &'lua Lua) -> Result<Self> {
+                Ok(())
+            }
+
+            #[inline]
+            unsafe fn from_stack_multi(nvals: c_int, lua: &'lua Lua) -> Result<Self> {
+                if nvals > 0 {
+                    ffi::lua_pop(lua.state(), nvals);
+                }
                 Ok(())
             }
         }
     );
 
     ($last:ident $($name:ident)*) => (
-        impl<'lua, $($name,)* $last> ToLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: ToLua<'lua>,)*
-                  $last: ToLuaMulti<'lua>
+        impl<'lua, $($name,)* $last> IntoLuaMulti<'lua> for ($($name,)* $last,)
+            where $($name: IntoLua<'lua>,)*
+                  $last: IntoLuaMulti<'lua>
         {
-            #[allow(unused_mut)]
-            #[allow(non_snake_case)]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+            #[allow(unused_mut, non_snake_case)]
+            #[inline]
+            fn into_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
                 let ($($name,)* $last,) = self;
 
-                let mut results = $last.to_lua_multi(lua)?;
-                push_reverse!(results, $($name.to_lua(lua)?,)*);
+                let mut results = $last.into_lua_multi(lua)?;
+                push_reverse!(results, $($name.into_lua(lua)?,)*);
                 Ok(results)
             }
+
+            #[allow(non_snake_case)]
+            #[inline]
+            unsafe fn push_into_stack_multi(self, lua: &'lua Lua) -> 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>
         {
-            #[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);)*
+                $(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<'lua>, mut i: usize, to: Option<&str>, lua: &'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: &'lua Lua) -> Result<Self> {
+                $(
+                    let $name = if nvals > 0 {
+                        nvals -= 1;
+                        FromLua::from_stack(-(nvals + 1), lua)
+                    } else {
+                        FromLua::from_lua(Nil, 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: &'lua Lua) -> 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)
+                    }?;
+                    i += 1;
+                )*
+                let $last = FromLuaMulti::from_stack_args(nargs, i, to, lua)?;
+                Ok(($($name,)* $last,))
             }
         }
     );

src/prelude.rs

@@ -1,21 +1,44 @@
 //! Re-exports most types with an extra `Lua*` prefix to prevent name clashes.
 
+#[doc(no_inline)]
 pub use crate::{
-    AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Error as LuaError,
-    ExternalError as LuaExternalError, ExternalResult as LuaExternalResult, FromLua, FromLuaMulti,
-    Function as LuaFunction, GCMode as LuaGCMode, Integer as LuaInteger,
-    LightUserData as LuaLightUserData, Lua, LuaOptions, MetaMethod as LuaMetaMethod,
+    AnyUserData as LuaAnyUserData, AnyUserDataExt as LuaAnyUserDataExt, Chunk as LuaChunk,
+    Error as LuaError, ErrorContext as LuaErrorContext, ExternalError as LuaExternalError,
+    ExternalResult as LuaExternalResult, FromLua, FromLuaMulti, Function as LuaFunction,
+    FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode, Integer as LuaInteger, IntoLua,
+    IntoLuaMulti, LightUserData as LuaLightUserData, Lua, LuaOptions, MetaMethod as LuaMetaMethod,
     MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber, RegistryKey as LuaRegistryKey,
-    Result as LuaResult, 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,
+    Result as LuaResult, StdLib as LuaStdLib, String as LuaString, Table as LuaTable,
+    TableExt as LuaTableExt, TablePairs as LuaTablePairs, TableSequence as LuaTableSequence,
+    Thread as LuaThread, ThreadStatus as LuaThreadStatus, UserData as LuaUserData,
     UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
-    UserDataMethods as LuaUserDataMethods, Value as LuaValue,
+    UserDataMethods as LuaUserDataMethods, UserDataRef as LuaUserDataRef,
+    UserDataRefMut as LuaUserDataRefMut, UserDataRegistry as LuaUserDataRegistry,
+    Value as LuaValue,
 };
 
+#[cfg(not(feature = "luau"))]
+#[doc(no_inline)]
+pub use crate::HookTriggers as LuaHookTriggers;
+
+#[cfg(feature = "luau")]
+#[doc(no_inline)]
+pub use crate::{CoverageInfo as LuaCoverageInfo, Vector as LuaVector, VmState as LuaVmState};
+
 #[cfg(feature = "async")]
+#[doc(no_inline)]
 pub use crate::AsyncThread as LuaAsyncThread;
 
 #[cfg(feature = "serialize")]
-#[doc(inline)]
-pub use crate::{LuaSerdeExt, SerializeOptions as LuaSerializeOptions};
+#[doc(no_inline)]
+pub use crate::{
+    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt,
+    SerializeOptions as LuaSerializeOptions,
+};
+
+#[cfg(feature = "unstable")]
+#[doc(no_inline)]
+pub use crate::{
+    OwnedAnyUserData as LuaOwnedAnyUserData, OwnedFunction as LuaOwnedFunction,
+    OwnedString as LuaOwnedString, OwnedTable as LuaOwnedTable, OwnedThread as LuaOwnedThread,
+};

src/serde/de.rs

@@ -1,19 +1,124 @@
+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;
 use serde::de::{self, IntoDeserializer};
 
 use crate::error::{Error, Result};
-use crate::table::{TablePairs, TableSequence};
+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<'lua>);
+pub struct Deserializer<'lua> {
+    value: Value<'lua>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+}
+
+/// 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 [`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
+    /// [`LightUserData`]: crate::LightUserData
+    /// [`Error`]: crate::Error
+    pub deny_unsupported_types: bool,
+
+    /// If true, an attempt to serialize a recursive table (table that refers to itself)
+    /// will cause an error.
+    /// Otherwise subsequent attempts to serialize the same table will be ignored.
+    ///
+    /// Default: **true**
+    pub deny_recursive_tables: bool,
+
+    /// If true, keys in tables will be iterated in sorted order.
+    ///
+    /// Default: **false**
+    pub sort_keys: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Options {
+    /// Returns a new instance of `Options` with default parameters.
+    pub const fn new() -> Self {
+        Options {
+            deny_unsupported_types: true,
+            deny_recursive_tables: true,
+            sort_keys: false,
+        }
+    }
+
+    /// Sets [`deny_unsupported_types`] option.
+    ///
+    /// [`deny_unsupported_types`]: #structfield.deny_unsupported_types
+    #[must_use]
+    pub const fn deny_unsupported_types(mut self, enabled: bool) -> Self {
+        self.deny_unsupported_types = enabled;
+        self
+    }
+
+    /// Sets [`deny_recursive_tables`] option.
+    ///
+    /// [`deny_recursive_tables`]: #structfield.deny_recursive_tables
+    #[must_use]
+    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
+    }
+}
 
 impl<'lua> Deserializer<'lua> {
     /// Creates a new Lua Deserializer for the `Value`.
     pub fn new(value: Value<'lua>) -> Self {
-        Deserializer(value)
+        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 {
+        Deserializer {
+            value,
+            options,
+            visited: Rc::new(RefCell::new(FxHashSet::default())),
+        }
+    }
+
+    fn from_parts(
+        value: Value<'lua>,
+        options: Options,
+        visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+    ) -> Self {
+        Deserializer {
+            value,
+            options,
+            visited,
+        }
     }
 }
 
@@ -25,13 +130,17 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     where
         V: de::Visitor<'de>,
     {
-        match self.0 {
+        match self.value {
             Value::Nil => visitor.visit_unit(),
             Value::Boolean(b) => visitor.visit_bool(b),
             #[allow(clippy::useless_conversion)]
-            Value::Integer(i) => visitor.visit_i64(i.into()),
+            Value::Integer(i) => {
+                visitor.visit_i64(i.try_into().expect("cannot convert lua_Integer to i64"))
+            }
             #[allow(clippy::useless_conversion)]
             Value::Number(n) => visitor.visit_f64(n.into()),
+            #[cfg(feature = "luau")]
+            Value::Vector(_) => self.deserialize_seq(visitor),
             Value::String(s) => match s.to_str() {
                 Ok(s) => visitor.visit_str(s),
                 Err(_) => visitor.visit_bytes(s.as_bytes()),
@@ -39,11 +148,21 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
             Value::Table(ref t) if t.raw_len() > 0 || t.is_array() => self.deserialize_seq(visitor),
             Value::Table(_) => self.deserialize_map(visitor),
             Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_none(),
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_any(visitor))
+            }
             Value::Function(_)
             | Value::Thread(_)
             | Value::UserData(_)
             | Value::LightUserData(_)
-            | Value::Error(_) => Err(de::Error::custom("invalid value type")),
+            | Value::Error(_) => {
+                if self.options.deny_unsupported_types {
+                    let msg = format!("unsupported value type `{}`", self.value.type_name());
+                    Err(de::Error::custom(msg))
+                } else {
+                    visitor.visit_unit()
+                }
+            }
         }
     }
 
@@ -52,7 +171,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     where
         V: de::Visitor<'de>,
     {
-        match self.0 {
+        match self.value {
             Value::Nil => visitor.visit_none(),
             Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_none(),
             _ => visitor.visit_some(self),
@@ -62,16 +181,18 @@ 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
         V: de::Visitor<'de>,
     {
-        let (variant, value) = match self.0 {
-            Value::Table(value) => {
-                let mut iter = value.pairs::<StdString, Value>();
+        let (variant, value, _guard) = match self.value {
+            Value::Table(table) => {
+                let _guard = RecursionGuard::new(&table, &self.visited);
+
+                let mut iter = table.pairs::<StdString, Value>();
                 let (variant, value) = match iter.next() {
                     Some(v) => v?,
                     None => {
@@ -88,13 +209,27 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                         &"map with a single key",
                     ));
                 }
-                (variant, Some(value))
+                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));
             }
-            Value::String(variant) => (variant.to_str()?.to_owned(), None),
             _ => return Err(de::Error::custom("bad enum value")),
         };
 
-        visitor.visit_enum(EnumDeserializer { variant, value })
+        visitor.visit_enum(EnumDeserializer {
+            variant,
+            value,
+            options: self.options,
+            visited: self.visited,
+        })
     }
 
     #[inline]
@@ -102,12 +237,28 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     where
         V: de::Visitor<'de>,
     {
-        match self.0 {
+        match self.value {
+            #[cfg(feature = "luau")]
+            Value::Vector(vec) => {
+                let mut deserializer = VecDeserializer {
+                    vec,
+                    next: 0,
+                    options: self.options,
+                    visited: self.visited,
+                };
+                visitor.visit_seq(&mut deserializer)
+            }
             Value::Table(t) => {
-                let len = t.raw_len() as usize;
-                let mut deserializer = SeqDeserializer(t.raw_sequence_values());
+                let _guard = RecursionGuard::new(&t, &self.visited);
+
+                let len = t.raw_len();
+                let mut deserializer = SeqDeserializer {
+                    seq: t.sequence_values(),
+                    options: self.options,
+                    visited: self.visited,
+                };
                 let seq = visitor.visit_seq(&mut deserializer)?;
-                if deserializer.0.count() == 0 {
+                if deserializer.seq.count() == 0 {
                     Ok(seq)
                 } else {
                     Err(de::Error::invalid_length(
@@ -116,7 +267,13 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                     ))
                 }
             }
-            _ => Err(de::Error::custom("invalid value type")),
+            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",
+            )),
         }
     }
 
@@ -146,9 +303,17 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
     where
         V: de::Visitor<'de>,
     {
-        match self.0 {
+        match self.value {
             Value::Table(t) => {
-                let mut deserializer = MapDeserializer::new(t.pairs());
+                let _guard = RecursionGuard::new(&t, &self.visited);
+
+                let mut deserializer = MapDeserializer {
+                    pairs: MapPairs::new(t, self.options.sort_keys)?,
+                    value: None,
+                    options: self.options,
+                    visited: self.visited,
+                    processed: 0,
+                };
                 let map = visitor.visit_map(&mut deserializer)?;
                 let count = deserializer.pairs.count();
                 if count == 0 {
@@ -160,7 +325,13 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                     ))
                 }
             }
-            _ => Err(de::Error::custom("invalid value type")),
+            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",
+            )),
         }
     }
 
@@ -177,14 +348,52 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
         self.deserialize_map(visitor)
     }
 
+    #[inline]
+    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match self.value {
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_newtype_struct(name, visitor))
+            }
+            _ => visitor.visit_newtype_struct(self),
+        }
+    }
+
+    #[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 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf unit unit_struct newtype_struct
-        identifier ignored_any
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes
+        byte_buf identifier ignored_any
     }
 }
 
-struct SeqDeserializer<'lua>(TableSequence<'lua, Value<'lua>>);
+struct SeqDeserializer<'lua> {
+    seq: TableSequence<'lua, Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+}
 
 impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
     type Error = Error;
@@ -193,34 +402,113 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
     where
         T: de::DeserializeSeed<'de>,
     {
-        match self.0.next() {
-            Some(value) => seed.deserialize(Deserializer(value?)).map(Some),
-            None => Ok(None),
+        loop {
+            match self.seq.next() {
+                Some(value) => {
+                    let value = value?;
+                    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);
+                    let deserializer = Deserializer::from_parts(value, self.options, visited);
+                    return seed.deserialize(deserializer).map(Some);
+                }
+                None => return Ok(None),
+            }
         }
     }
 
     fn size_hint(&self) -> Option<usize> {
-        match self.0.size_hint() {
+        match self.seq.size_hint() {
             (lower, Some(upper)) if lower == upper => Some(upper),
             _ => None,
         }
     }
 }
 
-struct MapDeserializer<'lua> {
-    pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>,
-    value: Option<Value<'lua>>,
-    processed: usize,
+#[cfg(feature = "luau")]
+struct VecDeserializer {
+    vec: crate::types::Vector,
+    next: usize,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
-impl<'lua> MapDeserializer<'lua> {
-    fn new(pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>) -> Self {
-        MapDeserializer {
-            pairs,
-            value: None,
-            processed: 0,
+#[cfg(feature = "luau")]
+impl<'de> de::SeqAccess<'de> for VecDeserializer {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        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);
+                seed.deserialize(deserializer).map(Some)
+            }
+            None => Ok(None),
         }
     }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(crate::types::Vector::SIZE)
+    }
+}
+
+pub(crate) enum MapPairs<'lua> {
+    Iter(TablePairs<'lua, Value<'lua>, Value<'lua>>),
+    Vec(Vec<(Value<'lua>, Value<'lua>)>),
+}
+
+impl<'lua> MapPairs<'lua> {
+    pub(crate) fn new(t: Table<'lua>, sort_keys: bool) -> Result<Self> {
+        if sort_keys {
+            let mut pairs = t.pairs::<Value, Value>().collect::<Result<Vec<_>>>()?;
+            pairs.sort_by(|(a, _), (b, _)| b.cmp(a)); // reverse order as we pop values from the end
+            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<'lua> Iterator for MapPairs<'lua> {
+    type Item = Result<(Value<'lua>, Value<'lua>)>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            MapPairs::Iter(iter) => iter.next(),
+            MapPairs::Vec(vec) => vec.pop().map(Ok),
+        }
+    }
+}
+
+struct MapDeserializer<'lua> {
+    pairs: MapPairs<'lua>,
+    value: Option<Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+    processed: usize,
 }
 
 impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
@@ -230,15 +518,25 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
     where
         T: de::DeserializeSeed<'de>,
     {
-        match self.pairs.next() {
-            Some(item) => {
-                let (key, value) = item?;
-                self.processed += 1;
-                self.value = Some(value);
-                let key_de = Deserializer(key);
-                seed.deserialize(key_de).map(Some)
+        loop {
+            match self.pairs.next() {
+                Some(item) => {
+                    let (key, value) = item?;
+                    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);
+                }
+                None => return Ok(None),
             }
-            None => Ok(None),
         }
     }
 
@@ -247,7 +545,10 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
         T: de::DeserializeSeed<'de>,
     {
         match self.value.take() {
-            Some(value) => seed.deserialize(Deserializer(value)),
+            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")),
         }
     }
@@ -263,6 +564,8 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
 struct EnumDeserializer<'lua> {
     variant: StdString,
     value: Option<Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
 impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
@@ -274,13 +577,19 @@ impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
         T: de::DeserializeSeed<'de>,
     {
         let variant = self.variant.into_deserializer();
-        let variant_access = VariantDeserializer { value: self.value };
+        let variant_access = VariantDeserializer {
+            value: self.value,
+            options: self.options,
+            visited: self.visited,
+        };
         seed.deserialize(variant).map(|v| (v, variant_access))
     }
 }
 
 struct VariantDeserializer<'lua> {
     value: Option<Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
 
 impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
@@ -301,7 +610,9 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
         T: de::DeserializeSeed<'de>,
     {
         match self.value {
-            Some(value) => seed.deserialize(Deserializer(value)),
+            Some(value) => {
+                seed.deserialize(Deserializer::from_parts(value, self.options, self.visited))
+            }
             None => Err(de::Error::invalid_type(
                 de::Unexpected::UnitVariant,
                 &"newtype variant",
@@ -314,7 +625,10 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
         V: de::Visitor<'de>,
     {
         match self.value {
-            Some(value) => serde::Deserializer::deserialize_seq(Deserializer(value), visitor),
+            Some(value) => serde::Deserializer::deserialize_seq(
+                Deserializer::from_parts(value, self.options, self.visited),
+                visitor,
+            ),
             None => Err(de::Error::invalid_type(
                 de::Unexpected::UnitVariant,
                 &"tuple variant",
@@ -327,7 +641,10 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
         V: de::Visitor<'de>,
     {
         match self.value {
-            Some(value) => serde::Deserializer::deserialize_map(Deserializer(value), visitor),
+            Some(value) => serde::Deserializer::deserialize_map(
+                Deserializer::from_parts(value, self.options, self.visited),
+                visitor,
+            ),
             None => Err(de::Error::invalid_type(
                 de::Unexpected::UnitVariant,
                 &"struct variant",
@@ -335,3 +652,65 @@ 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 {
+    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 {
+        let visited = Rc::clone(visited);
+        let ptr = table.to_pointer();
+        visited.borrow_mut().insert(ptr);
+        RecursionGuard { ptr, visited }
+    }
+}
+
+impl Drop for RecursionGuard {
+    fn drop(&mut self) {
+        self.visited.borrow_mut().remove(&self.ptr);
+    }
+}
+
+// Checks `options` and decides should we emit an error or skip next element
+pub(crate) fn check_value_for_skip(
+    value: &Value,
+    options: Options,
+    visited: &RefCell<FxHashSet<*const c_void>>,
+) -> 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("recursive table detected");
+                }
+                return Ok(true); // skip
+            }
+        }
+        Value::UserData(ud) if ud.is_serializable() => {}
+        Value::Function(_)
+        | Value::Thread(_)
+        | Value::UserData(_)
+        | Value::LightUserData(_)
+        | Value::Error(_)
+            if !options.deny_unsupported_types =>
+        {
+            return Ok(true); // skip
+        }
+        _ => {}
+    }
+    Ok(false) // do not skip
+}
+
+fn serde_userdata<V>(
+    ud: AnyUserData,
+    f: impl FnOnce(serde_value::Value) -> std::result::Result<V, serde_value::DeserializerError>,
+) -> Result<V> {
+    let value = serde_value::to_value(ud).map_err(|err| Error::SerializeError(err.to_string()))?;
+    f(value).map_err(|err| Error::DeserializeError(err.to_string()))
+}

src/serde/mod.rs

@@ -1,20 +1,19 @@
 //! (De)Serialization support using serde.
 
 use std::os::raw::c_void;
-use std::ptr;
 
-use serde::{Deserialize, Serialize};
+use serde::{de::DeserializeOwned, ser::Serialize};
 
 use crate::error::Result;
-use crate::ffi;
 use crate::lua::Lua;
+use crate::private::Sealed;
 use crate::table::Table;
-use crate::types::LightUserData;
-use crate::util::{assert_stack, check_stack, StackGuard};
+use crate::util::check_stack;
 use crate::value::Value;
 
 /// Trait for serializing/deserializing Lua values using Serde.
-pub trait LuaSerdeExt<'lua> {
+#[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+pub trait LuaSerdeExt: Sealed {
     /// A special value (lightuserdata) to encode/decode optional (none) values.
     ///
     /// Requires `feature = "serialize"`
@@ -36,7 +35,7 @@ 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
@@ -67,13 +66,13 @@ pub trait LuaSerdeExt<'lua> {
     ///     Ok(())
     /// }
     /// ```
-    fn array_metatable(&'lua self) -> Table<'lua>;
+    fn array_metatable(&self) -> Table;
 
-    /// Converts `T` into a `Value` instance.
+    /// Converts `T` into a [`Value`] instance.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
     ///
     /// # Example
     ///
@@ -100,13 +99,13 @@ pub trait LuaSerdeExt<'lua> {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value<T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
+    fn to_value<'lua, T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
 
-    /// Converts `T` into a `Value` instance with options.
+    /// Converts `T` into a [`Value`] instance with options.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
     ///
     /// # Example
     ///
@@ -125,15 +124,15 @@ pub trait LuaSerdeExt<'lua> {
     ///     "#).exec()
     /// }
     /// ```
-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<'lua, T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
     where
         T: Serialize + ?Sized;
 
-    /// Deserializes a `Value` into any serde deserializable object.
+    /// Deserializes a [`Value`] into any serde deserializable object.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
     ///
     /// # Example
     ///
@@ -157,62 +156,101 @@ pub trait LuaSerdeExt<'lua> {
     ///     Ok(())
     /// }
     /// ```
-    fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> Result<T>;
+    #[allow(clippy::wrong_self_convention)]
+    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
+    ///
+    /// ```
+    /// use mlua::{Lua, Result, LuaSerdeExt, DeserializeOptions};
+    /// use serde::Deserialize;
+    ///
+    /// #[derive(Deserialize, Debug, PartialEq)]
+    /// struct User {
+    ///     name: String,
+    ///     age: u8,
+    /// }
+    ///
+    /// fn main() -> Result<()> {
+    ///     let lua = Lua::new();
+    ///     let val = lua.load(r#"{name = "John Smith", age = 20, f = function() end}"#).eval()?;
+    ///     let options = DeserializeOptions::new().deny_unsupported_types(false);
+    ///     let u: User = lua.from_value_with(val, options)?;
+    ///
+    ///     assert_eq!(u, User { name: "John Smith".into(), age: 20 });
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    #[allow(clippy::wrong_self_convention)]
+    fn from_value_with<T: DeserializeOwned>(&self, value: Value, options: de::Options)
+        -> Result<T>;
 }
 
-impl<'lua> LuaSerdeExt<'lua> for Lua {
-    fn null(&'lua self) -> Value<'lua> {
-        Value::LightUserData(LightUserData(ptr::null_mut()))
+impl LuaSerdeExt for Lua {
+    fn null(&self) -> Value {
+        Value::NULL
     }
 
-    fn array_metatable(&'lua self) -> Table<'lua> {
+    fn array_metatable(&self) -> Table {
         unsafe {
-            let _sg = StackGuard::new(self.state);
-            assert_stack(self.state, 1);
-
-            push_array_metatable(self.state);
-
-            Table(self.pop_ref())
+            push_array_metatable(self.ref_thread());
+            Table(self.pop_ref_thread())
         }
     }
 
-    fn to_value<T>(&'lua self, t: &T) -> Result<Value<'lua>>
+    fn to_value<'lua, T>(&'lua self, t: &T) -> Result<Value<'lua>>
     where
         T: Serialize + ?Sized,
     {
         t.serialize(ser::Serializer::new(self))
     }
 
-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<'lua, T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
     where
         T: Serialize + ?Sized,
     {
         t.serialize(ser::Serializer::new_with_options(self, options))
     }
 
-    fn from_value<T>(&'lua self, value: Value<'lua>) -> Result<T>
+    fn from_value<T>(&self, value: Value) -> Result<T>
     where
-        T: Deserialize<'lua>,
+        T: DeserializeOwned,
     {
         T::deserialize(de::Deserializer::new(value))
     }
+
+    fn from_value_with<T>(&self, value: Value, options: de::Options) -> Result<T>
+    where
+        T: DeserializeOwned,
+    {
+        T::deserialize(de::Deserializer::new_with_options(value, options))
+    }
 }
 
-// Uses 6 stack spaces and calls checkstack.
+// Uses 2 stack spaces and calls checkstack.
 pub(crate) unsafe fn init_metatables(state: *mut ffi::lua_State) -> Result<()> {
-    check_stack(state, 6)?;
+    check_stack(state, 2)?;
+    protect_lua!(state, 0, 0, fn(state) {
+        ffi::lua_createtable(state, 0, 1);
 
-    ffi::safe::lua_createtable(state, 0, 1)?;
+        ffi::lua_pushstring(state, cstr!("__metatable"));
+        ffi::lua_pushboolean(state, 0);
+        ffi::lua_rawset(state, -3);
 
-    ffi::lua_pushboolean(state, 0);
-    ffi::safe::lua_rawsetfield(state, -2, "__metatable")?;
-
-    let array_metatable_key = &ARRAY_METATABLE_REGISTRY_KEY as *const u8 as *const c_void;
-    ffi::safe::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, array_metatable_key)
+        let array_metatable_key = &ARRAY_METATABLE_REGISTRY_KEY as *const u8 as *const c_void;
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, array_metatable_key);
+    })
 }
 
 pub(crate) unsafe fn push_array_metatable(state: *mut ffi::lua_State) {
-    let array_metatable_key = &ARRAY_METATABLE_REGISTRY_KEY as *const u8 as *mut c_void;
+    let array_metatable_key = &ARRAY_METATABLE_REGISTRY_KEY as *const u8 as *const c_void;
     ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, array_metatable_key);
 }
 

src/serde/ser.rs

@@ -1,16 +1,11 @@
-use std::os::raw::c_int;
-
 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::table::Table;
-use crate::types::Integer;
-use crate::util::{check_stack, StackGuard};
-use crate::value::{ToLua, Value};
+use crate::value::{IntoLua, Value};
 
 /// A struct for serializing Rust values into Lua values.
 #[derive(Debug)]
@@ -28,16 +23,16 @@ pub struct Options {
     ///
     /// Default: **true**
     ///
-    /// [`array_metatable`]: ../trait.LuaSerdeExt.html#tymethod.array_metatable
+    /// [`array_metatable`]: crate::LuaSerdeExt::array_metatable
     pub set_array_metatable: bool,
 
-    /// If true, serialize `None` (part of `Option` type) to [`null`].
+    /// If true, serialize `None` (part of the `Option` type) to [`null`].
     /// Otherwise it will be set to Lua [`Nil`].
     ///
     /// Default: **true**
     ///
-    /// [`null`]: ../trait.LuaSerdeExt.html#tymethod.null
-    /// [`Nil`]: ../../enum.Value.html#variant.Nil
+    /// [`null`]: crate::LuaSerdeExt::null
+    /// [`Nil`]: crate::Value::Nil
     pub serialize_none_to_null: bool,
 
     /// If true, serialize `Unit` (type of `()` in Rust) and Unit structs to [`null`].
@@ -45,31 +40,32 @@ pub struct Options {
     ///
     /// Default: **true**
     ///
-    /// [`null`]: ../trait.LuaSerdeExt.html#tymethod.null
-    /// [`Nil`]: ../../enum.Value.html#variant.Nil
+    /// [`null`]: crate::LuaSerdeExt::null
+    /// [`Nil`]: crate::Value::Nil
     pub serialize_unit_to_null: bool,
 }
 
 impl Default for Options {
     fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Options {
+    /// Returns a new instance of [`Options`] with default parameters.
+    pub const fn new() -> Self {
         Options {
             set_array_metatable: true,
             serialize_none_to_null: true,
             serialize_unit_to_null: true,
         }
     }
-}
-
-impl Options {
-    /// Retruns a new instance of `Options` with default parameters.
-    pub fn new() -> Self {
-        Self::default()
-    }
 
     /// Sets [`set_array_metatable`] option.
     ///
     /// [`set_array_metatable`]: #structfield.set_array_metatable
-    pub fn set_array_metatable(mut self, enabled: bool) -> Self {
+    #[must_use]
+    pub const fn set_array_metatable(mut self, enabled: bool) -> Self {
         self.set_array_metatable = enabled;
         self
     }
@@ -77,7 +73,8 @@ impl Options {
     /// Sets [`serialize_none_to_null`] option.
     ///
     /// [`serialize_none_to_null`]: #structfield.serialize_none_to_null
-    pub fn serialize_none_to_null(mut self, enabled: bool) -> Self {
+    #[must_use]
+    pub const fn serialize_none_to_null(mut self, enabled: bool) -> Self {
         self.serialize_none_to_null = enabled;
         self
     }
@@ -85,7 +82,8 @@ impl Options {
     /// Sets [`serialize_unit_to_null`] option.
     ///
     /// [`serialize_unit_to_null`]: #structfield.serialize_unit_to_null
-    pub fn serialize_unit_to_null(mut self, enabled: bool) -> Self {
+    #[must_use]
+    pub const fn serialize_unit_to_null(mut self, enabled: bool) -> Self {
         self.serialize_unit_to_null = enabled;
         self
     }
@@ -107,7 +105,7 @@ macro_rules! lua_serialize_number {
     ($name:ident, $t:ty) => {
         #[inline]
         fn $name(self, value: $t) -> Result<Value<'lua>> {
-            value.to_lua(self.lua)
+            value.into_lua(self.lua)
         }
     };
 }
@@ -118,9 +116,9 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     // Associated types for keeping track of additional state while serializing
     // compound data structures like sequences and maps.
-    type SerializeSeq = SerializeVec<'lua>;
-    type SerializeTuple = SerializeVec<'lua>;
-    type SerializeTupleStruct = SerializeVec<'lua>;
+    type SerializeSeq = SerializeSeq<'lua>;
+    type SerializeTuple = SerializeSeq<'lua>;
+    type SerializeTupleStruct = SerializeSeq<'lua>;
     type SerializeTupleVariant = SerializeTupleVariant<'lua>;
     type SerializeMap = SerializeMap<'lua>;
     type SerializeStruct = SerializeMap<'lua>;
@@ -139,6 +137,8 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     lua_serialize_number!(serialize_u32, u32);
     lua_serialize_number!(serialize_i64, i64);
     lua_serialize_number!(serialize_u64, u64);
+    lua_serialize_number!(serialize_i128, i128);
+    lua_serialize_number!(serialize_u128, u128);
 
     lua_serialize_number!(serialize_f32, f32);
     lua_serialize_number!(serialize_f64, f64);
@@ -231,13 +231,11 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     #[inline]
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        let len = len.unwrap_or(0) as c_int;
-        let table = self.lua.create_table_with_capacity(len, 0)?;
+        let table = self.lua.create_table_with_capacity(len.unwrap_or(0), 0)?;
         if self.options.set_array_metatable {
             table.set_metatable(Some(self.lua.array_metatable()));
         }
-        let options = self.options;
-        Ok(SerializeVec { table, options })
+        Ok(SerializeSeq::new(table, self.options))
     }
 
     #[inline]
@@ -248,9 +246,14 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     #[inline]
     fn serialize_tuple_struct(
         self,
-        _name: &'static str,
+        name: &'static str,
         len: usize,
     ) -> Result<Self::SerializeTupleStruct> {
+        #[cfg(feature = "luau")]
+        if name == "Vector" && len == crate::types::Vector::SIZE {
+            return Ok(SerializeSeq::new_vector(self.lua, self.options));
+        }
+        _ = name;
         self.serialize_seq(Some(len))
     }
 
@@ -271,10 +274,9 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
 
     #[inline]
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
-        let len = len.unwrap_or(0) as c_int;
         Ok(SerializeMap {
             key: None,
-            table: self.lua.create_table_with_capacity(0, len)?,
+            table: self.lua.create_table_with_capacity(0, len.unwrap_or(0))?,
             options: self.options,
         })
     }
@@ -294,19 +296,47 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
     ) -> Result<Self::SerializeStructVariant> {
         Ok(SerializeStructVariant {
             name: self.lua.create_string(variant)?,
-            table: self.lua.create_table_with_capacity(0, len as c_int)?,
+            table: self.lua.create_table_with_capacity(0, len)?,
             options: self.options,
         })
     }
 }
 
 #[doc(hidden)]
-pub struct SerializeVec<'lua> {
-    table: Table<'lua>,
+pub struct SerializeSeq<'lua> {
+    lua: &'lua Lua,
+    #[cfg(feature = "luau")]
+    vector: Option<crate::types::Vector>,
+    table: Option<Table<'lua>>,
+    next: usize,
     options: Options,
 }
 
-impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
+impl<'lua> SerializeSeq<'lua> {
+    const fn new(table: Table<'lua>, options: Options) -> Self {
+        Self {
+            lua: table.0.lua,
+            #[cfg(feature = "luau")]
+            vector: None,
+            table: Some(table),
+            next: 0,
+            options,
+        }
+    }
+
+    #[cfg(feature = "luau")]
+    const fn new_vector(lua: &'lua Lua, options: Options) -> Self {
+        Self {
+            lua,
+            vector: Some(crate::types::Vector::zero()),
+            table: None,
+            next: 0,
+            options,
+        }
+    }
+}
+
+impl<'lua> ser::SerializeSeq for SerializeSeq<'lua> {
     type Ok = Value<'lua>;
     type Error = Error;
 
@@ -314,25 +344,19 @@ impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
     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, 6)?;
-
-            lua.push_ref(&self.table.0);
-            lua.push_value(value)?;
-            let len = ffi::lua_rawlen(lua.state, -2) as Integer;
-            ffi::safe::lua_rawseti(lua.state, -2, len + 1)
-        }
+        let value = self.lua.to_value_with(value, self.options)?;
+        let table = self.table.as_ref().unwrap();
+        table.raw_seti(self.next + 1, value)?;
+        self.next += 1;
+        Ok(())
     }
 
     fn end(self) -> Result<Value<'lua>> {
-        Ok(Value::Table(self.table))
+        Ok(Value::Table(self.table.unwrap()))
     }
 }
 
-impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
+impl<'lua> ser::SerializeTuple for SerializeSeq<'lua> {
     type Ok = Value<'lua>;
     type Error = Error;
 
@@ -348,7 +372,7 @@ impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
     }
 }
 
-impl<'lua> ser::SerializeTupleStruct for SerializeVec<'lua> {
+impl<'lua> ser::SerializeTupleStruct for SerializeSeq<'lua> {
     type Ok = Value<'lua>;
     type Error = Error;
 
@@ -356,10 +380,22 @@ impl<'lua> ser::SerializeTupleStruct for SerializeVec<'lua> {
     where
         T: Serialize + ?Sized,
     {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector.as_mut() {
+            let value = self.lua.to_value_with(value, self.options)?;
+            let value = self.lua.unpack(value)?;
+            vector.0[self.next] = value;
+            self.next += 1;
+            return Ok(());
+        }
         ser::SerializeSeq::serialize_element(self, value)
     }
 
     fn end(self) -> Result<Value<'lua>> {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector {
+            return Ok(Value::Vector(vector));
+        }
         ser::SerializeSeq::end(self)
     }
 }
@@ -380,9 +416,7 @@ impl<'lua> ser::SerializeTupleVariant for SerializeTupleVariant<'lua> {
         T: Serialize + ?Sized,
     {
         let lua = self.table.0.lua;
-        let idx = self.table.raw_len() + 1;
-        self.table
-            .raw_insert(idx, lua.to_value_with(value, self.options)?)
+        self.table.raw_push(lua.to_value_with(value, self.options)?)
     }
 
     fn end(self) -> Result<Value<'lua>> {

src/stdlib.rs

@@ -6,45 +6,69 @@ use std::u32;
 pub struct StdLib(u32);
 
 impl StdLib {
-    /// [`coroutine`](https://www.lua.org/manual/5.3/manual.html#6.2) library
+    /// [`coroutine`](https://www.lua.org/manual/5.4/manual.html#6.2) library
     ///
-    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    /// Requires `feature = "lua54/lua53/lua52/luau"`
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luau"
+    ))]
     pub const COROUTINE: StdLib = StdLib(1);
-    /// [`table`](https://www.lua.org/manual/5.3/manual.html#6.6) library
+
+    /// [`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.3/manual.html#6.8) library
+
+    /// [`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.3/manual.html#6.9) library
+
+    /// [`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.3/manual.html#6.4) library
+
+    /// [`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.3/manual.html#6.5) library
+
+    /// [`utf8`](https://www.lua.org/manual/5.4/manual.html#6.5) library
     ///
-    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    /// Requires `feature = "lua54/lua53/luau"`
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
     pub const UTF8: StdLib = StdLib(1 << 5);
+
     /// [`bit`](https://www.lua.org/manual/5.2/manual.html#6.7) library
     ///
-    /// Requires `feature = "lua52/luajit"`
-    #[cfg(any(feature = "lua52", feature = "luajit", doc))]
+    /// Requires `feature = "lua52/luajit/luau"`
+    #[cfg(any(feature = "lua52", feature = "luajit", feature = "luau", doc))]
     pub const BIT: StdLib = StdLib(1 << 6);
-    /// [`math`](https://www.lua.org/manual/5.3/manual.html#6.7) library
+
+    /// [`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.3/manual.html#6.3) library
+
+    /// [`package`](https://www.lua.org/manual/5.4/manual.html#6.3) library
     pub const PACKAGE: StdLib = StdLib(1 << 8);
+
+    /// [`buffer`](https://luau-lang.org/library#buffer-library) library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub const BUFFER: StdLib = StdLib(1 << 9);
+
     /// [`jit`](http://luajit.org/ext_jit.html) library
     ///
     /// Requires `feature = "luajit"`
     #[cfg(any(feature = "luajit", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
     pub const JIT: StdLib = StdLib(1 << 9);
 
     /// (**unsafe**) [`ffi`](http://luajit.org/ext_ffi.html) library
     ///
     /// Requires `feature = "luajit"`
     #[cfg(any(feature = "luajit", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
     pub const FFI: StdLib = StdLib(1 << 30);
-    /// (**unsafe**) [`debug`](https://www.lua.org/manual/5.3/manual.html#6.10) library
+
+    /// (**unsafe**) [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10) library
     pub const DEBUG: StdLib = StdLib(1 << 31);
 
     /// No libraries
@@ -52,7 +76,10 @@ impl StdLib {
     /// (**unsafe**) All standard libraries
     pub const ALL: StdLib = StdLib(u32::MAX);
     /// The safe subset of the standard libraries
+    #[cfg(not(feature = "luau"))]
     pub const ALL_SAFE: StdLib = StdLib((1 << 30) - 1);
+    #[cfg(feature = "luau")]
+    pub const ALL_SAFE: StdLib = StdLib(u32::MAX);
 
     pub fn contains(self, lib: Self) -> bool {
         (self & lib).0 != 0

src/string.rs

@@ -1,6 +1,8 @@
-use std::borrow::Cow;
+use std::borrow::{Borrow, Cow};
+use std::hash::{Hash, Hasher};
+use std::os::raw::c_void;
 use std::string::String as StdString;
-use std::{slice, str};
+use std::{fmt, slice, str};
 
 #[cfg(feature = "serialize")]
 use {
@@ -9,16 +11,35 @@ use {
 };
 
 use crate::error::{Error, Result};
-use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{assert_stack, StackGuard};
 
 /// Handle to an internal Lua string.
 ///
 /// Unlike Rust strings, Lua strings may not be valid UTF-8.
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct String<'lua>(pub(crate) LuaRef<'lua>);
 
+/// Owned handle to an internal Lua string.
+///
+/// The owned handle holds a *strong* reference to the current Lua instance.
+/// Be warned, if you place it into a Lua type (eg. [`UserData`] or a Rust callback), it is *very easy*
+/// to accidentally cause reference cycles that would prevent destroying Lua instance.
+///
+/// [`UserData`]: crate::UserData
+#[cfg(feature = "unstable")]
+#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
+#[derive(Clone)]
+pub struct OwnedString(pub(crate) crate::types::LuaOwnedRef);
+
+#[cfg(feature = "unstable")]
+impl OwnedString {
+    /// Get borrowed handle to the underlying Lua string.
+    #[cfg_attr(feature = "send", allow(unused))]
+    pub const fn to_ref(&self) -> String {
+        String(self.0.to_ref())
+    }
+}
+
 impl<'lua> String<'lua> {
     /// Get a `&str` slice if the Lua string is valid UTF-8.
     ///
@@ -38,6 +59,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn to_str(&self) -> Result<&str> {
         str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
             from: "string",
@@ -64,6 +86,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn to_string_lossy(&self) -> Cow<'_, str> {
         StdString::from_utf8_lossy(self.as_bytes())
     }
@@ -85,6 +108,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn as_bytes(&self) -> &[u8] {
         let nulled = self.as_bytes_with_nul();
         &nulled[..nulled.len() - 1]
@@ -92,25 +116,68 @@ impl<'lua> String<'lua> {
 
     /// Get the bytes that make up this string, including the trailing nul byte.
     pub fn as_bytes_with_nul(&self) -> &[u8] {
-        let lua = self.0.lua;
+        let ref_thread = self.0.lua.ref_thread();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
-
-            lua.push_ref(&self.0);
             mlua_debug_assert!(
-                ffi::lua_type(lua.state, -1) == ffi::LUA_TSTRING,
+                ffi::lua_type(ref_thread, self.0.index) == ffi::LUA_TSTRING,
                 "string ref is not string type"
             );
 
             let mut size = 0;
             // This will not trigger a 'm' error, because the reference is guaranteed to be of
             // string type
-            let data = ffi::lua_tolstring(lua.state, -1, &mut size);
+            let data = ffi::lua_tolstring(ref_thread, self.0.index, &mut size);
 
             slice::from_raw_parts(data as *const u8, size + 1)
         }
     }
+
+    /// Converts the string to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
+
+    /// Convert this handle to owned version.
+    #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+    #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+    #[inline]
+    pub fn into_owned(self) -> OwnedString {
+        OwnedString(self.0.into_owned())
+    }
+}
+
+impl<'lua> fmt::Debug for String<'lua> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let bytes = self.as_bytes();
+        // Check if the string is valid utf8
+        if let Ok(s) = str::from_utf8(bytes) {
+            return s.fmt(f);
+        }
+
+        // Format as bytes
+        write!(f, "b\"")?;
+        for &b in bytes {
+            // https://doc.rust-lang.org/reference/tokens.html#byte-escapes
+            match b {
+                b'\n' => write!(f, "\\n")?,
+                b'\r' => write!(f, "\\r")?,
+                b'\t' => write!(f, "\\t")?,
+                b'\\' | b'"' => write!(f, "\\{}", b as char)?,
+                b'\0' => write!(f, "\\0")?,
+                // ASCII printable
+                0x20..=0x7e => write!(f, "{}", b as char)?,
+                _ => write!(f, "\\x{b:02x}")?,
+            }
+        }
+        write!(f, "\"")?;
+
+        Ok(())
+    }
 }
 
 impl<'lua> AsRef<[u8]> for String<'lua> {
@@ -119,6 +186,12 @@ impl<'lua> AsRef<[u8]> for String<'lua> {
     }
 }
 
+impl<'lua> Borrow<[u8]> for String<'lua> {
+    fn borrow(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
 // Lua strings are basically &[u8] slices, so implement PartialEq for anything resembling that.
 //
 // This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str`, `String` and `mlua::String`
@@ -129,13 +202,21 @@ impl<'lua> AsRef<[u8]> for String<'lua> {
 // in other ways.
 impl<'lua, T> PartialEq<T> for String<'lua>
 where
-    T: AsRef<[u8]>,
+    T: AsRef<[u8]> + ?Sized,
 {
     fn eq(&self, other: &T) -> bool {
         self.as_bytes() == other.as_ref()
     }
 }
 
+impl<'lua> Eq for String<'lua> {}
+
+impl<'lua> Hash for String<'lua> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.as_bytes().hash(state);
+    }
+}
+
 #[cfg(feature = "serialize")]
 impl<'lua> Serialize for String<'lua> {
     fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
@@ -148,3 +229,41 @@ impl<'lua> Serialize for String<'lua> {
         }
     }
 }
+
+// Additional shortcuts
+#[cfg(feature = "unstable")]
+impl OwnedString {
+    /// Get a `&str` slice if the Lua string is valid UTF-8.
+    ///
+    /// This is a shortcut for [`String::to_str()`].
+    #[inline]
+    pub fn to_str(&self) -> Result<&str> {
+        let s = self.to_ref();
+        // Reattach lifetime to &self
+        unsafe { std::mem::transmute(s.to_str()) }
+    }
+
+    /// Get the bytes that make up this string.
+    ///
+    /// This is a shortcut for [`String::as_bytes()`].
+    #[inline]
+    pub fn as_bytes(&self) -> &[u8] {
+        let s = self.to_ref();
+        // Reattach lifetime to &self
+        unsafe { std::mem::transmute(s.as_bytes()) }
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl fmt::Debug for OwnedString {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.to_ref().fmt(f)
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(String: Send);
+}

src/thread.rs

@@ -1,41 +1,39 @@
-use std::cmp;
 use std::os::raw::c_int;
 
 use crate::error::{Error, Result};
-use crate::ffi;
+#[allow(unused)]
+use crate::lua::Lua;
 use crate::types::LuaRef;
-use crate::util::{assert_stack, check_stack, pop_error, StackGuard};
-use crate::value::{FromLuaMulti, MultiValue, ToLuaMulti};
+use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
+use crate::value::{FromLuaMulti, IntoLuaMulti};
 
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored"), doc))]
-use crate::function::Function;
+#[cfg(not(feature = "luau"))]
+use crate::{
+    hook::{Debug, HookTriggers},
+    types::MaybeSend,
+};
 
 #[cfg(feature = "async")]
 use {
-    crate::{
-        lua::{ASYNC_POLL_PENDING, WAKER_REGISTRY_KEY},
-        util::get_gc_userdata,
-        value::Value,
-    },
-    futures_core::{future::Future, stream::Stream},
+    crate::value::MultiValue,
+    futures_util::stream::Stream,
     std::{
-        cell::RefCell,
+        future::Future,
         marker::PhantomData,
-        mem,
-        os::raw::c_void,
         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`.
     ///
     /// If a thread is in this state, it can be resumed by calling [`Thread::resume`].
     ///
-    /// [`Thread::resume`]: struct.Thread.html#method.resume
+    /// [`Thread::resume`]: crate::Thread::resume
     Resumable,
     /// Either the thread has finished executing, or the thread is currently running.
     Unresumable,
@@ -43,26 +41,61 @@ pub enum ThreadStatus {
     Error,
 }
 
-/// Handle to an internal Lua thread (or coroutine).
+/// Handle to an internal Lua thread (coroutine).
 #[derive(Clone, Debug)]
-pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
+pub struct Thread<'lua>(pub(crate) LuaRef<'lua>, pub(crate) *mut ffi::lua_State);
+
+/// Owned handle to an internal Lua thread (coroutine).
+///
+/// The owned handle holds a *strong* reference to the current Lua instance.
+/// Be warned, if you place it into a Lua type (eg. [`UserData`] or a Rust callback), it is *very easy*
+/// to accidentally cause reference cycles that would prevent destroying Lua instance.
+///
+/// [`UserData`]: crate::UserData
+#[cfg(feature = "unstable")]
+#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
+#[derive(Clone, Debug)]
+pub struct OwnedThread(
+    pub(crate) crate::types::LuaOwnedRef,
+    pub(crate) *mut ffi::lua_State,
+);
+
+#[cfg(feature = "unstable")]
+impl OwnedThread {
+    /// Get borrowed handle to the underlying Lua table.
+    #[cfg_attr(feature = "send", allow(unused))]
+    pub const fn to_ref(&self) -> Thread {
+        Thread(self.0.to_ref(), self.1)
+    }
+}
 
 /// Thread (coroutine) representation as an async [`Future`] or [`Stream`].
 ///
 /// Requires `feature = "async"`
 ///
-/// [`Future`]: ../futures_core/future/trait.Future.html
-/// [`Stream`]: ../futures_core/stream/trait.Stream.html
+/// [`Future`]: std::future::Future
+/// [`Stream`]: futures_util::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-#[derive(Debug)]
+#[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AsyncThread<'lua, R> {
     thread: Thread<'lua>,
-    args0: RefCell<Option<Result<MultiValue<'lua>>>>,
+    init_args: Option<Result<MultiValue<'lua>>>,
     ret: PhantomData<R>,
+    recycle: bool,
 }
 
 impl<'lua> Thread<'lua> {
+    #[inline(always)]
+    pub(crate) fn new(r#ref: LuaRef<'lua>) -> Self {
+        let state = unsafe { ffi::lua_tothread(r#ref.lua.ref_thread(), r#ref.index) };
+        Thread(r#ref, state)
+    }
+
+    const fn state(&self) -> *mut ffi::lua_State {
+        self.1
+    }
+
     /// Resumes execution of this thread.
     ///
     /// Equivalent to `coroutine.resume`.
@@ -106,62 +139,64 @@ impl<'lua> Thread<'lua> {
     /// ```
     pub fn resume<A, R>(&self, args: A) -> Result<R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
         let lua = self.0.lua;
-        let 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::min(nargs + 1, 3))?;
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
 
-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-            ffi::lua_pop(lua.state, 1);
+            let nresults = self.resume_inner(args)?;
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
 
-            let status = ffi::lua_status(thread_state);
-            if status != ffi::LUA_YIELD && ffi::lua_gettop(thread_state) == 0 {
-                return Err(Error::CoroutineInactive);
-            }
+            R::from_stack_multi(nresults, lua)
+        }
+    }
 
+    /// Resumes execution of this thread.
+    ///
+    /// It's similar to `resume()` but leaves `nresults` values on the thread stack.
+    unsafe fn resume_inner<A: IntoLuaMulti<'lua>>(&self, args: A) -> Result<c_int> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        let thread_state = self.state();
+
+        if self.status() != ThreadStatus::Resumable {
+            return Err(Error::CoroutineInactive);
+        }
+
+        let nargs = args.push_into_stack_multi(lua)?;
+        if nargs > 0 {
             check_stack(thread_state, nargs)?;
-            for arg in args {
-                lua.push_value(arg)?;
-            }
-            ffi::lua_xmove(lua.state, thread_state, nargs);
+            ffi::lua_xmove(state, thread_state, nargs);
+        }
 
-            let mut nresults = 0;
-
-            let ret = ffi::lua_resume(thread_state, lua.state, nargs, &mut nresults as *mut c_int);
-            if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
-                ffi::safe::error_traceback2(lua.state, thread_state)?;
+        let mut nresults = 0;
+        let ret = ffi::lua_resume(thread_state, state, nargs, &mut nresults as *mut c_int);
+        if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
+            if ret == ffi::LUA_ERRMEM {
+                // Don't call error handler for memory errors
                 return Err(pop_error(thread_state, ret));
             }
+            check_stack(state, 3)?;
+            protect_lua!(state, 0, 1, |state| error_traceback_thread(
+                state,
+                thread_state
+            ))?;
+            return Err(pop_error(state, ret));
+        }
 
-            let mut results = MultiValue::new();
-            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
-        };
-        R::from_lua_multi(results, lua)
+        Ok(nresults)
     }
 
     /// Gets the status of the thread.
     pub fn status(&self) -> ThreadStatus {
-        let lua = self.0.lua;
+        let thread_state = self.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
-
-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-            ffi::lua_pop(lua.state, 1);
-
             let status = ffi::lua_status(thread_state);
             if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
                 ThreadStatus::Error
@@ -173,47 +208,71 @@ impl<'lua> Thread<'lua> {
         }
     }
 
+    /// Sets a 'hook' function that will periodically be called as Lua code executes.
+    ///
+    /// This function is similar or [`Lua::set_hook()`] except that it sets for the thread.
+    /// To remove a hook call [`Lua::remove_hook()`].
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F)
+    where
+        F: Fn(&Lua, Debug) -> Result<()> + MaybeSend + 'static,
+    {
+        let lua = self.0.lua;
+        unsafe {
+            lua.set_thread_hook(self.state(), triggers, callback);
+        }
+    }
+
     /// Resets a thread
     ///
     /// In [Lua 5.4]: cleans its call stack and closes all pending to-be-closed variables.
     /// Returns a error in case of either the original error that stopped the thread or errors
     /// in closing methods.
     ///
-    /// In [LuaJIT]: resets to the initial state of a newly created Lua thread.
+    /// In Luau: resets to the initial state of a newly created Lua thread.
     /// Lua threads in arbitrary states (like yielded or errored) can be reset properly.
     ///
     /// Sets a Lua function for the thread afterwards.
     ///
-    /// Requires `feature = "lua54"` OR `feature = "luajit,vendored"`
+    /// Requires `feature = "lua54"` OR `feature = "luau"`.
     ///
-    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_resetthread
-    /// [LuaJIT]: https://github.com/openresty/luajit2#lua_resetthread
-    #[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored"), doc))]
-    pub fn reset(&self, func: Function<'lua>) -> Result<()> {
+    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_closethread
+    #[cfg(any(feature = "lua54", feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua54", feature = "luau"))))]
+    pub fn reset(&self, func: crate::function::Function<'lua>) -> Result<()> {
         let lua = self.0.lua;
+        let thread_state = self.state();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 2)?;
-
-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-
-            let ret = ffi::lua_resetthread(lua.state, thread_state);
-            if ret != ffi::LUA_OK {
-                return Err(pop_error(thread_state, ret));
+            #[cfg(all(feature = "lua54", not(feature = "vendored")))]
+            let status = ffi::lua_resetthread(thread_state);
+            #[cfg(all(feature = "lua54", feature = "vendored"))]
+            let status = ffi::lua_closethread(thread_state, lua.state());
+            #[cfg(feature = "lua54")]
+            if status != ffi::LUA_OK {
+                return Err(pop_error(thread_state, status));
             }
+            #[cfg(feature = "luau")]
+            ffi::lua_resetthread(thread_state);
 
-            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 main thread
+                ffi::lua_xpush(lua.main_state(), thread_state, ffi::LUA_GLOBALSINDEX);
+                ffi::lua_replace(thread_state, ffi::LUA_GLOBALSINDEX);
+            }
 
             Ok(())
         }
     }
 
-    /// Converts Thread to an AsyncThread which implements Future and Stream traits.
+    /// Converts Thread to an AsyncThread which implements [`Future`] and [`Stream`] traits.
     ///
     /// `args` are passed as arguments to the thread function for first call.
-    /// The object call `resume()` while polling and also allows to run rust futures
+    /// The object calls [`resume()`] while polling and also allows to run rust futures
     /// to completion using an executor.
     ///
     /// Using AsyncThread as a Stream allows to iterate through `coroutine.yield()`
@@ -222,6 +281,10 @@ impl<'lua> Thread<'lua> {
     ///
     /// Requires `feature = "async"`
     ///
+    /// [`Future`]: std::future::Future
+    /// [`Stream`]: futures_util::stream::Stream
+    /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    ///
     /// # Examples
     ///
     /// ```
@@ -255,16 +318,70 @@ impl<'lua> Thread<'lua> {
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R>
     where
-        A: ToLuaMulti<'lua>,
+        A: IntoLuaMulti<'lua>,
         R: FromLuaMulti<'lua>,
     {
-        let args = args.to_lua_multi(&self.0.lua);
+        let args = args.into_lua_multi(self.0.lua);
         AsyncThread {
             thread: self,
-            args0: RefCell::new(Some(args)),
+            init_args: Some(args),
             ret: PhantomData,
+            recycle: false,
         }
     }
+
+    /// Enables sandbox mode on this thread.
+    ///
+    /// Under the hood replaces the global environment table with a new table,
+    /// that performs writes locally and proxies reads to caller's global environment.
+    ///
+    /// This mode ideally should be used together with the global sandbox mode [`Lua::sandbox()`].
+    ///
+    /// Please note that Luau links environment table with chunk when loading it into Lua state.
+    /// Therefore you need to load chunks into a thread to link with the thread environment.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result};
+    /// # fn main() -> Result<()> {
+    /// let lua = Lua::new();
+    /// let thread = lua.create_thread(lua.create_function(|lua2, ()| {
+    ///     lua2.load("var = 123").exec()?;
+    ///     assert_eq!(lua2.globals().get::<_, u32>("var")?, 123);
+    ///     Ok(())
+    /// })?)?;
+    /// thread.sandbox()?;
+    /// thread.resume(())?;
+    ///
+    /// // The global environment should be unchanged
+    /// assert_eq!(lua.globals().get::<_, Option<u32>>("var")?, None);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(any(feature = "luau", docsrs))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    #[doc(hidden)]
+    pub fn sandbox(&self) -> Result<()> {
+        let lua = self.0.lua;
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            check_stack(thread_state, 3)?;
+            check_stack(state, 3)?;
+            protect_lua!(state, 0, 0, |_| ffi::luaL_sandboxthread(thread_state))
+        }
+    }
+
+    /// Convert this handle to owned version.
+    #[cfg(all(feature = "unstable", any(not(feature = "send"), doc)))]
+    #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", not(feature = "send")))))]
+    #[inline]
+    pub fn into_owned(self) -> OwnedThread {
+        OwnedThread(self.0.into_owned(), self.1)
+    }
 }
 
 impl<'lua> PartialEq for Thread<'lua> {
@@ -273,6 +390,56 @@ impl<'lua> PartialEq for Thread<'lua> {
     }
 }
 
+// Additional shortcuts
+#[cfg(feature = "unstable")]
+impl OwnedThread {
+    /// Resumes execution of this thread.
+    ///
+    /// See [`Thread::resume()`] for more details.
+    pub fn resume<'lua, A, R>(&'lua self, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti<'lua>,
+        R: FromLuaMulti<'lua>,
+    {
+        self.to_ref().resume(args)
+    }
+
+    /// Gets the status of the thread.
+    pub fn status(&self) -> ThreadStatus {
+        self.to_ref().status()
+    }
+}
+
+#[cfg(feature = "async")]
+impl<'lua, R> AsyncThread<'lua, R> {
+    #[inline]
+    pub(crate) fn set_recyclable(&mut self, recyclable: bool) {
+        self.recycle = recyclable;
+    }
+}
+
+#[cfg(feature = "async")]
+#[cfg(any(feature = "lua54", feature = "luau"))]
+impl<'lua, R> Drop for AsyncThread<'lua, R> {
+    fn drop(&mut self) {
+        if self.recycle {
+            unsafe {
+                let lua = self.thread.0.lua;
+                // For Lua 5.4 this also closes all pending to-be-closed variables
+                if !lua.recycle_thread(&mut self.thread) {
+                    #[cfg(feature = "lua54")]
+                    if self.thread.status() == ThreadStatus::Error {
+                        #[cfg(not(feature = "vendored"))]
+                        ffi::lua_resetthread(self.thread.state());
+                        #[cfg(feature = "vendored")]
+                        ffi::lua_closethread(self.thread.state(), lua.state());
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[cfg(feature = "async")]
 impl<'lua, R> Stream for AsyncThread<'lua, R>
 where
@@ -281,26 +448,36 @@ where
     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 => {}
-            _ => return Poll::Ready(None),
-        };
-
-        let _wg = WakerGuard::new(lua.state, cx.waker().clone());
-        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
-            self.thread.resume(args?)?
-        } else {
-            self.thread.resume(())?
-        };
-
-        if is_poll_pending(&ret) {
-            return Poll::Pending;
+        if self.thread.status() != ThreadStatus::Resumable {
+            return Poll::Ready(None);
         }
 
-        cx.waker().wake_by_ref();
-        Poll::Ready(Some(R::from_lua_multi(ret, lua)))
+        let lua = self.thread.0.lua;
+        let state = lua.state();
+        let thread_state = self.thread.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let _wg = WakerGuard::new(lua, cx.waker());
+
+            // This is safe as we are not moving the whole struct
+            let this = self.get_unchecked_mut();
+            let nresults = if let Some(args) = this.init_args.take() {
+                this.thread.resume_inner(args?)?
+            } else {
+                this.thread.resume_inner(())?
+            };
+
+            if nresults == 1 && is_poll_pending(thread_state) {
+                return Poll::Pending;
+            }
+
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            cx.waker().wake_by_ref();
+            Poll::Ready(Some(R::from_stack_multi(nresults, lua)))
+        }
     }
 }
 
@@ -312,76 +489,80 @@ where
     type Output = Result<R>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if self.thread.status() != ThreadStatus::Resumable {
+            return Poll::Ready(Err(Error::CoroutineInactive));
+        }
+
         let lua = self.thread.0.lua;
-
-        match self.thread.status() {
-            ThreadStatus::Resumable => {}
-            _ => return Poll::Ready(Err(Error::CoroutineInactive)),
-        };
-
-        let _wg = WakerGuard::new(lua.state, cx.waker().clone());
-        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
-            self.thread.resume(args?)?
-        } else {
-            self.thread.resume(())?
-        };
-
-        if is_poll_pending(&ret) {
-            return Poll::Pending;
-        }
-
-        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")]
-fn is_poll_pending(val: &MultiValue) -> bool {
-    match val.iter().enumerate().last() {
-        Some((1, Value::LightUserData(ud))) => {
-            ud.0 == &ASYNC_POLL_PENDING as *const u8 as *mut c_void
-        }
-        _ => false,
-    }
-}
-
-#[cfg(feature = "async")]
-struct WakerGuard(*mut ffi::lua_State, Option<Waker>);
-
-#[cfg(feature = "async")]
-impl WakerGuard {
-    pub fn new(state: *mut ffi::lua_State, waker: Waker) -> Result<WakerGuard> {
+        let state = lua.state();
+        let thread_state = self.thread.state();
         unsafe {
             let _sg = StackGuard::new(state);
-            check_stack(state, 3)?;
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let _wg = WakerGuard::new(lua, cx.waker());
 
-            let waker_key = &WAKER_REGISTRY_KEY as *const u8 as *const c_void;
-            ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, waker_key);
-            let waker_slot = get_gc_userdata::<Option<Waker>>(state, -1).as_mut();
-            let old = mlua_expect!(waker_slot, "Waker is destroyed").replace(waker);
+            // This is safe as we are not moving the whole struct
+            let this = self.get_unchecked_mut();
+            let nresults = if let Some(args) = this.init_args.take() {
+                this.thread.resume_inner(args?)?
+            } else {
+                this.thread.resume_inner(())?
+            };
 
-            Ok(WakerGuard(state, old))
+            if nresults == 1 && is_poll_pending(thread_state) {
+                return Poll::Pending;
+            }
+
+            if ffi::lua_status(thread_state) == ffi::LUA_YIELD {
+                // Ignore value 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))
         }
     }
 }
 
 #[cfg(feature = "async")]
-impl Drop for WakerGuard {
+#[inline(always)]
+unsafe fn is_poll_pending(state: *mut ffi::lua_State) -> bool {
+    ffi::lua_tolightuserdata(state, -1) == Lua::poll_pending().0
+}
+
+#[cfg(feature = "async")]
+struct WakerGuard<'lua, 'a> {
+    lua: &'lua Lua,
+    prev: NonNull<Waker>,
+    _phantom: PhantomData<&'a ()>,
+}
+
+#[cfg(feature = "async")]
+impl<'lua, 'a> WakerGuard<'lua, 'a> {
+    #[inline]
+    pub fn new(lua: &'lua Lua, waker: &'a Waker) -> Result<WakerGuard<'lua, 'a>> {
+        let prev = unsafe { lua.set_waker(NonNull::from(waker)) };
+        Ok(WakerGuard {
+            lua,
+            prev,
+            _phantom: PhantomData,
+        })
+    }
+}
+
+#[cfg(feature = "async")]
+impl<'lua, 'a> Drop for WakerGuard<'lua, 'a> {
     fn drop(&mut self) {
-        let state = self.0;
-        unsafe {
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 3);
-
-            let waker_key = &WAKER_REGISTRY_KEY as *const u8 as *const c_void;
-            ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, waker_key);
-            let waker_slot = get_gc_userdata::<Option<Waker>>(state, -1).as_mut();
-            mem::swap(mlua_expect!(waker_slot, "Waker is destroyed"), &mut self.1);
-        }
+        unsafe { self.lua.set_waker(self.prev) };
     }
 }
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_any!(Thread: Send);
+}

src/types.rs

@@ -1,35 +1,92 @@
-use std::cell::RefCell;
+use std::any::{Any, TypeId};
+use std::cell::{Cell, Ref, RefCell, RefMut, UnsafeCell};
+use std::hash::{Hash, Hasher};
+use std::ops::{Deref, DerefMut};
 use std::os::raw::{c_int, c_void};
+use std::result::Result as StdResult;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::{fmt, mem, ptr};
 
-#[cfg(feature = "async")]
-use futures_core::future::LocalBoxFuture;
+use rustc_hash::FxHashMap;
 
 use crate::error::Result;
-use crate::ffi;
+#[cfg(not(feature = "luau"))]
 use crate::hook::Debug;
-use crate::lua::Lua;
-use crate::util::{assert_stack, StackGuard};
-use crate::value::MultiValue;
+use crate::lua::{ExtraData, Lua};
+
+#[cfg(feature = "async")]
+use {crate::value::MultiValue, futures_util::future::LocalBoxFuture};
+
+#[cfg(feature = "unstable")]
+use {crate::lua::LuaInner, std::marker::PhantomData};
+
+#[cfg(all(feature = "luau", feature = "serialize"))]
+use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
 
 /// Type of Lua integer numbers.
 pub type Integer = ffi::lua_Integer;
 /// Type of Lua floating point numbers.
 pub type Number = ffi::lua_Number;
 
+// Represents different subtypes wrapped to AnyUserData
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub(crate) enum SubtypeId {
+    None,
+    #[cfg(feature = "luau")]
+    Buffer,
+    #[cfg(feature = "luajit")]
+    CData,
+}
+
 /// A "light" userdata value. Equivalent to an unmanaged raw pointer.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub struct LightUserData(pub *mut c_void);
 
-pub(crate) type Callback<'lua, 'a> =
-    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> Result<MultiValue<'lua>> + 'a>;
+pub(crate) type Callback<'lua, 'a> = Box<dyn Fn(&'lua Lua, c_int) -> Result<c_int> + 'a>;
+
+pub(crate) struct Upvalue<T> {
+    pub(crate) data: T,
+    pub(crate) extra: Arc<UnsafeCell<ExtraData>>,
+}
+
+pub(crate) type CallbackUpvalue = Upvalue<Callback<'static, 'static>>;
 
 #[cfg(feature = "async")]
 pub(crate) type AsyncCallback<'lua, 'a> =
-    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> LocalBoxFuture<'lua, Result<MultiValue<'lua>>> + 'a>;
+    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> LocalBoxFuture<'lua, Result<c_int>> + 'a>;
 
-pub(crate) type HookCallback = Arc<RefCell<dyn FnMut(&Lua, Debug) -> Result<()>>>;
+#[cfg(feature = "async")]
+pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback<'static, 'static>>;
+
+#[cfg(feature = "async")]
+pub(crate) type AsyncPollUpvalue = Upvalue<LocalBoxFuture<'static, Result<c_int>>>;
+
+/// Type to set next Luau VM action after executing interrupt function.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub enum VmState {
+    Continue,
+    Yield,
+}
+
+#[cfg(all(feature = "send", not(feature = "luau")))]
+pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()> + Send>;
+
+#[cfg(all(not(feature = "send"), not(feature = "luau")))]
+pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()>>;
+
+#[cfg(all(feature = "luau", feature = "send"))]
+pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState> + Send>;
+
+#[cfg(all(feature = "luau", not(feature = "send")))]
+pub(crate) type InterruptCallback = Arc<dyn Fn(&Lua) -> Result<VmState>>;
+
+#[cfg(all(feature = "send", feature = "lua54"))]
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;
+
+#[cfg(all(not(feature = "send"), feature = "lua54"))]
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()>>;
 
 #[cfg(feature = "send")]
 pub trait MaybeSend: Send {}
@@ -41,23 +98,114 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}
 
+/// A Luau vector type.
+///
+/// By default vectors are 3-dimensional, but can be 4-dimensional
+/// if the `luau-vector4` feature is enabled.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
+pub struct Vector(pub(crate) [f32; Self::SIZE]);
+
+#[cfg(any(feature = "luau", doc))]
+impl fmt::Display for Vector {
+    #[rustfmt::skip]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[cfg(not(feature = "luau-vector4"))]
+        return write!(f, "vector({}, {}, {})", self.x(), self.y(), self.z());
+        #[cfg(feature = "luau-vector4")]
+        return write!(f, "vector({}, {}, {}, {})", self.x(), self.y(), self.z(), self.w());
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Vector {
+    pub(crate) const SIZE: usize = if cfg!(feature = "luau-vector4") { 4 } else { 3 };
+
+    /// Creates a new vector.
+    #[cfg(not(feature = "luau-vector4"))]
+    pub const fn new(x: f32, y: f32, z: f32) -> Self {
+        Self([x, y, z])
+    }
+
+    /// Creates a new vector.
+    #[cfg(feature = "luau-vector4")]
+    pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
+        Self([x, y, z, w])
+    }
+
+    /// Creates a new vector with all components set to `0.0`.
+    #[doc(hidden)]
+    pub const fn zero() -> Self {
+        Self([0.0; Self::SIZE])
+    }
+
+    /// Returns 1st component of the vector.
+    pub const fn x(&self) -> f32 {
+        self.0[0]
+    }
+
+    /// Returns 2nd component of the vector.
+    pub const fn y(&self) -> f32 {
+        self.0[1]
+    }
+
+    /// Returns 3rd component of the vector.
+    pub const fn z(&self) -> f32 {
+        self.0[2]
+    }
+
+    /// Returns 4th component of the vector.
+    #[cfg(any(feature = "luau-vector4", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau-vector4")))]
+    pub const fn w(&self) -> f32 {
+        self.0[3]
+    }
+}
+
+#[cfg(all(feature = "luau", feature = "serialize"))]
+impl Serialize for Vector {
+    fn serialize<S: Serializer>(&self, serializer: S) -> StdResult<S::Ok, S::Error> {
+        let mut ts = serializer.serialize_tuple_struct("Vector", Self::SIZE)?;
+        ts.serialize_field(&self.x())?;
+        ts.serialize_field(&self.y())?;
+        ts.serialize_field(&self.z())?;
+        #[cfg(feature = "luau-vector4")]
+        ts.serialize_field(&self.w())?;
+        ts.end()
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl PartialEq<[f32; Self::SIZE]> for Vector {
+    #[inline]
+    fn eq(&self, other: &[f32; Self::SIZE]) -> bool {
+        self.0 == *other
+    }
+}
+
+pub(crate) struct DestructedUserdata;
+
 /// An auto generated key into the Lua registry.
 ///
 /// This is a handle to a value stored inside the Lua registry. It is not automatically
 /// garbage collected on Drop, but it can be removed with [`Lua::remove_registry_value`],
 /// and instances not manually removed can be garbage collected with [`Lua::expire_registry_values`].
 ///
-/// Be warned, If you place this into Lua via a `UserData` type or a rust callback, it is *very
+/// 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
-/// [`UserData::set_user_value`] / [`UserData::get_user_value`].
+/// Instead of placing a [`RegistryKey`] into a [`UserData`] type, prefer instead to use
+/// [`AnyUserData::set_user_value`] / [`AnyUserData::user_value`].
 ///
-/// [`Lua::remove_registry_value`]: struct.Lua.html#method.remove_registry_value
-/// [`Lua::expire_registry_values`]: struct.Lua.html#method.expire_registry_values
-/// [`UserData::set_user_value`]: struct.UserData.html#method.set_user_value
-/// [`UserData::get_user_value`]: struct.UserData.html#method.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::user_value`]: crate::AnyUserData::user_value
 pub struct RegistryKey {
     pub(crate) registry_id: c_int,
+    pub(crate) is_nil: AtomicBool,
     pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
 }
 
@@ -67,17 +215,43 @@ impl fmt::Debug for RegistryKey {
     }
 }
 
+impl Hash for RegistryKey {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.registry_id.hash(state)
+    }
+}
+
+impl PartialEq for RegistryKey {
+    fn eq(&self, other: &RegistryKey) -> bool {
+        self.registry_id == other.registry_id && Arc::ptr_eq(&self.unref_list, &other.unref_list)
+    }
+}
+
+impl Eq for RegistryKey {}
+
 impl Drop for RegistryKey {
     fn drop(&mut self) {
-        let mut unref_list = mlua_expect!(self.unref_list.lock(), "unref list poisoned");
-        if let Some(list) = unref_list.as_mut() {
-            list.push(self.registry_id);
+        // We don't need to collect nil slot
+        if self.registry_id > ffi::LUA_REFNIL {
+            let mut unref_list = mlua_expect!(self.unref_list.lock(), "unref list poisoned");
+            if let Some(list) = unref_list.as_mut() {
+                list.push(self.registry_id);
+            }
         }
     }
 }
 
 impl RegistryKey {
-    // Destroys the RegistryKey without adding to the drop list
+    // Creates a new instance of `RegistryKey`
+    pub(crate) const fn new(id: c_int, unref_list: Arc<Mutex<Option<Vec<c_int>>>>) -> Self {
+        RegistryKey {
+            registry_id: id,
+            is_nil: AtomicBool::new(id == ffi::LUA_REFNIL),
+            unref_list,
+        }
+    }
+
+    // Destroys the `RegistryKey` without adding to the unref list
     pub(crate) fn take(self) -> c_int {
         let registry_id = self.registry_id;
         unsafe {
@@ -86,16 +260,56 @@ impl RegistryKey {
         }
         registry_id
     }
+
+    // Returns true if this `RegistryKey` holds a nil value
+    #[inline(always)]
+    pub(crate) fn is_nil(&self) -> bool {
+        self.is_nil.load(Ordering::Relaxed)
+    }
+
+    // Marks value of this `RegistryKey` as `Nil`
+    #[inline(always)]
+    pub(crate) fn set_nil(&self, enabled: bool) {
+        // We cannot replace previous value with nil in as this will break
+        // Lua mechanism to find free keys.
+        // Instead, we set a special flag to mark value as nil.
+        self.is_nil.store(enabled, Ordering::Relaxed);
+    }
 }
 
 pub(crate) struct LuaRef<'lua> {
     pub(crate) lua: &'lua Lua,
     pub(crate) index: c_int,
+    pub(crate) drop: bool,
+}
+
+impl<'lua> LuaRef<'lua> {
+    pub(crate) const fn new(lua: &'lua Lua, index: c_int) -> Self {
+        LuaRef {
+            lua,
+            index,
+            drop: true,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn to_pointer(&self) -> *const c_void {
+        unsafe { ffi::lua_topointer(self.lua.ref_thread(), self.index) }
+    }
+
+    #[cfg(feature = "unstable")]
+    #[inline]
+    pub(crate) fn into_owned(self) -> LuaOwnedRef {
+        assert!(self.drop, "Cannot turn non-drop reference into owned");
+        let owned_ref = LuaOwnedRef::new(self.lua.clone(), self.index);
+        mem::forget(self);
+        owned_ref
+    }
 }
 
 impl<'lua> fmt::Debug for LuaRef<'lua> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Ref({})", self.index)
+        write!(f, "Ref({:p})", self.to_pointer())
     }
 }
 
@@ -107,19 +321,222 @@ impl<'lua> Clone for LuaRef<'lua> {
 
 impl<'lua> Drop for LuaRef<'lua> {
     fn drop(&mut self) {
-        self.lua.drop_ref(self)
+        if self.drop {
+            self.lua.drop_ref_index(self.index);
+        }
     }
 }
 
 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
+        let ref_thread = self.lua.ref_thread();
+        assert!(
+            ref_thread == other.lua.ref_thread(),
+            "Lua instance passed Value created from a different main Lua state"
+        );
+        unsafe { ffi::lua_rawequal(ref_thread, self.index, other.index) == 1 }
+    }
+}
+
+#[cfg(feature = "unstable")]
+pub(crate) struct LuaOwnedRef {
+    pub(crate) inner: Arc<LuaInner>,
+    pub(crate) index: c_int,
+    _non_send: PhantomData<*const ()>,
+}
+
+#[cfg(feature = "unstable")]
+impl fmt::Debug for LuaOwnedRef {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "OwnedRef({:p})", self.to_ref().to_pointer())
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl Clone for LuaOwnedRef {
+    fn clone(&self) -> Self {
+        self.to_ref().clone().into_owned()
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl Drop for LuaOwnedRef {
+    fn drop(&mut self) {
+        let lua: &Lua = unsafe { mem::transmute(&self.inner) };
+        lua.drop_ref_index(self.index);
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl LuaOwnedRef {
+    pub(crate) const fn new(inner: Arc<LuaInner>, index: c_int) -> Self {
+        LuaOwnedRef {
+            inner,
+            index,
+            _non_send: PhantomData,
+        }
+    }
+
+    pub(crate) const fn to_ref(&self) -> LuaRef {
+        LuaRef {
+            lua: unsafe { mem::transmute(&self.inner) },
+            index: self.index,
+            drop: false,
         }
     }
 }
+
+#[derive(Debug, Default)]
+pub(crate) struct AppData {
+    #[cfg(not(feature = "send"))]
+    container: UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any>>>>,
+    #[cfg(feature = "send")]
+    container: UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any + Send>>>>,
+    borrow: Cell<usize>,
+}
+
+impl AppData {
+    #[track_caller]
+    pub(crate) fn insert<T: MaybeSend + 'static>(&self, data: T) -> Option<T> {
+        match self.try_insert(data) {
+            Ok(data) => data,
+            Err(_) => panic!("cannot mutably borrow app data container"),
+        }
+    }
+
+    pub(crate) fn try_insert<T: MaybeSend + 'static>(&self, data: T) -> StdResult<Option<T>, T> {
+        if self.borrow.get() != 0 {
+            return Err(data);
+        }
+        // SAFETY: we checked that there are no other references to the container
+        Ok(unsafe { &mut *self.container.get() }
+            .insert(TypeId::of::<T>(), RefCell::new(Box::new(data)))
+            .and_then(|data| data.into_inner().downcast::<T>().ok().map(|data| *data)))
+    }
+
+    #[track_caller]
+    pub(crate) fn borrow<T: 'static>(&self) -> Option<AppDataRef<T>> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())?
+            .borrow();
+        self.borrow.set(self.borrow.get() + 1);
+        Some(AppDataRef {
+            data: Ref::filter_map(data, |data| data.downcast_ref()).ok()?,
+            borrow: &self.borrow,
+        })
+    }
+
+    #[track_caller]
+    pub(crate) fn borrow_mut<T: 'static>(&self) -> Option<AppDataRefMut<T>> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())?
+            .borrow_mut();
+        self.borrow.set(self.borrow.get() + 1);
+        Some(AppDataRefMut {
+            data: RefMut::filter_map(data, |data| data.downcast_mut()).ok()?,
+            borrow: &self.borrow,
+        })
+    }
+
+    #[track_caller]
+    pub(crate) fn remove<T: 'static>(&self) -> Option<T> {
+        if self.borrow.get() != 0 {
+            panic!("cannot mutably borrow app data container");
+        }
+        // SAFETY: we checked that there are no other references to the container
+        unsafe { &mut *self.container.get() }
+            .remove(&TypeId::of::<T>())?
+            .into_inner()
+            .downcast::<T>()
+            .ok()
+            .map(|data| *data)
+    }
+}
+
+/// A wrapper type for an immutably borrowed value from an app data container.
+///
+/// This type is similar to [`Ref`].
+pub struct AppDataRef<'a, T: ?Sized + 'a> {
+    data: Ref<'a, T>,
+    borrow: &'a Cell<usize>,
+}
+
+impl<T: ?Sized> Drop for AppDataRef<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRef<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+/// A wrapper type for a mutably borrowed value from an app data container.
+///
+/// This type is similar to [`RefMut`].
+pub struct AppDataRefMut<'a, T: ?Sized + 'a> {
+    data: RefMut<'a, T>,
+    borrow: &'a Cell<usize>,
+}
+
+impl<T: ?Sized> Drop for AppDataRefMut<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRefMut<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized> DerefMut for AppDataRefMut<'_, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_impl_all!(RegistryKey: Send, Sync);
+    static_assertions::assert_not_impl_any!(LuaRef: Send);
+
+    #[cfg(feature = "unstable")]
+    static_assertions::assert_not_impl_any!(LuaOwnedRef: Send);
+}

src/userdata_ext.rs

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

src/userdata_impl.rs

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

src/util.rs

@@ -1,648 +0,0 @@
-use std::any::{Any, TypeId};
-use std::collections::HashMap;
-use std::error::Error as StdError;
-use std::fmt::Write;
-use std::os::raw::{c_int, c_void};
-use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
-use std::sync::{Arc, Mutex};
-use std::{mem, ptr, slice};
-
-use once_cell::sync::Lazy;
-
-use crate::error::{Error, Result};
-use crate::ffi;
-
-static METATABLE_CACHE: Lazy<Mutex<HashMap<TypeId, u8>>> = Lazy::new(|| {
-    // The capacity must(!) be greater than number of stored keys
-    Mutex::new(HashMap::with_capacity(32))
-});
-
-// Checks that Lua has enough free stack space for future stack operations. On failure, this will
-// panic with an internal error message.
-pub unsafe fn assert_stack(state: *mut ffi::lua_State, amount: c_int) {
-    // TODO: This should only be triggered when there is a logic error in `mlua`. In the future,
-    // when there is a way to be confident about stack safety and test it, this could be enabled
-    // only when `cfg!(debug_assertions)` is true.
-    mlua_assert!(
-        ffi::lua_checkstack(state, amount) != 0,
-        "out of stack space"
-    );
-}
-
-// Checks that Lua has enough free stack space and returns `Error::StackError` on failure.
-pub unsafe fn check_stack(state: *mut ffi::lua_State, amount: c_int) -> Result<()> {
-    if ffi::lua_checkstack(state, amount) == 0 {
-        Err(Error::StackError)
-    } else {
-        Ok(())
-    }
-}
-
-pub struct StackGuard {
-    state: *mut ffi::lua_State,
-    top: c_int,
-    extra: c_int,
-}
-
-impl StackGuard {
-    // Creates a StackGuard instance with record of the stack size, and on Drop will check the
-    // stack size and drop any extra elements. If the stack size at the end is *smaller* than at
-    // the beginning, this is considered a fatal logic error and will result in a panic.
-    pub unsafe fn new(state: *mut ffi::lua_State) -> StackGuard {
-        StackGuard {
-            state,
-            top: ffi::lua_gettop(state),
-            extra: 0,
-        }
-    }
-
-    // Similar to `new`, but checks and keeps `extra` elements from top of the stack on Drop.
-    pub unsafe fn new_extra(state: *mut ffi::lua_State, extra: c_int) -> StackGuard {
-        StackGuard {
-            state,
-            top: ffi::lua_gettop(state),
-            extra,
-        }
-    }
-}
-
-impl Drop for StackGuard {
-    fn drop(&mut self) {
-        unsafe {
-            let top = ffi::lua_gettop(self.state);
-            if top < self.top + self.extra {
-                mlua_panic!("{} too many stack values popped", self.top - top)
-            }
-            if top > self.top + self.extra {
-                if self.extra > 0 {
-                    ffi::lua_rotate(self.state, self.top + 1, self.extra);
-                }
-                ffi::lua_settop(self.state, self.top + self.extra);
-            }
-        }
-    }
-}
-
-// Call a function that calls into the Lua API and may trigger a Lua error (longjmp) in a safe way.
-// Wraps the inner function in a call to `lua_pcall`, so the inner function only has access to a
-// limited lua stack. `nargs` is the same as the the parameter to `lua_pcall`, and `nresults` is
-// always LUA_MULTRET. Internally uses 2 extra stack spaces, and does not call checkstack.
-// Provided function must *never* panic.
-pub unsafe fn protect_lua(
-    state: *mut ffi::lua_State,
-    nargs: c_int,
-    f: unsafe extern "C" fn(*mut ffi::lua_State) -> c_int, // Must be "C-unwind" after stabilizing
-) -> Result<()> {
-    let stack_start = ffi::lua_gettop(state) - nargs;
-
-    ffi::lua_pushcfunction(state, ffi::safe::error_traceback);
-    ffi::lua_pushcfunction(state, f);
-    if nargs > 0 {
-        ffi::lua_rotate(state, stack_start + 1, 2);
-    }
-
-    let ret = ffi::lua_pcall(state, nargs, ffi::LUA_MULTRET, stack_start + 1);
-    ffi::lua_remove(state, stack_start + 1);
-
-    if ret == ffi::LUA_OK {
-        Ok(())
-    } else {
-        Err(pop_error(state, ret))
-    }
-}
-
-// Pops an error off of the stack and returns it. The specific behavior depends on the type of the
-// error at the top of the stack:
-//   1) If the error is actually a WrappedPanic, this will continue the panic.
-//   2) If the error on the top of the stack is actually a WrappedError, just returns it.
-//   3) Otherwise, interprets the error as the appropriate lua error.
-// Uses 2 stack spaces, does not call checkstack.
-pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
-    mlua_debug_assert!(
-        err_code != ffi::LUA_OK && err_code != ffi::LUA_YIELD,
-        "pop_error called with non-error return code"
-    );
-
-    if let Some(err) = get_wrapped_error(state, -1).as_ref() {
-        ffi::lua_pop(state, 1);
-        err.clone()
-    } else if let Some(panic) = get_gc_userdata::<WrappedPanic>(state, -1).as_mut() {
-        if let Some(p) = (*panic).0.take() {
-            resume_unwind(p);
-        } else {
-            Error::PreviouslyResumedPanic
-        }
-    } else {
-        let err_string = to_string(state, -1);
-        ffi::lua_pop(state, 1);
-
-        match err_code {
-            ffi::LUA_ERRRUN => Error::RuntimeError(err_string),
-            ffi::LUA_ERRSYNTAX => {
-                Error::SyntaxError {
-                    // This seems terrible, but as far as I can tell, this is exactly what the
-                    // stock Lua REPL does.
-                    incomplete_input: err_string.ends_with("<eof>")
-                        || err_string.ends_with("'<eof>'"),
-                    message: err_string,
-                }
-            }
-            ffi::LUA_ERRERR => {
-                // This error is raised when the error handler raises an error too many times
-                // recursively, and continuing to trigger the error handler would cause a stack
-                // overflow. It is not very useful to differentiate between this and "ordinary"
-                // runtime errors, so we handle them the same way.
-                Error::RuntimeError(err_string)
-            }
-            ffi::LUA_ERRMEM => Error::MemoryError(err_string),
-            #[cfg(any(feature = "lua53", feature = "lua52"))]
-            ffi::LUA_ERRGCMM => Error::GarbageCollectorError(err_string),
-            _ => mlua_panic!("unrecognized lua error code"),
-        }
-    }
-}
-
-// Internally uses 3 stack spaces, does not call checkstack.
-pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
-    let ud = ffi::safe::lua_newuserdata(state, mem::size_of::<T>())? as *mut T;
-    ptr::write(ud, t);
-    Ok(())
-}
-
-pub unsafe fn get_userdata<T>(state: *mut ffi::lua_State, index: c_int) -> *mut T {
-    let ud = ffi::lua_touserdata(state, index) as *mut T;
-    mlua_debug_assert!(!ud.is_null(), "userdata pointer is null");
-    ud
-}
-
-// Pops the userdata off of the top of the stack and returns it to rust, invalidating the lua
-// userdata and gives it the special "destructed" userdata metatable. Userdata must not have been
-// previously invalidated, and this method does not check for this.
-// Uses 1 extra stack space and does not call checkstack.
-pub unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
-    // We set the metatable of userdata on __gc to a special table with no __gc method and with
-    // metamethods that trigger an error on access. We do this so that it will not be double
-    // dropped, and also so that it cannot be used or identified as any particular userdata type
-    // after the first call to __gc.
-    get_destructed_userdata_metatable(state);
-    ffi::lua_setmetatable(state, -2);
-    let ud = get_userdata(state, -1);
-    ffi::lua_pop(state, 1);
-    ptr::read(ud)
-}
-
-// Pushes the userdata and attaches a metatable with __gc method.
-// Internally uses 3 stack spaces, does not call checkstack.
-pub unsafe fn push_gc_userdata<T: Any>(state: *mut ffi::lua_State, t: T) -> Result<()> {
-    push_userdata(state, t)?;
-    get_gc_metatable_for::<T>(state);
-    ffi::lua_setmetatable(state, -2);
-    Ok(())
-}
-
-// Uses 2 stack spaces, does not call checkstack
-pub unsafe fn get_gc_userdata<T: Any>(state: *mut ffi::lua_State, index: c_int) -> *mut T {
-    let ud = ffi::lua_touserdata(state, index) as *mut T;
-    if ud.is_null() || ffi::lua_getmetatable(state, index) == 0 {
-        return ptr::null_mut();
-    }
-    get_gc_metatable_for::<T>(state);
-    let res = ffi::lua_rawequal(state, -1, -2);
-    ffi::lua_pop(state, 2);
-    if res == 0 {
-        return ptr::null_mut();
-    }
-    ud
-}
-
-// Populates the given table with the appropriate members to be a userdata metatable for the given type.
-// This function takes the given table at the `metatable` index, and adds an appropriate `__gc` member
-// to it for the given type and a `__metatable` entry to protect the table from script access.
-// The function also, if given a `field_getters` or `methods` tables, will create an `__index` metamethod
-// (capturing previous one) to lookup in `field_getters` first, then `methods` and falling back to the
-// captured `__index` if no matches found.
-// The same is also applicable for `__newindex` metamethod and `field_setters` table.
-// Internally uses 9 stack spaces and does not call checkstack.
-pub unsafe fn init_userdata_metatable<T>(
-    state: *mut ffi::lua_State,
-    metatable: c_int,
-    field_getters: Option<c_int>,
-    field_setters: Option<c_int>,
-    methods: Option<c_int>,
-) -> Result<()> {
-    ffi::lua_pushvalue(state, metatable);
-
-    if field_getters.is_some() || methods.is_some() {
-        ffi::safe::lua_pushstring(state, "__index")?;
-
-        ffi::lua_pushvalue(state, -1);
-        let index_type = ffi::lua_rawget(state, -3);
-        match index_type {
-            ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
-                for &idx in &[field_getters, methods] {
-                    if let Some(idx) = idx {
-                        ffi::lua_pushvalue(state, idx);
-                    } else {
-                        ffi::lua_pushnil(state);
-                    }
-                }
-                ffi::safe::lua_pushcclosure(state, ffi::safe::meta_index_impl, 3)?;
-            }
-            _ => mlua_panic!("improper __index type {}", index_type),
-        }
-
-        ffi::safe::lua_rawset(state, -3)?;
-    }
-
-    if let Some(field_setters) = field_setters {
-        ffi::safe::lua_pushstring(state, "__newindex")?;
-
-        ffi::lua_pushvalue(state, -1);
-        let newindex_type = ffi::lua_rawget(state, -3);
-        match newindex_type {
-            ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
-                ffi::lua_pushvalue(state, field_setters);
-                ffi::safe::lua_pushcclosure(state, ffi::safe::meta_newindex_impl, 2)?;
-            }
-            _ => mlua_panic!("improper __newindex type {}", newindex_type),
-        }
-
-        ffi::safe::lua_rawset(state, -3)?;
-    }
-
-    ffi::safe::lua_pushrclosure(state, userdata_destructor::<T>, 0)?;
-    ffi::safe::lua_rawsetfield(state, -2, "__gc")?;
-
-    ffi::lua_pushboolean(state, 0);
-    ffi::safe::lua_rawsetfield(state, -2, "__metatable")?;
-
-    ffi::lua_pop(state, 1);
-
-    Ok(())
-}
-
-pub unsafe extern "C" fn userdata_destructor<T>(state: *mut ffi::lua_State) -> c_int {
-    callback_error(state, |_| {
-        check_stack(state, 1)?;
-        take_userdata::<T>(state);
-        Ok(0)
-    })
-}
-
-// In the context of a lua callback, this will call the given function and if the given function
-// returns an error, *or if the given function panics*, this will result in a call to lua_error (a
-// longjmp) by a C shim. The error or panic is wrapped in such a way that when calling pop_error back
-// on the rust side, it will resume the panic (or when popping a panic value from the stack).
-//
-// This function assumes the structure of the stack at the beginning of a callback, that the only
-// elements on the stack are the arguments to the callback.
-//
-// This function uses some of the bottom of the stack for error handling, the given callback will be
-// given the number of arguments available as an argument, and should return the number of returns
-// as normal, but cannot assume that the arguments available start at 1.
-pub unsafe fn callback_error<F>(state: *mut ffi::lua_State, f: F) -> c_int
-where
-    F: FnOnce(c_int) -> Result<c_int>,
-{
-    let nargs = ffi::lua_gettop(state) - 1;
-    match catch_unwind(AssertUnwindSafe(|| f(nargs))) {
-        Ok(Ok(r)) => {
-            ffi::lua_remove(state, 1);
-            r
-        }
-        Ok(Err(err)) => {
-            ffi::lua_settop(state, 1);
-            let error_ud = ffi::lua_touserdata(state, 1);
-            ptr::write(error_ud as *mut WrappedError, WrappedError(err));
-            get_gc_metatable_for::<WrappedError>(state);
-            ffi::lua_setmetatable(state, -2);
-            -1
-        }
-        Err(p) => {
-            ffi::lua_settop(state, 1);
-            let error_ud = ffi::lua_touserdata(state, 1);
-            ptr::write(error_ud as *mut WrappedPanic, WrappedPanic(Some(p)));
-            get_gc_metatable_for::<WrappedPanic>(state);
-            ffi::lua_setmetatable(state, -2);
-            -2
-        }
-    }
-}
-
-// A part of the C shim for errors handling.
-// Receives indexes of error and traceback (optional) in the stack.
-// Converts error into a `CallbackError` and attaches the traceback provided.
-#[no_mangle]
-pub unsafe extern "C" fn wrapped_error_traceback(
-    state: *mut ffi::lua_State,
-    error_idx: c_int,
-    traceback_idx: c_int,
-) {
-    let wrapped_error = mlua_expect!(
-        get_gc_userdata::<WrappedError>(state, error_idx).as_mut(),
-        "cannot get <WrappedError>"
-    );
-    let traceback = match traceback_idx {
-        0 => "<not enough stack space for traceback>".to_string(),
-        _ => to_string(state, traceback_idx),
-    };
-    let cause = Arc::new(wrapped_error.0.clone());
-    wrapped_error.0 = Error::CallbackError { traceback, cause };
-}
-
-// Returns Lua main thread for Lua >= 5.2 or checks that the passed thread is main for Lua 5.1.
-// Does not call lua_checkstack, uses 1 stack space.
-pub unsafe fn get_main_state(state: *mut ffi::lua_State) -> Option<*mut ffi::lua_State> {
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    {
-        ffi::lua_rawgeti(state, ffi::LUA_REGISTRYINDEX, ffi::LUA_RIDX_MAINTHREAD);
-        let main_state = ffi::lua_tothread(state, -1);
-        ffi::lua_pop(state, 1);
-        Some(main_state)
-    }
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    {
-        // Check the current state first
-        let is_main_state = ffi::lua_pushthread(state) == 1;
-        ffi::lua_pop(state, 1);
-        if is_main_state {
-            Some(state)
-        } else {
-            None
-        }
-    }
-}
-
-// Pushes a WrappedError to the top of the stack.
-// Uses 2 stack spaces and does not call checkstack.
-pub unsafe fn push_wrapped_error(state: *mut ffi::lua_State, err: Error) -> Result<()> {
-    let error_ud = ffi::safe::lua_newwrappederror(state)? as *mut WrappedError;
-    ptr::write(error_ud, WrappedError(err));
-    get_gc_metatable_for::<WrappedError>(state);
-    ffi::lua_setmetatable(state, -2);
-    Ok(())
-}
-
-// Checks if the value at the given index is a WrappedError, and if it is returns a pointer to it,
-// otherwise returns null.
-// Uses 2 stack spaces and does not call checkstack.
-pub unsafe fn get_wrapped_error(state: *mut ffi::lua_State, index: c_int) -> *const Error {
-    let ud = get_gc_userdata::<WrappedError>(state, index);
-    if ud.is_null() {
-        return ptr::null();
-    }
-    &(*ud).0
-}
-
-// Initialize the internal (with __gc method) metatable for a type T.
-// Uses 6 stack spaces and calls checkstack.
-pub unsafe fn init_gc_metatable_for<T: Any>(
-    state: *mut ffi::lua_State,
-    customize_fn: Option<fn(*mut ffi::lua_State) -> Result<()>>,
-) -> Result<*const u8> {
-    check_stack(state, 6)?;
-
-    let type_id = TypeId::of::<T>();
-    let ref_addr = {
-        let mut mt_cache = mlua_expect!(METATABLE_CACHE.lock(), "cannot lock metatable cache");
-        mlua_assert!(
-            mt_cache.capacity() - mt_cache.len() > 0,
-            "out of metatable cache capacity"
-        );
-        mt_cache.insert(type_id, 0);
-        &mt_cache[&type_id] as *const u8
-    };
-
-    ffi::safe::lua_createtable(state, 0, 3)?;
-
-    ffi::safe::lua_pushrclosure(state, userdata_destructor::<T>, 0)?;
-    ffi::safe::lua_rawsetfield(state, -2, "__gc")?;
-
-    ffi::lua_pushboolean(state, 0);
-    ffi::safe::lua_rawsetfield(state, -2, "__metatable")?;
-
-    if let Some(f) = customize_fn {
-        f(state)?;
-    }
-
-    ffi::safe::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, ref_addr as *mut c_void)?;
-
-    Ok(ref_addr)
-}
-
-pub unsafe fn get_gc_metatable_for<T: Any>(state: *mut ffi::lua_State) {
-    let type_id = TypeId::of::<T>();
-    let ref_addr = {
-        let mt_cache = mlua_expect!(METATABLE_CACHE.lock(), "cannot lock metatable cache");
-        mlua_expect!(mt_cache.get(&type_id), "gc metatable does not exist") as *const u8
-    };
-    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, ref_addr as *const c_void);
-}
-
-// Initialize the error, panic, and destructed userdata metatables.
-// Returns address of WrappedError and WrappedPanic metatables in Lua registry.
-pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<(*const u8, *const u8)> {
-    check_stack(state, 7)?;
-
-    // Create error and panic metatables
-
-    unsafe extern "C" fn error_tostring(state: *mut ffi::lua_State) -> c_int {
-        callback_error(state, |_| {
-            check_stack(state, 3)?;
-
-            let err_buf = if let Some(error) = get_wrapped_error(state, -1).as_ref() {
-                let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
-                ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
-                let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
-                ffi::lua_pop(state, 2);
-
-                (*err_buf).clear();
-                // Depending on how the API is used and what error types scripts are given, it may
-                // be possible to make this consume arbitrary amounts of memory (for example, some
-                // kind of recursive error structure?)
-                let _ = write!(&mut (*err_buf), "{}", error);
-                // Find first two sources that caused the error
-                let mut source1 = error.source();
-                let mut source0 = source1.and_then(|s| s.source());
-                while let Some(source) = source0.and_then(|s| s.source()) {
-                    source1 = source0;
-                    source0 = Some(source);
-                }
-                match (source1, source0) {
-                    (_, Some(error0)) if error0.to_string().contains("\nstack traceback:\n") => {
-                        let _ = write!(&mut (*err_buf), "\ncaused by: {}", error0);
-                    }
-                    (Some(error1), Some(error0)) => {
-                        let _ = write!(&mut (*err_buf), "\ncaused by: {}", error0);
-                        let s = error1.to_string();
-                        if let Some(traceback) = s.splitn(2, "\nstack traceback:\n").nth(1) {
-                            let _ = write!(&mut (*err_buf), "\nstack traceback:\n{}", traceback);
-                        }
-                    }
-                    (Some(error1), None) => {
-                        let _ = write!(&mut (*err_buf), "\ncaused by: {}", error1);
-                    }
-                    _ => {}
-                }
-                Ok(err_buf)
-            } else if let Some(panic) = get_gc_userdata::<WrappedPanic>(state, -1).as_ref() {
-                if let Some(ref p) = (*panic).0 {
-                    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
-                    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
-                    let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
-                    (*err_buf).clear();
-                    ffi::lua_pop(state, 2);
-
-                    if let Some(msg) = p.downcast_ref::<&str>() {
-                        let _ = write!(&mut (*err_buf), "{}", msg);
-                    } else if let Some(msg) = p.downcast_ref::<String>() {
-                        let _ = write!(&mut (*err_buf), "{}", msg);
-                    } else {
-                        let _ = write!(&mut (*err_buf), "<panic>");
-                    };
-                    Ok(err_buf)
-                } else {
-                    Err(Error::PreviouslyResumedPanic)
-                }
-            } else {
-                // I'm not sure whether this is possible to trigger without bugs in mlua?
-                Err(Error::UserDataTypeMismatch)
-            }?;
-
-            ffi::safe::lua_pushstring(state, &*err_buf)?;
-            (*err_buf).clear();
-
-            Ok(1)
-        })
-    }
-
-    let wrapped_error_key = init_gc_metatable_for::<WrappedError>(
-        state,
-        Some(|state| {
-            ffi::safe::lua_pushrclosure(state, error_tostring, 0)?;
-            ffi::safe::lua_rawsetfield(state, -2, "__tostring")
-        }),
-    )?;
-
-    let wrapped_panic_key = init_gc_metatable_for::<WrappedPanic>(
-        state,
-        Some(|state| {
-            ffi::safe::lua_pushrclosure(state, error_tostring, 0)?;
-            ffi::safe::lua_rawsetfield(state, -2, "__tostring")
-        }),
-    )?;
-
-    // Create destructed userdata metatable
-
-    unsafe extern "C" fn destructed_error(state: *mut ffi::lua_State) -> c_int {
-        callback_error(state, |_| {
-            check_stack(state, 2)?;
-            let error_ud = ffi::safe::lua_newwrappederror(state)? as *mut WrappedError;
-            ptr::write(error_ud, WrappedError(Error::CallbackDestructed));
-            get_gc_metatable_for::<WrappedError>(state);
-            ffi::lua_setmetatable(state, -2);
-            Ok(-1) // to trigger lua_error
-        })
-    }
-
-    ffi::safe::lua_createtable(state, 0, 26)?;
-    ffi::safe::lua_pushrclosure(state, destructed_error, 0)?;
-    for &method in &[
-        "__add",
-        "__sub",
-        "__mul",
-        "__div",
-        "__mod",
-        "__pow",
-        "__unm",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        "__idiv",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        "__band",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        "__bor",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        "__bxor",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        "__bnot",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        "__shl",
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        "__shr",
-        "__concat",
-        "__len",
-        "__eq",
-        "__lt",
-        "__le",
-        "__index",
-        "__newindex",
-        "__call",
-        "__tostring",
-        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-        "__pairs",
-        #[cfg(any(feature = "lua53", feature = "lua52"))]
-        "__ipairs",
-        #[cfg(feature = "lua54")]
-        "__close",
-    ] {
-        ffi::lua_pushvalue(state, -1);
-        ffi::safe::lua_rawsetfield(state, -3, method)?;
-    }
-    ffi::lua_pop(state, 1);
-
-    let destructed_metatable_key = &DESTRUCTED_USERDATA_METATABLE as *const u8 as *const c_void;
-    ffi::safe::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, destructed_metatable_key)?;
-
-    // Create error print buffer
-    init_gc_metatable_for::<String>(state, None)?;
-    push_gc_userdata(state, String::new())?;
-    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
-    ffi::safe::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key)?;
-
-    Ok((wrapped_error_key, wrapped_panic_key))
-}
-
-pub(crate) struct WrappedError(pub Error);
-pub(crate) struct WrappedPanic(pub Option<Box<dyn Any + Send + 'static>>);
-
-// Converts the given lua value to a string in a reasonable format without causing a Lua error or
-// panicking.
-unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> String {
-    match ffi::lua_type(state, index) {
-        ffi::LUA_TNONE => "<none>".to_string(),
-        ffi::LUA_TNIL => "<nil>".to_string(),
-        ffi::LUA_TBOOLEAN => (ffi::lua_toboolean(state, index) != 1).to_string(),
-        ffi::LUA_TLIGHTUSERDATA => {
-            format!("<lightuserdata {:?}>", ffi::lua_topointer(state, index))
-        }
-        ffi::LUA_TNUMBER => {
-            let mut isint = 0;
-            let i = ffi::lua_tointegerx(state, -1, &mut isint);
-            if isint == 0 {
-                ffi::lua_tonumber(state, index).to_string()
-            } else {
-                i.to_string()
-            }
-        }
-        ffi::LUA_TSTRING => {
-            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(state, index, &mut size);
-            String::from_utf8_lossy(slice::from_raw_parts(data as *const u8, size)).into_owned()
-        }
-        ffi::LUA_TTABLE => format!("<table {:?}>", ffi::lua_topointer(state, index)),
-        ffi::LUA_TFUNCTION => format!("<function {:?}>", ffi::lua_topointer(state, index)),
-        ffi::LUA_TUSERDATA => format!("<userdata {:?}>", ffi::lua_topointer(state, index)),
-        ffi::LUA_TTHREAD => format!("<thread {:?}>", ffi::lua_topointer(state, index)),
-        _ => "<unknown>".to_string(),
-    }
-}
-
-pub(crate) unsafe fn get_destructed_userdata_metatable(state: *mut ffi::lua_State) {
-    let key = &DESTRUCTED_USERDATA_METATABLE as *const u8 as *const c_void;
-    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, key);
-}
-
-static DESTRUCTED_USERDATA_METATABLE: u8 = 0;
-static ERROR_PRINT_BUFFER_KEY: u8 = 0;