v0.7.2

Update README
Update CHANGELOG
2026-06-08 16:05:43 +00:00 · 2022-01-17 11:12:46 +00:00 · 2022-01-17 11:11:56 +00:00 · 2022-01-16 23:50:26 +00:00 · 2022-01-16 20:57:43 +00:00 · 2022-01-08 23:06:01 +00:00
71 changed files with 4882 additions and 4004 deletions
@@ -0,0 +1 @@
+github: khvzak
@@ -14,7 +14,7 @@ jobs:

      - name: Generate code coverage
        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 --verbose --features lua54,vendored,async,send,serialize,macros --out xml --exclude-files benches --exclude-files build --exclude-files mlua_derive --exclude-files src/ffi --exclude-files tests

      - name: Upload to codecov.io
        uses: codecov/codecov-action@v1
@@ -7,11 +7,11 @@ jobs:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [ubuntu-20.04, macos-latest, windows-latest]
        rust: [stable]
        lua: [lua54, lua53, lua52, lua51, luajit]
        include:
-        - os: ubuntu-18.04
+        - os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
        - os: macos-latest
          target: x86_64-apple-darwin
@@ -24,17 +24,18 @@ jobs:
        toolchain: ${{ matrix.rust }}
        target: ${{ matrix.target }}
        override: true
+    - uses: Swatinem/rust-cache@v1
    - name: Build ${{ matrix.lua }} vendored
      run: |
-        cargo build --release --features "${{ matrix.lua }},vendored"
-        cargo build --release --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
+        cargo build --features "${{ matrix.lua }},vendored"
+        cargo build --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
      shell: bash
    - name: Build ${{ matrix.lua }} pkg-config
-      if: ${{ matrix.os == 'ubuntu-18.04' && matrix.lua != 'lua54' }}
+      if: ${{ matrix.os == 'ubuntu-20.04' && matrix.lua != 'lua54' }}
      run: |
        sudo apt-get update
        sudo apt-get install -y --no-install-recommends liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
-        cargo build --release --features "${{ matrix.lua }}"
+        cargo build --features "${{ matrix.lua }}"

  build_aarch64_cross_macos:
    name: Cross-compile to aarch64-apple-darwin
@@ -47,7 +48,7 @@ jobs:
    - uses: actions/checkout@v2
    - uses: actions-rs/toolchain@v1
      with:
-        toolchain: nightly
+        toolchain: stable
        target: aarch64-apple-darwin
        override: true
    - name: Cross-compile
@@ -55,7 +56,7 @@ jobs:

  build_aarch64_cross_ubuntu:
    name: Cross-compile to aarch64-unknown-linux-gnu
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    needs: build
    strategy:
      matrix:
@@ -64,7 +65,7 @@ jobs:
    - uses: actions/checkout@v2
    - uses: actions-rs/toolchain@v1
      with:
-        toolchain: nightly
+        toolchain: stable
        target: aarch64-unknown-linux-gnu
        override: true
    - name: Install ARM compiler toolchain
@@ -78,7 +79,7 @@ jobs:

  build_armv7_cross_ubuntu:
    name: Cross-compile to armv7-unknown-linux-gnueabihf
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    needs: build
    strategy:
      matrix:
@@ -87,7 +88,7 @@ jobs:
    - uses: actions/checkout@v2
    - uses: actions-rs/toolchain@v1
      with:
-        toolchain: nightly
+        toolchain: stable
        target: armv7-unknown-linux-gnueabihf
        override: true
    - name: Install ARM compiler toolchain
@@ -105,11 +106,11 @@ jobs:
    needs: build
    strategy:
      matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [ubuntu-20.04, macos-latest, windows-latest]
        rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luajit52]
        include:
-        - os: ubuntu-18.04
+        - os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
        - os: macos-latest
          target: x86_64-apple-darwin
@@ -122,16 +123,43 @@ jobs:
        toolchain: ${{ matrix.rust }}
        target: ${{ matrix.target }}
        override: true
+    - uses: Swatinem/rust-cache@v1
    - name: Run ${{ matrix.lua }} tests
      run: |
-        cargo test --release --features "${{ matrix.lua }},vendored"
-        cargo test --release --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
+        cargo test --features "${{ matrix.lua }},vendored"
+        cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
      shell: bash
-    - name: Run compile tests (macos lua53)
-      if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua53' }}
+    - name: Run compile tests (macos lua54)
+      if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua54' }}
      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
+        TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored" -- --ignored
+        TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros" -- --ignored
+      shell: bash
+
+  test_with_sanitizer:
+    name: Test with address sanitizer
+    runs-on: ${{ matrix.os }}
+    needs: build
+    strategy:
+      matrix:
+        os: [ubuntu-20.04]
+        rust: [nightly]
+        lua: [lua54, lua53, lua52, lua51, luajit]
+        include:
+        - os: ubuntu-20.04
+          target: x86_64-unknown-linux-gnu
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: ${{ matrix.rust }}
+        target: ${{ matrix.target }}
+        override: true
+    - uses: Swatinem/rust-cache@v1
+    - name: Run ${{ matrix.lua }} tests with address sanitizer
+      run: |
+        RUSTFLAGS="-Z sanitizer=address" \
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
      shell: bash

  test_modules:
@@ -140,11 +168,11 @@ jobs:
    needs: build
    strategy:
      matrix:
-        os: [ubuntu-18.04, macos-latest]
-        rust: [stable, nightly]
+        os: [ubuntu-20.04, macos-latest]
+        rust: [stable]
        lua: [lua54, lua53, lua52, lua51, luajit]
        include:
-        - os: ubuntu-18.04
+        - os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
        - os: macos-latest
          target: x86_64-apple-darwin
@@ -155,6 +183,7 @@ jobs:
        toolchain: ${{ matrix.rust }}
        target: ${{ matrix.target }}
        override: true
+    - uses: Swatinem/rust-cache@v1
    - name: Run ${{ matrix.lua }} module tests
      run: |
        (cd examples/module && cargo build --release --features "${{ matrix.lua }},vendored")
@@ -184,7 +213,7 @@ jobs:

  rustfmt:
    name: Rustfmt
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    steps:
    - uses: actions/checkout@v2
    - uses: actions-rs/toolchain@v1
@@ -196,7 +225,7 @@ jobs:

  clippy:
    name: Clippy check
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    strategy:
      matrix:
        lua: [lua54, lua53, lua52, lua51, luajit]
@@ -1,3 +1,96 @@
+## 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
+- Implement `UserData` for `Rc<RefCell>`/`Arc<Mutex>`/`Arc<RwLock>`
+- Added `__ipairs` metamethod for Lua 5.2
+- Added `String::to_string_lossy`
+- Various bugfixes and improvements
+
 ## v0.6.0-beta.2

 - [**Breaking**] Removed `AnyUserData::has_metamethod()`
@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.6.0-beta.2" # remember to update html_root_url and mlua_derive
+version = "0.7.2" # remember to update html_root_url and mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
 edition = "2018"
 repository = "https://github.com/khvzak/mlua"
@@ -13,11 +13,11 @@ 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.
+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"]
 rustdoc-args = ["--cfg", "docsrs"]

 [workspace]
@@ -33,6 +33,7 @@ lua53 = []
 lua52 = []
 lua51 = []
 luajit = []
+luajit52 = ["luajit"]
 vendored = ["lua-src", "luajit-src"]
 module = ["mlua_derive"]
 async = ["futures-core", "futures-task", "futures-util"]
@@ -41,10 +42,11 @@ serialize = ["serde", "erased-serde"]
 macros = ["mlua_derive/macros"]

 [dependencies]
-mlua_derive = { version = "=0.6.0-beta.2", optional = true, path = "mlua_derive" }
+mlua_derive = { version = "=0.6.0", optional = true, path = "mlua_derive" }
 bstr = { version = "0.2", features = ["std"], default_features = false }
-once_cell = { version = "1.7" }
+once_cell = { version = "1.0" }
 num-traits = { version = "0.2.14" }
+rustc-hash = "1.0"
 futures-core = { version = "0.3.5", optional = true }
 futures-task = { version = "0.3.5", optional = true }
 futures-util = { version = "0.3.5", optional = true }
@@ -55,10 +57,10 @@ erased-serde = { version = "0.3", optional = true }
 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 }
+luajit-src = { version = ">= 210.3.1, < 220.0.0", optional = true }

 [dev-dependencies]
-rustyline = "8.0"
+rustyline = "9.0"
 criterion = { version = "0.3.4", features = ["html_reports", "async_tokio"] }
 trybuild = "1.0"
 futures = "0.3.5"
@@ -76,20 +78,28 @@ required-features = ["async"]

 [[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"]
@@ -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
@@ -9,13 +9,14 @@
 [docs.rs]: https://docs.rs/mlua
 [Coverage Status]: https://codecov.io/gh/khvzak/mlua/branch/master/graph/badge.svg?token=99339FS1CG
 [codecov.io]: https://codecov.io/gh/khvzak/mlua
+[MSRV]: https://img.shields.io/badge/rust-1.53+-brightgreen.svg?&logo=rust

 [Guided Tour](examples/guided_tour.rs)

 `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 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.

 `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).

@@ -33,11 +34,13 @@ 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
 * `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!`)

 [5.4]: https://www.lua.org/manual/5.4/manual.html
 [5.3]: https://www.lua.org/manual/5.3/manual.html
@@ -73,7 +76,7 @@ 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` or `luajit(52)`, 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.
@@ -96,7 +99,7 @@ Add to `Cargo.toml` :

 ``` toml
 [dependencies]
-mlua = { version = "0.5", features = ["lua53", "vendored"] }
+mlua = { version = "0.7", features = ["lua54", "vendored"] }
 ```

 `main.rs`
@@ -120,7 +123,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)

@@ -131,7 +134,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]

 [dependencies]
-mlua = { version = "0.5", features = ["lua53", "vendored", "module"] }
+mlua = { version = "0.7", features = ["lua54", "vendored", "module"] }
 ```

 `lib.rs` :
@@ -157,7 +160,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!
 ```

@@ -184,6 +187,15 @@ MSVC with `LUA_INC` / `LUA_LIB` / `LUA_LIB_NAME` environment variables.

 More details about compiling and linking Lua modules can be found on the [Building Modules](http://lua-users.org/wiki/BuildingModules) page.

+### 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

 One of the `mlua` goals is to provide *safe* API between Rust and Lua.
@@ -59,6 +59,22 @@ fn create_string_table(c: &mut Criterion) {
    });
 }

+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 +120,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_cache_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;
@@ -228,7 +245,8 @@ fn call_async_userdata_method(c: &mut Criterion) {
        }
    }

-    let lua = Lua::new();
+    let options = LuaOptions::new().thread_cache_size(1024);
+    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
    lua.globals().set("userdata", UserData(10)).unwrap();

    c.bench_function("call async [userdata method] 10", |b| {
@@ -258,6 +276,7 @@ criterion_group! {
        create_table,
        create_array,
        create_string_table,
+        create_function,
        call_lua_function,
        call_sum_callback,
        call_async_sum_callback,
@@ -10,7 +10,7 @@ fn get_env_var(name: &str) -> String {
    }
 }

-pub fn probe_lua() -> PathBuf {
+pub fn probe_lua() -> Option<PathBuf> {
    let include_dir = get_env_var("LUA_INC");
    let lib_dir = get_env_var("LUA_LIB");
    let lua_lib = get_env_var("LUA_LIB_NAME");
@@ -38,73 +38,42 @@ pub fn probe_lua() -> PathBuf {
            println!("cargo:rustc-link-search=native={}", lib_dir);
            println!("cargo:rustc-link-lib={}{}", link_lib, lua_lib);
        }
-        return PathBuf::from(include_dir);
+        return Some(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()
-    }
-
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", "lua5.4", "5.4");
    #[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()
-    }
-
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", "lua5.3", "5.3");
    #[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()
-    }
-
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", "lua5.2", "5.2");
    #[cfg(feature = "lua51")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", "lua5.1", "5.1");
+
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "lua51"
+    ))]
    {
        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.1"), Bound::Excluded("5.2")))
+            .range_version((Bound::Included(incl_bound), Bound::Excluded(excl_bound)))
            .cargo_metadata(need_lua_lib)
            .probe("lua");

        if lua.is_err() {
            lua = pkg_config::Config::new()
                .cargo_metadata(need_lua_lib)
-                .probe("lua5.1");
+                .probe(alt_probe);
        }

-        lua.unwrap().include_paths[0].clone()
+        lua.expect(&format!("cannot find Lua {} using `pkg-config`", ver))
+            .include_paths
+            .get(0)
+            .cloned()
    }

    #[cfg(feature = "luajit")]
@@ -114,6 +83,9 @@ pub fn probe_lua() -> PathBuf {
            .cargo_metadata(need_lua_lib)
            .probe("luajit");

-        lua.unwrap().include_paths[0].clone()
+        lua.expect("cannot find LuaJIT using `pkg-config`")
+            .include_paths
+            .get(0)
+            .cloned()
    }
 }
@@ -1,6 +1,6 @@
 use std::path::PathBuf;

-pub fn probe_lua() -> PathBuf {
+pub fn probe_lua() -> Option<PathBuf> {
    #[cfg(feature = "lua54")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua54);
    #[cfg(feature = "lua53")]
@@ -10,10 +10,16 @@ pub fn probe_lua() -> PathBuf {
    #[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 = {
+        let mut builder = luajit_src::Build::new();
+        if cfg!(feature = "luajit52") {
+            builder.lua52compat(true);
+        }
+        builder.build()
+    };

    #[cfg(not(feature = "module"))]
    artifacts.print_cargo_metadata();

-    artifacts.include_dir().to_owned()
+    Some(artifacts.include_dir().to_owned())
 }
@@ -68,11 +68,14 @@ impl CommandExt for Command {
    }
 }

-fn build_glue<P: AsRef<Path> + std::fmt::Debug>(include_path: &P) {
+// `include_path` is optional as Lua headers can be also found in compiler standard paths
+fn build_glue(include_path: Option<impl AsRef<Path>>) {
    let build_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());

    let mut config = cc::Build::new();
-    config.include(include_path);
+    if let Some(include_path) = include_path {
+        config.include(include_path.as_ref());
+    }

    // Compile and run glue.c
    let glue = build_dir.join("glue");
@@ -143,16 +146,18 @@ fn generate_glue() -> Result<()> {
        (version.0 * 100) + version.1
    )?;

-    let max_stack = if pointer_bit_width >= 32 {
-        1_000_000
-    } else {
-        15_000
-    };
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
    writeln!(
        glue,
        "pub const LUA_REGISTRYINDEX: c_int = -{} - 1000;",
-        max_stack
+        if pointer_bit_width >= 32 {
+            1_000_000
+        } else {
+            15_000
+        }
    )?;
+    #[cfg(any(feature = "lua51", feature = "luajit"))]
+    writeln!(glue, "pub const LUA_REGISTRYINDEX: c_int = -10000;")?;

    // These two are only defined in lua 5.1
    writeln!(glue, "pub const LUA_ENVIRONINDEX: c_int = -10001;")?;
@@ -199,7 +204,9 @@ fn main() {
        feature = "lua51",
        feature = "luajit"
    )))]
-    compile_error!("You must enable one of the features: lua54, lua53, lua52, lua51, luajit");
+    compile_error!(
+        "You must enable one of the features: lua54, lua53, lua52, lua51, luajit, luajit52"
+    );

    #[cfg(all(
        feature = "lua54",
@@ -210,19 +217,27 @@ fn main() {
            feature = "luajit"
        )
    ))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52"
+    );

    #[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");
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52"
+    );

    #[cfg(all(feature = "lua52", any(feature = "lua51", feature = "luajit")))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52"
+    );

    #[cfg(all(feature = "lua51", feature = "luajit"))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52"
+    );

    // We don't support "vendored module" mode on windows
    #[cfg(all(feature = "vendored", feature = "module", target_os = "windows"))]
@@ -231,22 +246,13 @@ fn main() {
            + "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);
+        let include_dir = find::probe_lua();
+        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");
 }
@@ -0,0 +1,8 @@
+coverage:
+  status:
+    patch:
+      default:
+        only_pulls: true
+    project:
+      default:
+        only_pulls: true
@@ -1,29 +1,19 @@
 use std::collections::HashMap;
-use std::sync::Arc;

-use bstr::BString;
 use hyper::body::{Body as HyperBody, HttpBody as _};
 use hyper::Client as HyperClient;
-use tokio::sync::Mutex;

-use mlua::{Error, Lua, Result, UserData, UserDataMethods};
+use mlua::{chunk, AnyUserData, 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", |_, reader, ()| async move {
-            let mut reader = reader.0.lock().await;
-            if let Some(bytes) = reader.data().await {
-                let bytes = bytes.map_err(Error::external)?;
-                return Ok(Some(BString::from(bytes.as_ref())));
+        methods.add_async_function("read", |lua, reader: AnyUserData| async move {
+            let mut reader = reader.borrow_mut::<Self>()?;
+            if let Some(bytes) = reader.0.data().await {
+                let bytes = bytes.to_lua_err()?;
+                return Some(lua.create_string(&bytes)).transpose();
            }
            Ok(None)
        });
@@ -36,34 +26,30 @@ async fn main() -> Result<()> {

    let fetch_url = lua.create_async_function(|lua, uri: String| async move {
        let client = HyperClient::new();
-        let uri = uri.parse().map_err(Error::external)?;
-        let resp = client.get(uri).await.map_err(Error::external)?;
+        let uri = uri.parse().to_lua_err()?;
+        let resp = client.get(uri).await.to_lua_err()?;

        let lua_resp = lua.create_table()?;
        lua_resp.set("status", resp.status().as_u16())?;

        let mut headers = HashMap::new();
-        for (key, value) in resp.headers().iter() {
+        for (key, value) in resp.headers() {
            headers
                .entry(key.as_str())
                .or_insert(Vec::new())
-                .push(value.to_str().unwrap());
+                .push(value.to_str().to_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)
@@ -75,8 +61,7 @@ async fn main() -> Result<()> {
                    print(body)
                end
            until not body
-        "#,
-        )
+        })
        .into_function()?;

    f.call_async("http://httpbin.org/ip").await
@@ -1,40 +1,34 @@
-use mlua::{Error, Lua, LuaSerdeExt, Result};
+use mlua::{chunk, ExternalResult, Lua, LuaSerdeExt, Result};

 #[tokio::main]
 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())
-            .map_err(Error::external)?;
-        let json = resp
-            .json::<serde_json::Value>()
-            .await
-            .map_err(Error::external)?;
+            .to_lua_err()?;
+        let json = resp.json::<serde_json::Value>().await.to_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
@@ -1,91 +1,126 @@
+use std::future::Future;
 use std::net::SocketAddr;
-use std::sync::Arc;
+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,
+};

-#[derive(Clone)]
-struct LuaRequest(Arc<(SocketAddr, Request<Body>)>);
+struct LuaRequest(SocketAddr, Request<Body>);

 impl UserData for LuaRequest {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("remote_addr", |_lua, req, ()| Ok((req.0).0.to_string()));
-        methods.add_method("method", |_lua, req, ()| Ok((req.0).1.method().to_string()));
+        methods.add_method("remote_addr", |_lua, req, ()| Ok((req.0).to_string()));
+        methods.add_method("method", |_lua, req, ()| Ok((req.1).method().to_string()));
    }
 }

-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(Arc::new((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!"
-            }
-        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)]
@@ -1,128 +1,121 @@
-use std::sync::Arc;
+use std::io;
+use std::net::SocketAddr;
+use std::rc::Rc;

-use bstr::BString;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
-use tokio::sync::Mutex;
 use tokio::task;

-use mlua::{Function, Lua, Result, UserData, UserDataMethods};
+use mlua::{
+    chunk, AnyUserData, Function, Lua, RegistryKey, String as LuaString, UserData, UserDataMethods,
+};

-#[derive(Clone)]
-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", |_, stream, size: usize| async move {
-            let mut buf = vec![0; size];
-            let n = stream.0.lock().await.read(&mut buf).await?;
-            buf.truncate(n);
-            Ok(BString::from(buf))
-        });
+        methods.add_async_function(
+            "read",
+            |lua, (this, size): (AnyUserData, usize)| async move {
+                let mut this = this.borrow_mut::<Self>()?;
+                let mut buf = vec![0; size];
+                let n = this.0.read(&mut buf).await?;
+                buf.truncate(n);
+                lua.create_string(&buf)
+            },
+        );

-        methods.add_async_method("write", |_, stream, data: BString| async move {
-            let n = stream.0.lock().await.write(&data).await?;
-            Ok(n)
-        });
+        methods.add_async_function(
+            "write",
+            |_, (this, data): (AnyUserData, LuaString)| async move {
+                let mut this = this.borrow_mut::<Self>()?;
+                let n = this.0.write(&data.as_bytes()).await?;
+                Ok(n)
+            },
+        );

-        methods.add_async_method("close", |_, stream, ()| async move {
-            stream.0.lock().await.shutdown().await?;
+        methods.add_async_function("close", |_, this: AnyUserData| async move {
+            let mut this = this.borrow_mut::<Self>()?;
+            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
 }
@@ -1,15 +1,15 @@
 use std::f32;
 use std::iter::FromIterator;

-use mlua::{Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Variadic};
+use mlua::{chunk, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, 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,8 +20,8 @@ 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
+    // 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
    // messages are printed.

@@ -38,6 +38,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 +87,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 variadics using tuples. This is one way to call a function with
    // multiple parameters:

    print.call::<_, ()>(("hello", "again", "from", "rust"))?;
@@ -87,15 +98,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 inself 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)?;
@@ -174,7 +185,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 +202,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());

@@ -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",
+]
@@ -8,10 +8,32 @@ fn used_memory(lua: &Lua, _: ()) -> LuaResult<usize> {
    Ok(lua.used_memory())
 }

+fn check_userdata(_: &Lua, ud: MyUserData) -> LuaResult<i32> {
+    Ok(ud.0)
+}
+
 #[mlua::lua_module]
 fn rust_module(lua: &Lua) -> LuaResult<LuaTable> {
    let exports = lua.create_table()?;
    exports.set("sum", lua.create_function(sum)?)?;
    exports.set("used_memory", lua.create_function(used_memory)?)?;
+    exports.set("check_userdata", lua.create_function(check_userdata)?)?;
    Ok(exports)
 }
+
+#[derive(Clone, Copy)]
+struct MyUserData(i32);
+
+impl LuaUserData for MyUserData {}
+
+#[mlua::lua_module]
+fn rust_module_second(lua: &Lua) -> LuaResult<LuaTable> {
+    let exports = lua.create_table()?;
+    exports.set("userdata", lua.create_userdata(MyUserData(123))?)?;
+    Ok(exports)
+}
+
+#[mlua::lua_module]
+fn rust_module_error(_: &Lua) -> LuaResult<LuaTable> {
+    Err("custom module error".to_lua_err())
+}
@@ -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()
+}
@@ -1,6 +1,6 @@
 [package]
 name = "mlua_derive"
-version = "0.6.0-beta.2"
+version = "0.6.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
 edition = "2018"
 description = "Procedural macros for the mlua crate."
@@ -1,39 +1,38 @@
 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::{parse_macro_input, AttributeArgs, Error, ItemFn};

 #[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,
 };

 #[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);
+    let func = parse_macro_input!(item as ItemFn);

    if !args.is_empty() {
-        let err = Error::new(Span::call_site(), "the number of arguments must be zero")
+        let err = Error::new(Span::call_site(), "the macro does not support arguments")
            .to_compile_error();
        return err.into();
    }

-    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_name = func.sig.ident.clone();
+    let ext_entrypoint_name = Ident::new(&format!("luaopen_{}", func_name), Span::call_site());

-    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" fn #ext_entrypoint_name(state: *mut ::mlua::lua_State) -> ::std::os::raw::c_int {
+            ::mlua::Lua::init_from_ptr(state)
+                .entrypoint1(#func_name)
+                .expect("cannot initialize module")
        }
    };

@@ -78,15 +77,15 @@ pub fn chunk(input: TokenStream) -> TokenStream {
                (#source).as_bytes()
            }

-            fn env(&self, lua: &'lua Lua) -> Option<Result<Value<'lua>>> {
+            fn env(&self, lua: &'lua Lua) -> Result<Option<Value<'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));
+                            return make_env(lua).map(Some);
                        }
                    }
                }
-                None
+                Ok(None)
            }

            fn mode(&self) -> Option<ChunkMode> {
@@ -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()
            }
@@ -2,6 +2,7 @@

 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::convert::TryInto;
 use std::ffi::{CStr, CString};
 use std::hash::{BuildHasher, Hash};
 use std::string::String as StdString;
@@ -20,24 +21,28 @@ use crate::userdata::{AnyUserData, UserData};
 use crate::value::{FromLua, Nil, ToLua, Value};

 impl<'lua> ToLua<'lua> for Value<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(self)
    }
 }

 impl<'lua> FromLua<'lua> for Value<'lua> {
+    #[inline]
    fn from_lua(lua_value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
        Ok(lua_value)
    }
 }

 impl<'lua> ToLua<'lua> for String<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::String(self))
    }
 }

 impl<'lua> FromLua<'lua> for String<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<String<'lua>> {
        let ty = value.type_name();
        lua.coerce_string(value)?
@@ -50,12 +55,14 @@ impl<'lua> FromLua<'lua> for String<'lua> {
 }

 impl<'lua> ToLua<'lua> for Table<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Table(self))
    }
 }

 impl<'lua> FromLua<'lua> for Table<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Table<'lua>> {
        match value {
            Value::Table(table) => Ok(table),
@@ -69,12 +76,14 @@ impl<'lua> FromLua<'lua> for Table<'lua> {
 }

 impl<'lua> ToLua<'lua> for Function<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Function(self))
    }
 }

 impl<'lua> FromLua<'lua> for Function<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Function<'lua>> {
        match value {
            Value::Function(table) => Ok(table),
@@ -88,12 +97,14 @@ impl<'lua> FromLua<'lua> for Function<'lua> {
 }

 impl<'lua> ToLua<'lua> for Thread<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Thread(self))
    }
 }

 impl<'lua> FromLua<'lua> for Thread<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Thread<'lua>> {
        match value {
            Value::Thread(t) => Ok(t),
@@ -107,12 +118,14 @@ impl<'lua> FromLua<'lua> for Thread<'lua> {
 }

 impl<'lua> ToLua<'lua> for AnyUserData<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::UserData(self))
    }
 }

 impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<AnyUserData<'lua>> {
        match value {
            Value::UserData(ud) => Ok(ud),
@@ -126,12 +139,14 @@ impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
 }

 impl<'lua, T: 'static + MaybeSend + UserData> ToLua<'lua> for T {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::UserData(lua.create_userdata(self)?))
    }
 }

 impl<'lua, T: 'static + UserData + Clone> FromLua<'lua> for T {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<T> {
        match value {
            Value::UserData(ud) => Ok(ud.borrow::<T>()?.clone()),
@@ -145,12 +160,14 @@ impl<'lua, T: 'static + UserData + Clone> FromLua<'lua> for T {
 }

 impl<'lua> ToLua<'lua> for Error {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Error(self))
    }
 }

 impl<'lua> FromLua<'lua> for Error {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Error> {
        match value {
            Value::Error(err) => Ok(err),
@@ -164,12 +181,14 @@ impl<'lua> FromLua<'lua> for Error {
 }

 impl<'lua> ToLua<'lua> for bool {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Boolean(self))
    }
 }

 impl<'lua> FromLua<'lua> for bool {
+    #[inline]
    fn from_lua(v: Value<'lua>, _: &'lua Lua) -> Result<Self> {
        match v {
            Value::Nil => Ok(false),
@@ -180,12 +199,14 @@ impl<'lua> FromLua<'lua> for bool {
 }

 impl<'lua> ToLua<'lua> for LightUserData {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::LightUserData(self))
    }
 }

 impl<'lua> FromLua<'lua> for LightUserData {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
        match value {
            Value::LightUserData(ud) => Ok(ud),
@@ -199,12 +220,14 @@ impl<'lua> FromLua<'lua> for LightUserData {
 }

 impl<'lua> ToLua<'lua> for StdString {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::String(lua.create_string(&self)?))
    }
 }

 impl<'lua> FromLua<'lua> for StdString {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
        let ty = value.type_name();
        Ok(lua
@@ -220,6 +243,7 @@ impl<'lua> FromLua<'lua> for StdString {
 }

 impl<'lua> ToLua<'lua> for &str {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::String(lua.create_string(self)?))
    }
@@ -325,24 +349,24 @@ macro_rules! lua_convert_int {
    ($x:ty) => {
        impl<'lua> ToLua<'lua> for $x {
            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
-                if let Some(i) = cast(self) {
-                    Ok(Value::Integer(i))
-                } else {
-                    cast(self)
-                        .ok_or_else(|| Error::ToLuaConversionError {
-                            from: stringify!($x),
-                            to: "number",
-                            message: Some("out of range".to_owned()),
-                        })
-                        .map(Value::Number)
-                }
+                cast(self)
+                    .map(Value::Integer)
+                    .or_else(|| cast(self).map(Value::Number))
+                    // This is impossible error because conversion to Number never fails
+                    .ok_or_else(|| Error::ToLuaConversionError {
+                        from: stringify!($x),
+                        to: "number",
+                        message: Some("out of range".to_owned()),
+                    })
            }
        }

        impl<'lua> FromLua<'lua> for $x {
            fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
                let ty = value.type_name();
-                (if let Some(i) = lua.coerce_integer(value.clone())? {
+                (if let Value::Integer(i) = value {
+                    cast(i)
+                } else if let Some(i) = lua.coerce_integer(value.clone())? {
                    cast(i)
                } else {
                    cast(lua.coerce_number(value)?.ok_or_else(|| {
@@ -427,37 +451,36 @@ where
    }
 }

-macro_rules! lua_convert_array {
-    ($($N:literal)+) => {
-        $(
-            impl<'lua, T> ToLua<'lua> for [T; $N]
-            where
-                T: Clone + ToLua<'lua>,
-            {
-                fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-                    (&self).to_lua(lua)
-                }
-            }
-
-            impl<'lua, T> ToLua<'lua> for &[T; $N]
-            where
-                T: Clone + ToLua<'lua>,
-            {
-                fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-                    Ok(Value::Table(
-                        lua.create_sequence_from(self.iter().cloned())?,
-                    ))
-                }
-            }
-        )+
+impl<'lua, T, const N: usize> ToLua<'lua> for [T; N]
+where
+    T: ToLua<'lua>,
+{
+    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Table(lua.create_sequence_from(self)?))
    }
 }

-lua_convert_array! {
-    0  1  2  3  4  5  6  7  8  9
-   10 11 12 13 14 15 16 17 18 19
-   20 21 22 23 24 25 26 27 28 29
-   30 31 32
+impl<'lua, T, const N: usize> FromLua<'lua> for [T; N]
+where
+    T: FromLua<'lua>,
+{
+    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+        if let Value::Table(table) = value {
+            let vec = table.sequence_values().collect::<Result<Vec<_>>>()?;
+            vec.try_into()
+                .map_err(|vec: Vec<T>| Error::FromLuaConversionError {
+                    from: "Table",
+                    to: "Array",
+                    message: Some(format!("expected table of length {}, got {}", N, vec.len())),
+                })
+        } else {
+            Err(Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: "Array",
+                message: Some("expected table".to_string()),
+            })
+        }
+    }
 }

 impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
@@ -554,17 +577,17 @@ impl<'lua, T: Eq + Hash + ToLua<'lua>, S: BuildHasher> ToLua<'lua> for HashSet<T

 impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua> for HashSet<T, S> {
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table
+        match value {
+            Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
+            Value::Table(table) => table
                .pairs::<T, Value<'lua>>()
                .map(|res| res.map(|(k, _)| k))
-                .collect()
-        } else {
-            Err(Error::FromLuaConversionError {
+                .collect(),
+            _ => Err(Error::FromLuaConversionError {
                from: value.type_name(),
                to: "HashSet",
                message: Some("expected table".to_string()),
-            })
+            }),
        }
    }
 }
@@ -579,22 +602,23 @@ impl<'lua, T: Ord + ToLua<'lua>> ToLua<'lua> for BTreeSet<T> {

 impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table
+        match value {
+            Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
+            Value::Table(table) => table
                .pairs::<T, Value<'lua>>()
                .map(|res| res.map(|(k, _)| k))
-                .collect()
-        } else {
-            Err(Error::FromLuaConversionError {
+                .collect(),
+            _ => Err(Error::FromLuaConversionError {
                from: value.type_name(),
                to: "BTreeSet",
                message: Some("expected table".to_string()),
-            })
+            }),
        }
    }
 }

 impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        match self {
            Some(val) => val.to_lua(lua),
@@ -604,6 +628,7 @@ impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
 }

 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Option<T> {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
        match value {
            Nil => Ok(None),
@@ -96,8 +96,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,15 +105,15 @@ 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.
    ///
@@ -121,8 +121,8 @@ pub enum Error {
    /// 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.
    ///
@@ -130,22 +130,24 @@ pub enum Error {
    /// 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 {
        method: StdString,
        type_name: &'static str,
        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 {
@@ -174,15 +176,13 @@ pub enum Error {
    /// Returning `Err(ExternalError(...))` from a Rust callback will raise the error as a Lua
    /// error. The Rust code that originally invoked the Lua code then receives a `CallbackError`,
    /// from which the original error (and a stack traceback) can be recovered.
-    #[cfg(feature = "send")]
    ExternalError(Arc<dyn StdError + Send + Sync>),
-    #[cfg(not(feature = "send"))]
-    ExternalError(Arc<dyn StdError>),
 }

 /// 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 {
@@ -247,8 +247,28 @@ impl fmt::Display for Error {
            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 } => {
+                writeln!(fmt, "callback error")?;
+                // Trace errors down to the root
+                let (mut cause, mut full_traceback) = (cause, None);
+                while let Error::CallbackError { cause: ref cause2, traceback: ref traceback2 } = **cause {
+                    cause = cause2;
+                    full_traceback = Some(traceback2);
+                }
+                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())?;
+                }
+                write!(fmt, "caused by: {}", cause)
            }
            Error::PreviouslyResumedPanic => {
                write!(fmt, "previously resumed panic returned again")
@@ -269,7 +289,11 @@ 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(),
            _ => None,
        }
@@ -277,35 +301,21 @@ impl StdError for Error {
 }

 impl Error {
-    #[cfg(feature = "send")]
    pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Error {
        Error::ExternalError(err.into().into())
    }
-
-    #[cfg(not(feature = "send"))]
-    pub fn external<T: Into<Box<dyn StdError>>>(err: T) -> Error {
-        Error::ExternalError(err.into().into())
-    }
 }

 pub trait ExternalError {
    fn to_lua_err(self) -> Error;
 }

-#[cfg(feature = "send")]
 impl<E: Into<Box<dyn StdError + Send + Sync>>> ExternalError for E {
    fn to_lua_err(self) -> Error {
        Error::external(self)
    }
 }

-#[cfg(not(feature = "send"))]
-impl<E: Into<Box<dyn StdError>>> ExternalError for E {
-    fn to_lua_err(self) -> Error {
-        Error::external(self)
-    }
-}
-
 pub trait ExternalResult<T> {
    fn to_lua_err(self) -> Result<T>;
 }
@@ -23,6 +23,7 @@

 //! Contains definitions from `lua.h`.

+use std::marker::{PhantomData, PhantomPinned};
 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
 use std::os::raw::c_uchar;
 use std::os::raw::{c_char, c_int, c_void};
@@ -63,7 +64,7 @@ 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 {
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
    LUA_REGISTRYINDEX - i
 }

@@ -80,7 +81,12 @@ 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;
+/// 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;
@@ -111,20 +117,24 @@ 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;

+// I believe `luaL_traceback` < 5.4 requires this much free stack to not error.
+// 5.4 uses `luaL_Buffer`
+pub const LUA_TRACEBACK_STACK: c_int = 11;
+
 /// 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
+/// A Lua unsigned integer, usually equivalent to `u64`.
 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.
+/// Type for native C functions that can be passed to Lua.
 pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;

 // Type for continuation functions
@@ -564,7 +574,7 @@ pub unsafe fn lua_resume(
 // 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_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);
 }

@@ -616,7 +626,7 @@ extern "C" {
 #[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
+    (L as *mut c_char).offset(-super::glue::LUA_EXTRASPACE as isize) as *mut c_void
 }

 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
@@ -215,7 +215,8 @@ pub use self::lua::{
    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,
+    LUA_TNUMBER, LUA_TRACEBACK_STACK, LUA_TSTRING, LUA_TTABLE, LUA_TTHREAD, LUA_TUSERDATA,
+    LUA_YIELD,
 };

 #[cfg(any(feature = "lua54", feature = "lua53"))]
@@ -280,6 +281,25 @@ pub const SYS_MIN_ALIGN: usize = 8;
 )))]
 pub const SYS_MIN_ALIGN: usize = 16;

+// Hack to avoid stripping a few unused Lua symbols that could be imported
+// by C modules in unsafe mode
+pub(crate) fn keep_lua_symbols() {
+    let mut symbols: Vec<*const extern "C" fn()> = Vec::new();
+    symbols.push(lua_atpanic as _);
+    symbols.push(lua_isuserdata as _);
+    symbols.push(lua_tocfunction as _);
+    symbols.push(luaL_loadstring as _);
+    symbols.push(luaL_openlibs as _);
+    if cfg!(any(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52"
+    ))) {
+        symbols.push(lua_getglobal as _);
+        symbols.push(lua_setglobal as _);
+    }
+}
+
 #[allow(unused_imports, dead_code, non_camel_case_types)]
 #[allow(clippy::unreadable_literal)]
 mod glue {
@@ -293,5 +313,3 @@ mod lauxlib;
 mod lua;
 mod luaconf;
 mod lualib;
-
-pub mod safe;
@@ -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)
-}
@@ -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.
-*********************************************************************/
-
@@ -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_ */
-
@@ -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;
-}
@@ -1,11 +1,12 @@
 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::util::{assert_stack, check_stack, error_traceback, pop_error, StackGuard};
+use crate::value::{FromLuaMulti, ToLuaMulti};

 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
@@ -58,17 +59,17 @@ impl<'lua> Function<'lua> {
    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
        let lua = self.0.lua;

-        let args = args.to_lua_multi(lua)?;
+        let mut args = args.to_lua_multi(lua)?;
        let nargs = args.len() as c_int;

        let results = unsafe {
            let _sg = StackGuard::new(lua.state);
            check_stack(lua.state, nargs + 3)?;

-            ffi::lua_pushcfunction(lua.state, ffi::safe::error_traceback);
+            ffi::lua_pushcfunction(lua.state, error_traceback);
            let stack_start = ffi::lua_gettop(lua.state);
            lua.push_ref(&self.0);
-            for arg in args {
+            for arg in args.drain_all() {
                lua.push_value(arg)?;
            }
            let ret = ffi::lua_pcall(lua.state, nargs, ffi::LUA_MULTRET, stack_start);
@@ -76,7 +77,7 @@ impl<'lua> Function<'lua> {
                return Err(pop_error(lua.state, ret));
            }
            let nresults = ffi::lua_gettop(lua.state) - stack_start;
-            let mut results = MultiValue::new();
+            let mut results = args; // Reuse MultiValue container
            assert_stack(lua.state, 2);
            for _ in 0..nresults {
                results.push_front(lua.pop_value());
@@ -115,7 +116,7 @@ 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>>
@@ -125,8 +126,12 @@ impl<'lua> Function<'lua> {
        R: FromLuaMulti<'lua> + 'fut,
    {
        let lua = self.0.lua;
-        match lua.create_thread(self.clone()) {
-            Ok(t) => Box::pin(t.into_async(args)),
+        match lua.create_recycled_thread(self.clone()) {
+            Ok(t) => {
+                let mut t = t.into_async(args);
+                t.set_recyclable(true);
+                Box::pin(t)
+            }
            Err(e) => Box::pin(future::err(e)),
        }
    }
@@ -159,6 +164,26 @@ impl<'lua> Function<'lua> {
    /// # }
    /// ```
    pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
+        unsafe extern "C" fn bind_call_impl(state: *mut ffi::lua_State) -> c_int {
+            let nargs = ffi::lua_gettop(state);
+            let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(2)) as c_int;
+            ffi::luaL_checkstack(state, nbinds + 2, ptr::null());
+
+            ffi::lua_settop(state, nargs + nbinds + 1);
+            ffi::lua_rotate(state, -(nargs + nbinds + 1), nbinds + 1);
+
+            ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
+            ffi::lua_replace(state, 1);
+
+            for i in 0..nbinds {
+                ffi::lua_pushvalue(state, ffi::lua_upvalueindex(i + 3));
+                ffi::lua_replace(state, i + 2);
+            }
+
+            ffi::lua_call(state, nargs + nbinds, ffi::LUA_MULTRET);
+            ffi::lua_gettop(state)
+        }
+
        let lua = self.0.lua;

        let args = args.to_lua_multi(lua)?;
@@ -177,7 +202,9 @@ impl<'lua> Function<'lua> {
            for arg in args {
                lua.push_value(arg)?;
            }
-            ffi::safe::lua_pushcclosure(lua.state, ffi::safe::bind_call_impl, nargs + 2)?;
+            protect_lua!(lua.state, nargs + 2, 1, fn(state) {
+                ffi::lua_pushcclosure(state, bind_call_impl, ffi::lua_gettop(state));
+            })?;

            Ok(Function(lua.pop_ref()))
        }
@@ -1,55 +1,86 @@
+use std::cell::UnsafeCell;
 use std::ffi::CStr;
-use std::marker::PhantomData;
+use std::ops::{BitOr, BitOrAssign};
 use std::os::raw::{c_char, c_int};

-use crate::ffi::{self, lua_Debug, lua_State};
+use crate::ffi::{self, lua_Debug};
 use crate::lua::Lua;
-use crate::util::callback_error;

 /// 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,
 }

-impl<'a> Debug<'a> {
+impl<'lua> Debug<'lua> {
+    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, ar: lua_Debug) -> Self {
+        Debug {
+            lua,
+            ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
+        }
+    }
+
+    /// 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
+    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<'a> {
+    pub fn names(&self) -> DebugNames<'lua> {
        unsafe {
            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`"
            );
            DebugNames {
-                name: ptr_to_str((*self.ar).name),
-                name_what: ptr_to_str((*self.ar).namewhat),
+                name: ptr_to_str((*self.ar.get()).name),
+                name_what: ptr_to_str((*self.ar.get()).namewhat),
            }
        }
    }

    /// Corresponds to the `S` what mask.
-    pub fn source(&self) -> DebugSource<'a> {
+    pub fn source(&self) -> DebugSource<'lua> {
        unsafe {
            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`"
            );
            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_str((*self.ar.get()).source),
+                short_src: ptr_to_str((*self.ar.get()).short_src.as_ptr()),
+                line_defined: (*self.ar.get()).linedefined as i32,
+                last_line_defined: (*self.ar.get()).lastlinedefined as i32,
+                what: ptr_to_str((*self.ar.get()).what),
            }
        }
    }
@@ -58,10 +89,10 @@ impl<'a> Debug<'a> {
    pub fn curr_line(&self) -> i32 {
        unsafe {
            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
+            (*self.ar.get()).currentline as i32
        }
    }

@@ -70,10 +101,10 @@ impl<'a> Debug<'a> {
    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
        }
    }

@@ -81,20 +112,46 @@ impl<'a> Debug<'a> {
    pub fn stack(&self) -> DebugStack {
        unsafe {
            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,
+                num_ups: (*self.ar.get()).nups as i32,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar).nparams as i32,
+                num_params: (*self.ar.get()).nparams as i32,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                is_vararg: (*self.ar).isvararg != 0,
+                is_vararg: (*self.ar.get()).isvararg != 0,
            }
        }
    }
 }

+enum ActivationRecord {
+    Borrowed(*mut lua_Debug),
+    Owned(UnsafeCell<lua_Debug>),
+}
+
+impl ActivationRecord {
+    #[inline]
+    fn get(&self) -> *mut lua_Debug {
+        match self {
+            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]>,
@@ -114,10 +171,10 @@ pub struct DebugSource<'a> {
 pub struct DebugStack {
    pub num_ups: i32,
    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
    pub num_params: i32,
    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
    pub is_vararg: bool,
 }

@@ -140,6 +197,46 @@ pub struct HookTriggers {
 }

 impl HookTriggers {
+    /// Returns a new instance of `HookTriggers` with [`on_calls`] trigger set.
+    ///
+    /// [`on_calls`]: #structfield.on_calls
+    pub fn on_calls() -> Self {
+        HookTriggers {
+            on_calls: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns a new instance of `HookTriggers` with [`on_returns`] trigger set.
+    ///
+    /// [`on_returns`]: #structfield.on_returns
+    pub fn on_returns() -> Self {
+        HookTriggers {
+            on_returns: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns a new instance of `HookTriggers` with [`every_line`] trigger set.
+    ///
+    /// [`every_line`]: #structfield.every_line
+    pub fn every_line() -> Self {
+        HookTriggers {
+            every_line: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns a new instance of `HookTriggers` with [`every_nth_instruction`] trigger set.
+    ///
+    /// [`every_nth_instruction`]: #structfield.every_nth_instruction
+    pub fn every_nth_instruction(n: u32) -> Self {
+        HookTriggers {
+            every_nth_instruction: Some(n),
+            ..Default::default()
+        }
+    }
+
    // Compute the mask to pass to `lua_sethook`.
    pub(crate) fn mask(&self) -> c_int {
        let mut mask: c_int = 0;
@@ -165,26 +262,24 @@ impl HookTriggers {
    }
 }

-#[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,
-        };
+impl BitOr for HookTriggers {
+    type Output = Self;

-        let lua = Lua::make_from_ptr(state);
-        let hook_cb = mlua_expect!(lua.hook_callback(), "no hook callback set in hook_proc");
+    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
+    }
+}

-        #[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)
-    })
+impl BitOrAssign for HookTriggers {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
+    }
 }

 unsafe fn ptr_to_str<'a>(input: *const c_char) -> Option<&'a [u8]> {
@@ -50,29 +50,29 @@
 //! 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
+//! [`ToLua`]: crate::ToLua
+//! [`FromLua`]: crate::FromLua
+//! [`ToLuaMulti`]: crate::ToLuaMulti
+//! [`FromLuaMulti`]: crate::FromLuaMulti
+//! [`Function`]: crate::Function
+//! [`UserData`]: crate::UserData
+//! [`UserDataFields`]: crate::UserDataFields
+//! [`UserDataMethods`]: crate::UserDataMethods
+//! [`LuaSerdeExt`]: crate::LuaSerdeExt
+//! [`Value`]: crate::Value
+//! [`create_async_function`]: crate::Lua::create_async_function
+//! [`call_async`]: crate::Function::call_async
+//! [`AsyncThread`]: crate::AsyncThread
+//! [`Future`]: std::future::Future
 //! [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html

 // mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.6.0-beta.2")]
+#![doc(html_root_url = "https://docs.rs/mlua/0.7.2")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]
@@ -98,12 +98,13 @@ mod userdata;
 mod util;
 mod value;

-#[doc(hidden)]
-pub use crate::ffi::lua_State;
+pub mod prelude;
+
+pub use crate::{ffi::lua_CFunction, ffi::lua_State};

 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::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack, HookTriggers};
 pub use crate::lua::{AsChunk, Chunk, ChunkMode, GCMode, Lua, LuaOptions};
 pub use crate::multi::Variadic;
 pub use crate::scope::Scope;
@@ -122,9 +123,10 @@ 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;
@@ -139,9 +141,9 @@ extern crate mlua_derive;
 /// This macro allows to write Lua code directly in Rust code.
 ///
 /// Rust variables can be referenced from Lua using `$` prefix, as shown in the example below.
-/// User Rust types needs to implement [`UserData`] or [`ToLua`] traits.
+/// User's Rust types needs to implement [`UserData`] or [`ToLua`] traits.
 ///
-/// Captured variables are moved into the chunk.
+/// Captured variables are **moved** into the chunk.
 ///
 /// ```
 /// use mlua::{Lua, Result, chunk};
@@ -165,24 +167,48 @@ 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
+/// [`AsChunk`]: crate::AsChunk
+/// [`UserData`]: crate::UserData
+/// [`ToLua`]: crate::ToLua
 #[cfg(any(feature = "macros"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;

-#[cfg(any(feature = "module"))]
+/// 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`.
+///
+#[cfg(any(feature = "module", docsrs))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;
@@ -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,18 @@ 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) => {{
+        unsafe extern "C" fn do_call($state_inner: *mut ffi::lua_State) -> ::std::os::raw::c_int {
+            $code;
+            $nresults
+        }
+
+        crate::util::protect_lua_call($state, $nargs, do_call)
+    }};
+}
@@ -12,8 +12,7 @@ use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
 /// 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();
-
+        let mut result = MultiValue::new_or_cached(lua);
        match self {
            Ok(v) => result.push_front(v.to_lua(lua)?),
            Err(e) => {
@@ -21,14 +20,13 @@ impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E>
                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();
+        let mut v = MultiValue::new_or_cached(lua);
        v.push_front(self.to_lua(lua)?);
        Ok(v)
    }
@@ -36,7 +34,9 @@ impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {

 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-        T::from_lua(values.pop_front().unwrap_or(Nil), lua)
+        let res = T::from_lua(values.pop_front().unwrap_or(Nil), lua);
+        lua.cache_multivalue(values);
+        res
    }
 }

@@ -76,8 +76,8 @@ 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>);

@@ -125,30 +125,35 @@ 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()
+        let mut values = MultiValue::new_or_cached(lua);
+        values.refill(self.0.into_iter().map(|e| e.to_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> {
-        values
-            .into_iter()
+    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+        let res = values
+            .drain_all()
            .map(|e| T::from_lua(e, lua))
            .collect::<Result<Vec<T>>>()
-            .map(Variadic)
+            .map(Variadic);
+        lua.cache_multivalue(values);
+        res
    }
 }

 macro_rules! impl_tuple {
    () => (
        impl<'lua> ToLuaMulti<'lua> for () {
-            fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
-                Ok(MultiValue::new())
+            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+                Ok(MultiValue::new_or_cached(lua))
            }
        }

        impl<'lua> FromLuaMulti<'lua> for () {
-            fn from_lua_multi(_: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
+            fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+                lua.cache_multivalue(values);
                Ok(())
            }
        }
@@ -1,21 +1,27 @@
 //! 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,
    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,
-    UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
-    UserDataMethods as LuaUserDataMethods, Value as LuaValue,
+    Result as LuaResult, StdLib as LuaStdLib, String as LuaString, Table as LuaTable,
+    TableExt as LuaTableExt, TablePairs as LuaTablePairs, TableSequence as LuaTableSequence,
+    Thread as LuaThread, ThreadStatus as LuaThreadStatus, ToLua, ToLuaMulti,
+    UserData as LuaUserData, UserDataFields as LuaUserDataFields,
+    UserDataMetatable as LuaUserDataMetatable, UserDataMethods as LuaUserDataMethods,
+    Value as LuaValue,
 };

 #[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,
+};
@@ -1,8 +1,10 @@
 use std::any::Any;
-use std::cell::{Cell, Ref, RefCell, RefMut};
+use std::cell::{Cell, RefCell};
 use std::marker::PhantomData;
 use std::mem;
 use std::os::raw::{c_int, c_void};
+use std::ptr;
+use std::rc::Rc;

 #[cfg(feature = "serialize")]
 use serde::Serialize;
@@ -11,20 +13,23 @@ use crate::error::{Error, Result};
 use crate::ffi;
 use crate::function::Function;
 use crate::lua::Lua;
-use crate::types::{Callback, LuaRef, MaybeSend};
+use crate::types::{Callback, CallbackUpvalue, LuaRef, MaybeSend};
 use crate::userdata::{
    AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
 };
 use crate::util::{
-    assert_stack, check_stack, get_userdata, init_userdata_metatable, push_userdata, take_userdata,
-    StackGuard,
+    assert_stack, check_stack, get_userdata, init_userdata_metatable, push_table, rawset_field,
+    take_userdata, StackGuard,
 };
 use crate::value::{FromLua, FromLuaMulti, MultiValue, ToLua, ToLuaMulti, Value};

+#[cfg(feature = "lua54")]
+use crate::userdata::USER_VALUE_MAXSLOT;
+
 #[cfg(feature = "async")]
 use {
-    crate::types::AsyncCallback,
-    futures_core::future::{Future, LocalBoxFuture},
+    crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue},
+    futures_core::future::Future,
    futures_util::future::{self, TryFutureExt},
 };

@@ -33,7 +38,7 @@ use {
 ///
 /// See [`Lua::scope`] for more details.
 ///
-/// [`Lua::scope`]: struct.Lua.html#method.scope
+/// [`Lua::scope`]: crate::Lua.html::scope
 pub struct Scope<'lua, 'scope> {
    lua: &'lua Lua,
    destructors: RefCell<Vec<(LuaRef<'lua>, DestructorCallback<'lua>)>>,
@@ -56,8 +61,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// This is a version of [`Lua::create_function`] that creates a callback which expires on
    /// scope drop. See [`Lua::scope`] for more details.
    ///
-    /// [`Lua::create_function`]: struct.Lua.html#method.create_function
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_function`]: crate::Lua::create_function
+    /// [`Lua::scope`]: crate::Lua::scope
    pub fn create_function<'callback, A, R, F>(&'callback self, func: F) -> Result<Function<'lua>>
    where
        A: FromLuaMulti<'callback>,
@@ -85,8 +90,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// This is a version of [`Lua::create_function_mut`] that creates a callback which expires
    /// on scope drop. See [`Lua::scope`] and [`Scope::create_function`] for more details.
    ///
-    /// [`Lua::create_function_mut`]: struct.Lua.html#method.create_function_mut
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_function_mut`]: crate::Lua::create_function_mut
+    /// [`Lua::scope`]: crate::Lua::scope
    /// [`Scope::create_function`]: #method.create_function
    pub fn create_function_mut<'callback, A, R, F>(
        &'callback self,
@@ -112,9 +117,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    ///
    /// Requires `feature = "async"`
    ///
-    /// [`Lua::create_async_function`]: struct.Lua.html#method.create_async_function
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
-    /// [`Lua::async_scope`]: struct.Lua.html#method.async_scope
+    /// [`Lua::create_async_function`]: crate::Lua::create_async_function
+    /// [`Lua::scope`]: crate::Lua::scope
+    /// [`Lua::async_scope`]: crate::Lua::async_scope
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
    pub fn create_async_function<'callback, A, R, F, FR>(
@@ -145,8 +150,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// UserData be 'static).
    /// See [`Lua::scope`] for more details.
    ///
-    /// [`Lua::create_userdata`]: struct.Lua.html#method.create_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_userdata`]: crate::Lua::create_userdata
+    /// [`Lua::scope`]: crate::Lua::scope
    pub fn create_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
    where
        T: 'static + UserData,
@@ -163,8 +168,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    ///
    /// Requires `feature = "serialize"`
    ///
-    /// [`Lua::create_ser_userdata`]: struct.Lua.html#method.create_ser_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_ser_userdata`]: crate::Lua::create_ser_userdata
+    /// [`Lua::scope`]: crate::Lua::scope
    #[cfg(feature = "serialize")]
    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
    pub fn create_ser_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
@@ -190,16 +195,27 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                let _sg = StackGuard::new(state);
                assert_stack(state, 2);

-                ud.lua.push_ref(&ud);
+                // Check that userdata is not destructed (via `take()` call)
+                if ud.lua.push_userdata_ref(&ud).is_err() {
+                    return vec![];
+                }

-                // We know the destructor has not run yet because we hold a reference to the userdata.
-
-                // Clear uservalue
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                ffi::lua_pushnil(state);
+                // Clear associated user values
+                #[cfg(feature = "lua54")]
+                for i in 1..=USER_VALUE_MAXSLOT {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setiuservalue(state, -2, i as c_int);
+                }
+                #[cfg(any(feature = "lua53", feature = "lua52"))]
+                {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setuservalue(state, -2);
+                }
                #[cfg(any(feature = "lua51", feature = "luajit"))]
-                ud.lua.push_ref(&newtable.0);
-                ffi::lua_setuservalue(state, -2);
+                {
+                    ud.lua.push_ref(&newtable.0);
+                    ffi::lua_setuservalue(state, -2);
+                }

                vec![Box::new(take_userdata::<UserDataCell<T>>(state))]
            });
@@ -222,7 +238,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// use [`Scope::create_userdata`] instead.
    ///
    /// The main limitation that comes from using non-'static userdata is that the produced userdata
-    /// will no longer have a `TypeId` associated with it, becuase `TypeId` can only work for
+    /// will no longer have a `TypeId` associated with it, because `TypeId` can only work for
    /// 'static types. This means that it is impossible, once the userdata is created, to get a
    /// reference to it back *out* of an `AnyUserData` handle. This also implies that the
    /// "function" type methods that can be added via [`UserDataMethods`] (the ones that accept
@@ -231,14 +247,14 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// creating the userdata metatable each time a new userdata is created.
    ///
    /// [`Scope::create_userdata`]: #method.create_userdata
-    /// [`Lua::create_userdata`]: struct.Lua.html#method.create_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
-    /// [`UserDataMethods`]: trait.UserDataMethods.html
+    /// [`Lua::create_userdata`]: crate::Lua::create_userdata
+    /// [`Lua::scope`]:crate::Lua::scope
+    /// [`UserDataMethods`]: crate::UserDataMethods
    pub fn create_nonstatic_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
    where
        T: 'scope + UserData,
    {
-        let data = UserDataCell::new_arc(data);
+        let data = Rc::new(RefCell::new(data));

        // 'callback outliving 'scope is a lie to make the types work out, required due to the
        // inability to work with the more correct callback type that is universally quantified over
@@ -247,8 +263,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
        // parameters.
        fn wrap_method<'scope, 'lua, 'callback: 'scope, T: 'scope>(
            scope: &Scope<'lua, 'scope>,
-            data: UserDataCell<T>,
-            data_ptr: *mut c_void,
+            data: Rc<RefCell<T>>,
+            data_ptr: *const c_void,
            method: NonStaticMethod<'callback, T>,
        ) -> Result<Function<'lua>> {
            // On methods that actually receive the userdata, we fake a type check on the passed in
@@ -262,9 +278,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                if let Some(Value::UserData(ud)) = value {
                    unsafe {
                        let _sg = StackGuard::new(lua.state);
-                        check_stack(lua.state, 3)?;
+                        check_stack(lua.state, 2)?;
                        lua.push_userdata_ref(&ud.0)?;
-                        if get_userdata(lua.state, -1) == data_ptr {
+                        if get_userdata(lua.state, -1) as *const _ == data_ptr {
                            return Ok(());
                        }
                    }
@@ -276,10 +292,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                NonStaticMethod::Method(method) => {
                    let f = Box::new(move |lua, mut args: MultiValue<'callback>| {
                        check_ud_type(lua, args.pop_front())?;
-                        let data = data
-                            .try_borrow()
-                            .map(|cell| Ref::map(cell, AsRef::as_ref))
-                            .map_err(|_| Error::UserDataBorrowError)?;
+                        let data = data.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
                        method(lua, &*data, args)
                    });
                    unsafe { scope.create_callback(f) }
@@ -293,7 +306,6 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                            .map_err(|_| Error::RecursiveMutCallback)?;
                        let mut data = data
                            .try_borrow_mut()
-                            .map(|cell| RefMut::map(cell, AsMut::as_mut))
                            .map_err(|_| Error::UserDataBorrowMutError)?;
                        (&mut *method)(lua, &mut *data, args)
                    });
@@ -324,32 +336,43 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
            let _sg = StackGuard::new(lua.state);
            check_stack(lua.state, 13)?;

-            push_userdata(lua.state, data.clone())?;
-            let data_ptr = ffi::lua_touserdata(lua.state, -1);
+            #[allow(clippy::let_and_return)]
+            let data_ptr = protect_lua!(lua.state, 0, 1, |state| {
+                let ud =
+                    ffi::lua_newuserdata(state, mem::size_of::<UserDataCell<Rc<RefCell<T>>>>());

+                // Set empty environment for Lua 5.1
+                #[cfg(any(feature = "lua51", feature = "luajit"))]
+                {
+                    ffi::lua_newtable(state);
+                    ffi::lua_setuservalue(state, -2);
+                }
+
+                ud
+            })?;
            // Prepare metatable, add meta methods first and then meta fields
            let meta_methods_nrec = ud_methods.meta_methods.len() + ud_fields.meta_fields.len() + 1;
-            ffi::safe::lua_createtable(lua.state, 0, meta_methods_nrec as c_int)?;
+            push_table(lua.state, 0, meta_methods_nrec as c_int)?;

            for (k, m) in ud_methods.meta_methods {
                let data = data.clone();
                lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
-                ffi::safe::lua_rawsetfield(lua.state, -2, k.validate()?.name())?;
+                rawset_field(lua.state, -2, k.validate()?.name())?;
            }
            for (k, f) in ud_fields.meta_fields {
                lua.push_value(f(mem::transmute(lua))?)?;
-                ffi::safe::lua_rawsetfield(lua.state, -2, k.validate()?.name())?;
+                rawset_field(lua.state, -2, k.validate()?.name())?;
            }
            let metatable_index = ffi::lua_absindex(lua.state, -1);

            let mut field_getters_index = None;
            let field_getters_nrec = ud_fields.field_getters.len();
            if field_getters_nrec > 0 {
-                ffi::safe::lua_createtable(lua.state, 0, field_getters_nrec as c_int)?;
+                push_table(lua.state, 0, field_getters_nrec as c_int)?;
                for (k, m) in ud_fields.field_getters {
                    let data = data.clone();
                    lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
-                    ffi::safe::lua_rawsetfield(lua.state, -2, &k)?;
+                    rawset_field(lua.state, -2, &k)?;
                }
                field_getters_index = Some(ffi::lua_absindex(lua.state, -1));
            }
@@ -357,11 +380,11 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
            let mut field_setters_index = None;
            let field_setters_nrec = ud_fields.field_setters.len();
            if field_setters_nrec > 0 {
-                ffi::safe::lua_createtable(lua.state, 0, field_setters_nrec as c_int)?;
+                push_table(lua.state, 0, field_setters_nrec as c_int)?;
                for (k, m) in ud_fields.field_setters {
                    let data = data.clone();
                    lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
-                    ffi::safe::lua_rawsetfield(lua.state, -2, &k)?;
+                    rawset_field(lua.state, -2, &k)?;
                }
                field_setters_index = Some(ffi::lua_absindex(lua.state, -1));
            }
@@ -370,16 +393,16 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
            let methods_nrec = ud_methods.methods.len();
            if methods_nrec > 0 {
                // Create table used for methods lookup
-                ffi::safe::lua_createtable(lua.state, 0, methods_nrec as c_int)?;
+                push_table(lua.state, 0, methods_nrec as c_int)?;
                for (k, m) in ud_methods.methods {
                    let data = data.clone();
                    lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
-                    ffi::safe::lua_rawsetfield(lua.state, -2, &k)?;
+                    rawset_field(lua.state, -2, &k)?;
                }
                methods_index = Some(ffi::lua_absindex(lua.state, -1));
            }

-            init_userdata_metatable::<()>(
+            init_userdata_metatable::<UserDataCell<Rc<RefCell<T>>>>(
                lua.state,
                metatable_index,
                field_getters_index,
@@ -392,10 +415,12 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                + methods_index.map(|_| 1).unwrap_or(0);
            ffi::lua_pop(lua.state, count);

-            let mt_id = ffi::lua_topointer(lua.state, -1);
+            let mt_ptr = ffi::lua_topointer(lua.state, -1);
+            // Write userdata just before attaching metatable with `__gc` metamethod
+            ptr::write(data_ptr as _, UserDataCell::new(data));
            ffi::lua_setmetatable(lua.state, -2);
            let ud = AnyUserData(lua.pop_ref());
-            lua.register_userdata_metatable(mt_id as isize);
+            lua.register_userdata_metatable(mt_ptr, None);

            #[cfg(any(feature = "lua51", feature = "luajit"))]
            let newtable = lua.create_table()?;
@@ -404,22 +429,33 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                let _sg = StackGuard::new(state);
                assert_stack(state, 2);

-                ud.lua.push_ref(&ud);
-
-                // We know the destructor has not run yet because we hold a reference to the userdata.
+                // Check that userdata is valid (very likely)
+                if ud.lua.push_userdata_ref(&ud).is_err() {
+                    return vec![];
+                }

                // Deregister metatable
                ffi::lua_getmetatable(state, -1);
-                let mt_id = ffi::lua_topointer(state, -1);
+                let mt_ptr = ffi::lua_topointer(state, -1);
                ffi::lua_pop(state, 1);
-                ud.lua.deregister_userdata_metatable(mt_id as isize);
+                ud.lua.deregister_userdata_metatable(mt_ptr);

-                // Clear uservalue
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                ffi::lua_pushnil(state);
+                // Clear associated user values
+                #[cfg(feature = "lua54")]
+                for i in 1..=USER_VALUE_MAXSLOT {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setiuservalue(state, -2, i as c_int);
+                }
+                #[cfg(any(feature = "lua53", feature = "lua52"))]
+                {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setuservalue(state, -2);
+                }
                #[cfg(any(feature = "lua51", feature = "luajit"))]
-                ud.lua.push_ref(&newtable.0);
-                ffi::lua_setuservalue(state, -2);
+                {
+                    ud.lua.push_ref(&newtable.0);
+                    ffi::lua_setuservalue(state, -2);
+                }

                // A hack to drop non-static `T`
                unsafe fn seal<T>(t: T) -> Box<dyn FnOnce() + 'static> {
@@ -427,7 +463,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                    mem::transmute(f)
                }

-                vec![Box::new(seal(take_userdata::<UserDataCell<T>>(state)))]
+                let ud = Box::new(seal(take_userdata::<UserDataCell<Rc<RefCell<T>>>>(state)));
+                vec![ud]
            });
            self.destructors
                .borrow_mut()
@@ -458,17 +495,12 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {

            // We know the destructor has not run yet because we hold a reference to the callback.

-            ffi::lua_getupvalue(state, -1, 2);
-            let ud1 = take_userdata::<Callback>(state);
+            ffi::lua_getupvalue(state, -1, 1);
+            let ud = take_userdata::<CallbackUpvalue>(state);
            ffi::lua_pushnil(state);
-            ffi::lua_setupvalue(state, -2, 2);
+            ffi::lua_setupvalue(state, -2, 1);

-            ffi::lua_getupvalue(state, -1, 3);
-            let ud2 = take_userdata::<Lua>(state);
-            ffi::lua_pushnil(state);
-            ffi::lua_setupvalue(state, -2, 3);
-
-            vec![Box::new(ud1), Box::new(ud2)]
+            vec![Box::new(ud)]
        });
        self.destructors
            .borrow_mut()
@@ -508,33 +540,22 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
            ffi::lua_rawget(state, -2);

            // Destroy all upvalues
-            ffi::lua_getupvalue(state, -1, 2);
-            let ud1 = take_userdata::<AsyncCallback>(state);
+            ffi::lua_getupvalue(state, -1, 1);
+            let upvalue1 = take_userdata::<AsyncCallbackUpvalue>(state);
            ffi::lua_pushnil(state);
-            ffi::lua_setupvalue(state, -2, 2);
-
-            ffi::lua_getupvalue(state, -1, 3);
-            let ud2 = take_userdata::<Lua>(state);
-            ffi::lua_pushnil(state);
-            ffi::lua_setupvalue(state, -2, 3);
+            ffi::lua_setupvalue(state, -2, 1);

            ffi::lua_pop(state, 1);
-            let mut data: Vec<Box<dyn Any>> = vec![Box::new(ud1), Box::new(ud2)];
+            let mut data: Vec<Box<dyn Any>> = vec![Box::new(upvalue1)];

            // Finally, get polled future and destroy it
            f.lua.push_ref(&poll_str.0);
            if ffi::lua_rawget(state, -2) == ffi::LUA_TFUNCTION {
-                ffi::lua_getupvalue(state, -1, 2);
-                let ud3 = take_userdata::<LocalBoxFuture<Result<MultiValue>>>(state);
+                ffi::lua_getupvalue(state, -1, 1);
+                let upvalue2 = take_userdata::<AsyncPollUpvalue>(state);
                ffi::lua_pushnil(state);
-                ffi::lua_setupvalue(state, -2, 2);
-                data.push(Box::new(ud3));
-
-                ffi::lua_getupvalue(state, -1, 3);
-                let ud4 = take_userdata::<Lua>(state);
-                ffi::lua_pushnil(state);
-                ffi::lua_setupvalue(state, -2, 3);
-                data.push(Box::new(ud4));
+                ffi::lua_setupvalue(state, -2, 1);
+                data.push(Box::new(upvalue2));
            }

            data
@@ -665,7 +686,6 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
    #[cfg(feature = "async")]
    fn add_async_function<S, A, R, F, FR>(&mut self, _name: &S, _function: F)
    where
-        T: Clone,
        S: AsRef<[u8]> + ?Sized,
        A: FromLuaMulti<'lua>,
        R: ToLuaMulti<'lua>,
@@ -707,6 +727,21 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
        ));
    }

+    #[cfg(all(feature = "async", not(feature = "lua51")))]
+    fn add_async_meta_method<S, A, R, M, MR>(&mut self, _meta: S, _method: M)
+    where
+        T: Clone,
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
+        MR: 'lua + Future<Output = Result<R>>,
+    {
+        // The panic should never happen as async non-static code wouldn't compile
+        // Non-static lifetime must be bounded to 'lua lifetime
+        mlua_panic!("asynchronous meta methods are not supported for non-static userdata")
+    }
+
    fn add_meta_function<S, A, R, F>(&mut self, meta: S, function: F)
    where
        S: Into<MetaMethod>,
@@ -736,6 +771,20 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
            })),
        ));
    }
+
+    #[cfg(all(feature = "async", not(feature = "lua51")))]
+    fn add_async_meta_function<S, A, R, F, FR>(&mut self, _meta: S, _function: F)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
+        FR: 'lua + Future<Output = Result<R>>,
+    {
+        // The panic should never happen as async non-static code wouldn't compile
+        // Non-static lifetime must be bounded to 'lua lifetime
+        mlua_panic!("asynchronous meta functions are not supported for non-static userdata")
+    }
 }

 struct NonStaticUserDataFields<'lua, T: UserData> {
@@ -1,19 +1,107 @@
+use std::cell::RefCell;
+use std::os::raw::c_void;
+use std::rc::Rc;
 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::ffi;
+use crate::table::{Table, TablePairs, TableSequence};
 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 [`Thread`], [`UserData`], [`LightUserData`]
+    /// and [`Error`] will cause an error.
+    /// Otherwise these types skipped when iterating or serialized as unit type.
+    ///
+    /// Default: **true**
+    ///
+    /// [`Thread`]: crate::Thread
+    /// [`UserData`]: crate::UserData
+    /// [`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,
+}
+
+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,
+        }
+    }
+
+    /// 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 fn deny_recursive_tables(mut self, enabled: bool) -> Self {
+        self.deny_recursive_tables = 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,7 +113,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_unit(),
            Value::Boolean(b) => visitor.visit_bool(b),
            #[allow(clippy::useless_conversion)]
@@ -43,7 +131,16 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
            | Value::Thread(_)
            | Value::UserData(_)
            | Value::LightUserData(_)
-            | Value::Error(_) => Err(de::Error::custom("invalid value type")),
+            | Value::Error(_) => {
+                if self.options.deny_unsupported_types {
+                    Err(de::Error::custom(format!(
+                        "unsupported value type `{}`",
+                        self.value.type_name()
+                    )))
+                } else {
+                    visitor.visit_unit()
+                }
+            }
        }
    }

@@ -52,7 +149,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),
@@ -69,9 +166,11 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    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 +187,22 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                        &"map with a single key",
                    ));
                }
-                (variant, Some(value))
+                if check_value_if_skip(&value, self.options, &self.visited)? {
+                    return Err(de::Error::custom("bad enum value"));
+                }
+
+                (variant, Some(value), Some(_guard))
            }
-            Value::String(variant) => (variant.to_str()?.to_owned(), None),
+            Value::String(variant) => (variant.to_str()?.to_owned(), None, 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 +210,18 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    where
        V: de::Visitor<'de>,
    {
-        match self.0 {
+        match self.value {
            Value::Table(t) => {
+                let _guard = RecursionGuard::new(&t, &self.visited);
+
                let len = t.raw_len() as usize;
-                let mut deserializer = SeqDeserializer(t.raw_sequence_values());
+                let mut deserializer = SeqDeserializer {
+                    seq: t.raw_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 +230,10 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                    ))
                }
            }
-            _ => Err(de::Error::custom("invalid value type")),
+            value => Err(de::Error::invalid_type(
+                de::Unexpected::Other(value.type_name()),
+                &"table",
+            )),
        }
    }

@@ -146,9 +263,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: t.pairs(),
+                    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 +285,10 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                    ))
                }
            }
-            _ => Err(de::Error::custom("invalid value type")),
+            value => Err(de::Error::invalid_type(
+                de::Unexpected::Other(value.type_name()),
+                &"table",
+            )),
        }
    }

@@ -178,13 +306,17 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    }

    serde::forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes
        byte_buf unit unit_struct newtype_struct
        identifier ignored_any
    }
 }

-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,14 +325,24 @@ 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?;
+                    if check_value_if_skip(&value, self.options, &self.visited)? {
+                        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,
        }
@@ -210,19 +352,11 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
 struct MapDeserializer<'lua> {
    pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>,
    value: Option<Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
    processed: usize,
 }

-impl<'lua> MapDeserializer<'lua> {
-    fn new(pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>) -> Self {
-        MapDeserializer {
-            pairs,
-            value: None,
-            processed: 0,
-        }
-    }
-}
-
 impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
    type Error = Error;

@@ -230,15 +364,23 @@ 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?;
+                    if check_value_if_skip(&key, self.options, &self.visited)?
+                        || check_value_if_skip(&value, self.options, &self.visited)?
+                    {
+                        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 +389,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 +408,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 +421,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 +454,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 +469,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 +485,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 +496,60 @@ 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 lua = table.0.lua;
+        let ptr =
+            unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+        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
+fn check_value_if_skip(
+    value: &Value,
+    options: Options,
+    visited: &RefCell<FxHashSet<*const c_void>>,
+) -> Result<bool> {
+    match value {
+        Value::Table(table) => {
+            let lua = table.0.lua;
+            let ptr =
+                unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+            if visited.borrow().contains(&ptr) {
+                if options.deny_recursive_tables {
+                    return Err(de::Error::custom("recursive table detected"));
+                }
+                return Ok(true); // skip
+            }
+        }
+        Value::Function(_)
+        | Value::Thread(_)
+        | Value::UserData(_)
+        | Value::LightUserData(_)
+        | Value::Error(_)
+            if !options.deny_unsupported_types =>
+        {
+            return Ok(true); // skip
+        }
+        _ => {}
+    }
+    Ok(false) // do not skip
+}
@@ -69,11 +69,11 @@ pub trait LuaSerdeExt<'lua> {
    /// ```
    fn array_metatable(&'lua self) -> Table<'lua>;

-    /// Converts `T` into a `Value` instance.
+    /// Converts `T` into a [`Value`] instance.
    ///
    /// Requires `feature = "serialize"`
    ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
    ///
    /// # Example
    ///
@@ -102,11 +102,11 @@ pub trait LuaSerdeExt<'lua> {
    /// ```
    fn to_value<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
    ///
@@ -129,11 +129,11 @@ pub trait LuaSerdeExt<'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
    ///
@@ -158,6 +158,41 @@ pub trait LuaSerdeExt<'lua> {
    /// }
    /// ```
    fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> 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(())
+    /// }
+    /// ```
+    fn from_value_with<T: Deserialize<'lua>>(
+        &'lua self,
+        value: Value<'lua>,
+        options: de::Options,
+    ) -> Result<T>;
 }

 impl<'lua> LuaSerdeExt<'lua> for Lua {
@@ -196,19 +231,28 @@ impl<'lua> LuaSerdeExt<'lua> for Lua {
    {
        T::deserialize(de::Deserializer::new(value))
    }
+
+    fn from_value_with<T>(&'lua self, value: Value<'lua>, options: de::Options) -> Result<T>
+    where
+        T: Deserialize<'lua>,
+    {
+        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) {
@@ -28,16 +28,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 +45,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 +78,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 +87,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
    }
@@ -139,6 +142,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);
@@ -318,12 +323,14 @@ impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
        let value = lua.to_value_with(value, self.options)?;
        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 6)?;
+            check_stack(lua.state, 4)?;

            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)
+            protect_lua!(lua.state, 2, 0, fn(state) {
+                let len = ffi::lua_rawlen(state, -2) as Integer;
+                ffi::lua_rawseti(state, -2, len + 1);
+            })
        }
    }

@@ -6,32 +6,32 @@ 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))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
    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
    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))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    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))]
    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);
    /// [`jit`](http://luajit.org/ext_jit.html) library
    ///
@@ -44,7 +44,7 @@ impl StdLib {
    /// Requires `feature = "luajit"`
    #[cfg(any(feature = "luajit", doc))]
    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
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+use std::string::String as StdString;
 use std::{slice, str};

 #[cfg(feature = "serialize")]
@@ -44,6 +46,28 @@ impl<'lua> String<'lua> {
        })
    }

+    /// Converts this string to a [`Cow<str>`].
+    ///
+    /// Any non-Unicode sequences are replaced with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].
+    ///
+    /// [U+FFFD]: std::char::REPLACEMENT_CHARACTER
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result};
+    /// # fn main() -> Result<()> {
+    /// let lua = Lua::new();
+    ///
+    /// let s = lua.create_string(b"test\xff")?;
+    /// assert_eq!(s.to_string_lossy(), "test\u{fffd}");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn to_string_lossy(&self) -> Cow<'_, str> {
+        StdString::from_utf8_lossy(self.as_bytes())
+    }
+
    /// Get the bytes that make up this string.
    ///
    /// The returned slice will not contain the terminating nul byte, but will contain any nul
@@ -2,8 +2,9 @@ use std::marker::PhantomData;

 #[cfg(feature = "serialize")]
 use {
-    serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer},
-    std::result::Result as StdResult,
+    rustc_hash::FxHashSet,
+    serde::ser::{self, Serialize, SerializeMap, SerializeSeq, Serializer},
+    std::{cell::RefCell, os::raw::c_void, result::Result as StdResult},
 };

 use crate::error::{Error, Result};
@@ -62,12 +63,12 @@ impl<'lua> Table<'lua> {

        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 6)?;
+            check_stack(lua.state, 5)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
            lua.push_value(value)?;
-            ffi::safe::lua_settable(lua.state, -3)
+            protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_settable(state, -3))
        }
    }

@@ -101,11 +102,11 @@ impl<'lua> Table<'lua> {

        let value = unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            check_stack(lua.state, 4)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
-            ffi::safe::lua_gettable(lua.state, -2)?;
+            protect_lua!(lua.state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;

            lua.pop_value()
        };
@@ -119,12 +120,11 @@ impl<'lua> Table<'lua> {

        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            check_stack(lua.state, 4)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
-            ffi::safe::lua_gettable(lua.state, -2)?;
-
+            protect_lua!(lua.state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;
            Ok(ffi::lua_isnil(lua.state, -1) == 0)
        }
    }
@@ -193,12 +193,12 @@ impl<'lua> Table<'lua> {

        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 6)?;
+            check_stack(lua.state, 5)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
            lua.push_value(value)?;
-            ffi::safe::lua_rawset(lua.state, -3)
+            protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_rawset(state, -3))
        }
    }

@@ -232,11 +232,18 @@ impl<'lua> Table<'lua> {
        let value = value.to_lua(lua)?;
        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 6)?;
+            check_stack(lua.state, 5)?;

            lua.push_ref(&self.0);
            lua.push_value(value)?;
-            ffi::safe::lua_rawinsert(lua.state, -2, idx)
+            protect_lua!(lua.state, 2, 0, |state| {
+                for i in (idx..=size).rev() {
+                    // table[i+1] = table[i]
+                    ffi::lua_rawgeti(state, -2, i);
+                    ffi::lua_rawseti(state, -3, i + 1);
+                }
+                ffi::lua_rawseti(state, -2, idx)
+            })
        }
    }

@@ -258,10 +265,17 @@ impl<'lua> Table<'lua> {
                }
                unsafe {
                    let _sg = StackGuard::new(lua.state);
-                    check_stack(lua.state, 5)?;
+                    check_stack(lua.state, 4)?;

                    lua.push_ref(&self.0);
-                    ffi::safe::lua_rawremove(lua.state, -1, idx)
+                    protect_lua!(lua.state, 1, 0, |state| {
+                        for i in idx..size {
+                            ffi::lua_rawgeti(state, -1, i + 1);
+                            ffi::lua_rawseti(state, -2, i);
+                        }
+                        ffi::lua_pushnil(state);
+                        ffi::lua_rawseti(state, -2, size);
+                    })
                }
            }
            _ => self.raw_set(key, Nil),
@@ -280,7 +294,7 @@ impl<'lua> Table<'lua> {
            check_stack(lua.state, 4)?;

            lua.push_ref(&self.0);
-            ffi::safe::luaL_len(lua.state, -1)
+            protect_lua!(lua.state, 1, 0, |state| ffi::luaL_len(state, -1))
        }
    }

@@ -365,8 +379,8 @@ impl<'lua> Table<'lua> {
    /// # }
    /// ```
    ///
-    /// [`Result`]: type.Result.html
-    /// [Lua manual]: http://www.lua.org/manual/5.3/manual.html#pdf-next
+    /// [`Result`]: crate::Result
+    /// [Lua manual]: http://www.lua.org/manual/5.4/manual.html#pdf-next
    pub fn pairs<K: FromLua<'lua>, V: FromLua<'lua>>(self) -> TablePairs<'lua, K, V> {
        TablePairs {
            table: self.0,
@@ -414,8 +428,8 @@ impl<'lua> Table<'lua> {
    /// ```
    ///
    /// [`pairs`]: #method.pairs
-    /// [`Result`]: type.Result.html
-    /// [Lua manual]: http://www.lua.org/manual/5.3/manual.html#pdf-next
+    /// [`Result`]: crate::Result
+    /// [Lua manual]: http://www.lua.org/manual/5.4/manual.html#pdf-next
    pub fn sequence_values<V: FromLua<'lua>>(self) -> TableSequence<'lua, V> {
        TableSequence {
            table: self.0,
@@ -488,6 +502,25 @@ impl<'lua> AsRef<Table<'lua>> for Table<'lua> {

 /// An extension trait for `Table`s that provides a variety of convenient functionality.
 pub trait TableExt<'lua> {
+    /// Calls the table as function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the table as its first argument, followed by the passed arguments.
+    fn call<A, R>(&self, args: A) -> Result<R>
+    where
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua>;
+
+    /// Asynchronously calls the table as function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the table as its first argument, followed by the passed arguments.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut;
+
    /// Gets the function associated to `key` from the table and executes it,
    /// passing the table itself along with `args` as function arguments.
    ///
@@ -550,6 +583,25 @@ pub trait TableExt<'lua> {
 }

 impl<'lua> TableExt<'lua> for Table<'lua> {
+    fn call<A, R>(&self, args: A) -> Result<R>
+    where
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua>,
+    {
+        // Convert table to a function and call via pcall that respects the `__call` metamethod.
+        Function(self.0.clone()).call(args)
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut,
+    {
+        Function(self.0.clone()).call_async(args)
+    }
+
    fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
    where
        K: ToLua<'lua>,
@@ -609,22 +661,42 @@ impl<'lua> Serialize for Table<'lua> {
    where
        S: Serializer,
    {
-        let len = self.raw_len() as usize;
-        if len > 0 || self.is_array() {
-            let mut seq = serializer.serialize_seq(Some(len))?;
-            for v in self.clone().raw_sequence_values_by_len::<Value>(None) {
-                let v = v.map_err(serde::ser::Error::custom)?;
-                seq.serialize_element(&v)?;
-            }
-            return seq.end();
+        thread_local! {
+            static VISITED: RefCell<FxHashSet<*const c_void>> = RefCell::new(FxHashSet::default());
        }

-        let mut map = serializer.serialize_map(None)?;
-        for kv in self.clone().pairs::<Value, Value>() {
-            let (k, v) = kv.map_err(serde::ser::Error::custom)?;
-            map.serialize_entry(&k, &v)?;
-        }
-        map.end()
+        let lua = self.0.lua;
+        let ptr = unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) };
+        let res = VISITED.with(|visited| {
+            {
+                let mut visited = visited.borrow_mut();
+                if visited.contains(&ptr) {
+                    return Err(ser::Error::custom("recursive table detected"));
+                }
+                visited.insert(ptr);
+            }
+
+            let len = self.raw_len() as usize;
+            if len > 0 || self.is_array() {
+                let mut seq = serializer.serialize_seq(Some(len))?;
+                for v in self.clone().raw_sequence_values_by_len::<Value>(None) {
+                    let v = v.map_err(serde::ser::Error::custom)?;
+                    seq.serialize_element(&v)?;
+                }
+                return seq.end();
+            }
+
+            let mut map = serializer.serialize_map(None)?;
+            for kv in self.clone().pairs::<Value, Value>() {
+                let (k, v) = kv.map_err(serde::ser::Error::custom)?;
+                map.serialize_entry(&k, &v)?;
+            }
+            map.end()
+        });
+        VISITED.with(|visited| {
+            visited.borrow_mut().remove(&ptr);
+        });
+        res
    }
 }

@@ -632,7 +704,7 @@ impl<'lua> Serialize for Table<'lua> {
 ///
 /// This struct is created by the [`Table::pairs`] method.
 ///
-/// [`Table::pairs`]: struct.Table.html#method.pairs
+/// [`Table::pairs`]: crate::Table::pairs
 pub struct TablePairs<'lua, K, V> {
    table: LuaRef<'lua>,
    key: Option<Value<'lua>>,
@@ -657,7 +729,10 @@ where
                lua.push_ref(&self.table);
                lua.push_value(prev_key)?;

-                if ffi::safe::lua_next(lua.state, -2)? != 0 {
+                let next = protect_lua!(lua.state, 2, ffi::LUA_MULTRET, |state| {
+                    ffi::lua_next(state, -2)
+                })?;
+                if next != 0 {
                    let value = lua.pop_value();
                    let key = lua.pop_value();
                    Ok(Some((
@@ -688,7 +763,7 @@ where
 ///
 /// This struct is created by the [`Table::sequence_values`] method.
 ///
-/// [`Table::sequence_values`]: struct.Table.html#method.sequence_values
+/// [`Table::sequence_values`]: crate::Table::sequence_values
 pub struct TableSequence<'lua, V> {
    table: LuaRef<'lua>,
    index: Option<Integer>,
@@ -709,13 +784,13 @@ where

            let res = (|| unsafe {
                let _sg = StackGuard::new(lua.state);
-                check_stack(lua.state, 1 + if self.raw { 0 } else { 4 })?;
+                check_stack(lua.state, 1 + if self.raw { 0 } else { 3 })?;

                lua.push_ref(&self.table);
                let res = if self.raw {
                    ffi::lua_rawgeti(lua.state, -1, index)
                } else {
-                    ffi::safe::lua_geti(lua.state, -1, index)?
+                    protect_lua!(lua.state, 1, 1, |state| ffi::lua_geti(state, -1, index))?
                };
                match res {
                    ffi::LUA_TNIL if index > self.len.unwrap_or(0) => Ok(None),
@@ -4,24 +4,22 @@ use std::os::raw::c_int;
 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::util::{check_stack, error_traceback, pop_error, StackGuard};
+use crate::value::{FromLuaMulti, ToLuaMulti};

-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored"), doc))]
+#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
 use crate::function::Function;

 #[cfg(feature = "async")]
 use {
    crate::{
-        lua::{ASYNC_POLL_PENDING, WAKER_REGISTRY_KEY},
-        util::get_gc_userdata,
-        value::Value,
+        lua::{Lua, ASYNC_POLL_PENDING},
+        value::{MultiValue, Value},
    },
    futures_core::{future::Future, stream::Stream},
    std::{
        cell::RefCell,
        marker::PhantomData,
-        mem,
        os::raw::c_void,
        pin::Pin,
        task::{Context, Poll, Waker},
@@ -35,7 +33,7 @@ pub enum ThreadStatus {
    ///
    /// 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,
@@ -51,8 +49,8 @@ pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
 ///
 /// Requires `feature = "async"`
 ///
-/// [`Future`]: ../futures_core/future/trait.Future.html
-/// [`Stream`]: ../futures_core/stream/trait.Stream.html
+/// [`Future`]: futures_core::future::Future
+/// [`Stream`]: futures_core::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
 #[derive(Debug)]
@@ -60,6 +58,7 @@ pub struct AsyncThread<'lua, R> {
    thread: Thread<'lua>,
    args0: RefCell<Option<Result<MultiValue<'lua>>>>,
    ret: PhantomData<R>,
+    recycle: bool,
 }

 impl<'lua> Thread<'lua> {
@@ -110,15 +109,14 @@ impl<'lua> Thread<'lua> {
        R: FromLuaMulti<'lua>,
    {
        let lua = self.0.lua;
-        let args = args.to_lua_multi(lua)?;
+        let mut args = args.to_lua_multi(lua)?;
        let nargs = args.len() as c_int;
        let results = unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, cmp::min(nargs + 1, 3))?;
+            check_stack(lua.state, cmp::max(nargs + 1, 3))?;

-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-            ffi::lua_pop(lua.state, 1);
+            let thread_state =
+                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));

            let status = ffi::lua_status(thread_state);
            if status != ffi::LUA_YIELD && ffi::lua_gettop(thread_state) == 0 {
@@ -126,7 +124,7 @@ impl<'lua> Thread<'lua> {
            }

            check_stack(thread_state, nargs)?;
-            for arg in args {
+            for arg in args.drain_all() {
                lua.push_value(arg)?;
            }
            ffi::lua_xmove(lua.state, thread_state, nargs);
@@ -135,11 +133,11 @@ impl<'lua> Thread<'lua> {

            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)?;
+                protect_lua!(lua.state, 0, 0, |_| error_traceback(thread_state))?;
                return Err(pop_error(thread_state, ret));
            }

-            let mut results = MultiValue::new();
+            let mut results = args; // Reuse MultiValue container
            check_stack(lua.state, nresults + 2)?; // 2 is extra for `lua.pop_value()` below
            ffi::lua_xmove(thread_state, lua.state, nresults);

@@ -155,12 +153,8 @@ impl<'lua> Thread<'lua> {
    pub fn status(&self) -> ThreadStatus {
        let lua = self.0.lua;
        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 thread_state =
+                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));

            let status = ffi::lua_status(thread_state);
            if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
@@ -188,7 +182,7 @@ impl<'lua> Thread<'lua> {
    ///
    /// [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))]
+    #[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
    pub fn reset(&self, func: Function<'lua>) -> Result<()> {
        let lua = self.0.lua;
        unsafe {
@@ -210,10 +204,10 @@ impl<'lua> Thread<'lua> {
        }
    }

-    /// Converts Thread to an AsyncThread which implements Future and Stream traits.
+    /// Converts Thread to an AsyncThread which implements [`Future`] and [`Stream`] traits.
    ///
    /// `args` are passed as arguments to the thread function for first call.
-    /// The object 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 +216,10 @@ impl<'lua> Thread<'lua> {
    ///
    /// Requires `feature = "async"`
    ///
+    /// [`Future`]: futures_core::future::Future
+    /// [`Stream`]: futures_core::stream::Stream
+    /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    ///
    /// # Examples
    ///
    /// ```
@@ -258,11 +256,12 @@ impl<'lua> Thread<'lua> {
        A: ToLuaMulti<'lua>,
        R: FromLuaMulti<'lua>,
    {
-        let args = args.to_lua_multi(&self.0.lua);
+        let args = args.to_lua_multi(self.0.lua);
        AsyncThread {
            thread: self,
            args0: RefCell::new(Some(args)),
            ret: PhantomData,
+            recycle: false,
        }
    }
 }
@@ -273,6 +272,24 @@ impl<'lua> PartialEq for Thread<'lua> {
    }
 }

+#[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", all(feature = "luajit", feature = "vendored")))]
+impl<'lua, R> Drop for AsyncThread<'lua, R> {
+    fn drop(&mut self) {
+        if self.recycle {
+            self.thread.0.lua.recycle_thread(&mut self.thread);
+        }
+    }
+}
+
 #[cfg(feature = "async")]
 impl<'lua, R> Stream for AsyncThread<'lua, R>
 where
@@ -288,7 +305,7 @@ where
            _ => return Poll::Ready(None),
        };

-        let _wg = WakerGuard::new(lua.state, cx.waker().clone());
+        let _wg = WakerGuard::new(lua, cx.waker().clone());
        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
            self.thread.resume(args?)?
        } else {
@@ -319,7 +336,7 @@ where
            _ => return Poll::Ready(Err(Error::CoroutineInactive)),
        };

-        let _wg = WakerGuard::new(lua.state, cx.waker().clone());
+        let _wg = WakerGuard::new(lua, cx.waker().clone());
        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
            self.thread.resume(args?)?
        } else {
@@ -341,9 +358,10 @@ where
 }

 #[cfg(feature = "async")]
+#[inline(always)]
 fn is_poll_pending(val: &MultiValue) -> bool {
    match val.iter().enumerate().last() {
-        Some((1, Value::LightUserData(ud))) => {
+        Some((0, Value::LightUserData(ud))) => {
            ud.0 == &ASYNC_POLL_PENDING as *const u8 as *mut c_void
        }
        _ => false,
@@ -351,37 +369,27 @@ fn is_poll_pending(val: &MultiValue) -> bool {
 }

 #[cfg(feature = "async")]
-struct WakerGuard(*mut ffi::lua_State, Option<Waker>);
+struct WakerGuard<'lua> {
+    lua: &'lua Lua,
+    prev: Option<Waker>,
+}

 #[cfg(feature = "async")]
-impl WakerGuard {
-    pub fn new(state: *mut ffi::lua_State, waker: Waker) -> Result<WakerGuard> {
+impl<'lua> WakerGuard<'lua> {
+    #[inline]
+    pub fn new(lua: &Lua, waker: Waker) -> Result<WakerGuard> {
        unsafe {
-            let _sg = StackGuard::new(state);
-            check_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();
-            let old = mlua_expect!(waker_slot, "Waker is destroyed").replace(waker);
-
-            Ok(WakerGuard(state, old))
+            let prev = lua.set_waker(Some(waker));
+            Ok(WakerGuard { lua, prev })
        }
    }
 }

 #[cfg(feature = "async")]
-impl Drop for WakerGuard {
+impl<'lua> Drop for WakerGuard<'lua> {
    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);
+            self.lua.set_waker(self.prev.take());
        }
    }
 }
@@ -1,8 +1,11 @@
-use std::cell::RefCell;
+use std::hash::{Hash, Hasher};
 use std::os::raw::{c_int, c_void};
 use std::sync::{Arc, Mutex};
 use std::{fmt, mem, ptr};

+#[cfg(feature = "lua54")]
+use std::ffi::CStr;
+
 #[cfg(feature = "async")]
 use futures_core::future::LocalBoxFuture;

@@ -25,11 +28,38 @@ pub struct LightUserData(pub *mut c_void);
 pub(crate) type Callback<'lua, 'a> =
    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> Result<MultiValue<'lua>> + 'a>;

+pub(crate) struct CallbackUpvalue<'lua> {
+    pub(crate) lua: Lua,
+    pub(crate) func: Callback<'lua, 'static>,
+}
+
 #[cfg(feature = "async")]
 pub(crate) type AsyncCallback<'lua, 'a> =
    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> LocalBoxFuture<'lua, Result<MultiValue<'lua>>> + 'a>;

-pub(crate) type HookCallback = Arc<RefCell<dyn FnMut(&Lua, Debug) -> Result<()>>>;
+#[cfg(feature = "async")]
+pub(crate) struct AsyncCallbackUpvalue<'lua> {
+    pub(crate) lua: Lua,
+    pub(crate) func: AsyncCallback<'lua, 'static>,
+}
+
+#[cfg(feature = "async")]
+pub(crate) struct AsyncPollUpvalue<'lua> {
+    pub(crate) lua: Lua,
+    pub(crate) fut: LocalBoxFuture<'lua, Result<MultiValue<'lua>>>,
+}
+
+#[cfg(feature = "send")]
+pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()> + Send>>;
+
+#[cfg(not(feature = "send"))]
+pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()>>>;
+
+#[cfg(all(feature = "send", feature = "lua54"))]
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()> + Send>;
+
+#[cfg(all(not(feature = "send"), feature = "lua54"))]
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()>>;

 #[cfg(feature = "send")]
 pub trait MaybeSend: Send {}
@@ -41,21 +71,25 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}

+pub(crate) struct DestructedUserdataMT;
+
 /// 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::get_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::get_user_value`]: crate::AnyUserData::get_user_value
 pub struct RegistryKey {
    pub(crate) registry_id: c_int,
    pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
@@ -67,6 +101,20 @@ 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");
@@ -107,7 +155,9 @@ impl<'lua> Clone for LuaRef<'lua> {

 impl<'lua> Drop for LuaRef<'lua> {
    fn drop(&mut self) {
-        self.lua.drop_ref(self)
+        if self.index > 0 {
+            self.lua.drop_ref(self);
+        }
    }
 }

@@ -117,8 +167,8 @@ impl<'lua> PartialEq for LuaRef<'lua> {
        unsafe {
            let _sg = StackGuard::new(lua.state);
            assert_stack(lua.state, 2);
-            lua.push_ref(&self);
-            lua.push_ref(&other);
+            lua.push_ref(self);
+            lua.push_ref(other);
            ffi::lua_rawequal(lua.state, -1, -2) == 1
        }
    }
@@ -1,9 +1,10 @@
+use std::any::TypeId;
 use std::cell::{Ref, RefCell, RefMut};
 use std::fmt;
 use std::hash::{Hash, Hasher};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
+use std::os::raw::{c_char, c_int};
 use std::string::String as StdString;
-use std::sync::Arc;

 #[cfg(feature = "async")]
 use std::future::Future;
@@ -19,19 +20,22 @@ use crate::ffi;
 use crate::function::Function;
 use crate::lua::Lua;
 use crate::table::{Table, TablePairs};
-use crate::types::{LuaRef, MaybeSend};
-use crate::util::{check_stack, get_destructed_userdata_metatable, get_userdata, StackGuard};
+use crate::types::{Callback, LuaRef, MaybeSend};
+use crate::util::{check_stack, get_userdata, take_userdata, StackGuard};
 use crate::value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti};

-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-use crate::value::Value;
+#[cfg(feature = "async")]
+use crate::types::AsyncCallback;
+
+#[cfg(feature = "lua54")]
+pub(crate) const USER_VALUE_MAXSLOT: usize = 8;

 /// Kinds of metamethods that can be overridden.
 ///
 /// Currently, this mechanism does not allow overriding the `__gc` metamethod, since there is
 /// generally no need to do so: [`UserData`] implementors can instead just implement `Drop`.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 #[derive(Debug, Clone)]
 pub enum MetaMethod {
    /// The `+` operator.
@@ -50,29 +54,29 @@ pub enum MetaMethod {
    Unm,
    /// The floor division (//) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    IDiv,
    /// The bitwise AND (&) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BAnd,
    /// The bitwise OR (|) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BOr,
    /// The bitwise XOR (binary ~) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BXor,
    /// The bitwise NOT (unary ~) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BNot,
    /// The bitwise left shift (<<) operator.
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    Shl,
    /// The bitwise right shift (>>) operator.
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    Shr,
    /// The string concatenation operator `..`.
    Concat,
@@ -99,8 +103,22 @@ pub enum MetaMethod {
    /// This is not an operator, but it will be called by the built-in `pairs` function.
    ///
    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52",
+    ))]
    Pairs,
+    /// The `__ipairs` metamethod.
+    ///
+    /// This is not an operator, but it will be called by the built-in [`ipairs`] function.
+    ///
+    /// Requires `feature = "lua52"`
+    ///
+    /// [`ipairs`]: https://www.lua.org/manual/5.2/manual.html#pdf-ipairs
+    #[cfg(any(feature = "lua52", feature = "luajit52", doc))]
+    IPairs,
    /// The `__close` metamethod.
    ///
    /// Executed when a variable, that marked as to-be-closed, goes out of scope.
@@ -111,7 +129,7 @@ pub enum MetaMethod {
    /// Requires `feature = "lua54"`
    ///
    /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#3.3.8
-    #[cfg(any(feature = "lua54", doc))]
+    #[cfg(any(feature = "lua54"))]
    Close,
    /// A custom metamethod.
    ///
@@ -176,8 +194,15 @@ impl MetaMethod {
            MetaMethod::Call => "__call",
            MetaMethod::ToString => "__tostring",

-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "luajit52"
+            ))]
            MetaMethod::Pairs => "__pairs",
+            #[cfg(any(feature = "lua52", feature = "luajit52"))]
+            MetaMethod::IPairs => "__ipairs",

            #[cfg(feature = "lua54")]
            MetaMethod::Close => "__close",
@@ -236,8 +261,15 @@ impl From<StdString> for MetaMethod {
            "__call" => MetaMethod::Call,
            "__tostring" => MetaMethod::ToString,

-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "luajit52"
+            ))]
            "__pairs" => MetaMethod::Pairs,
+            #[cfg(any(feature = "lua52", feature = "luajit52"))]
+            "__ipairs" => MetaMethod::IPairs,

            #[cfg(feature = "lua54")]
            "__close" => MetaMethod::Close,
@@ -255,7 +287,7 @@ impl From<&str> for MetaMethod {

 /// Method registry for [`UserData`] implementors.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 pub trait UserDataMethods<'lua, T: UserData> {
    /// Add a regular method which accepts a `&T` as the first parameter.
    ///
@@ -309,7 +341,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
    ///
    /// Prefer to use [`add_method`] or [`add_method_mut`] as they are easier to use.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
    /// [`add_method`]: #method.add_method
    /// [`add_method_mut`]: #method.add_method_mut
    fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
@@ -343,7 +375,6 @@ pub trait UserDataMethods<'lua, T: UserData> {
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
    fn add_async_function<S, A, R, F, FR>(&mut self, name: &S, function: F)
    where
-        T: Clone,
        S: AsRef<[u8]> + ?Sized,
        A: FromLuaMulti<'lua>,
        R: ToLuaMulti<'lua>,
@@ -380,6 +411,25 @@ pub trait UserDataMethods<'lua, T: UserData> {
        R: ToLuaMulti<'lua>,
        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>;

+    /// Add an async metamethod which accepts a `T` as the first parameter and returns Future.
+    /// The passed `T` is cloned from the original value.
+    ///
+    /// This is an async version of [`add_meta_method`].
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`add_meta_method`]: #method.add_meta_method
+    #[cfg(all(feature = "async", not(feature = "lua51")))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn add_async_meta_method<S, A, R, M, MR>(&mut self, name: S, method: M)
+    where
+        T: Clone,
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
+        MR: 'lua + Future<Output = Result<R>>;
+
    /// Add a metamethod which accepts generic arguments.
    ///
    /// Metamethods for binary operators can be triggered if either the left or right argument to
@@ -403,11 +453,51 @@ pub trait UserDataMethods<'lua, T: UserData> {
        A: FromLuaMulti<'lua>,
        R: ToLuaMulti<'lua>,
        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>;
+
+    /// Add a metamethod which accepts generic arguments and returns Future.
+    ///
+    /// This is an async version of [`add_meta_function`].
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`add_meta_function`]: #method.add_meta_function
+    #[cfg(all(feature = "async", not(feature = "lua51")))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn add_async_meta_function<S, A, R, F, FR>(&mut self, name: S, function: F)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
+        FR: 'lua + Future<Output = Result<R>>;
+
+    //
+    // Below are internal methods used in generated code
+    //
+
+    #[doc(hidden)]
+    fn add_callback(&mut self, _name: Vec<u8>, _callback: Callback<'lua, 'static>) {}
+
+    #[doc(hidden)]
+    #[cfg(feature = "async")]
+    fn add_async_callback(&mut self, _name: Vec<u8>, _callback: AsyncCallback<'lua, 'static>) {}
+
+    #[doc(hidden)]
+    fn add_meta_callback(&mut self, _meta: MetaMethod, _callback: Callback<'lua, 'static>) {}
+
+    #[doc(hidden)]
+    #[cfg(feature = "async")]
+    fn add_async_meta_callback(
+        &mut self,
+        _meta: MetaMethod,
+        _callback: AsyncCallback<'lua, 'static>,
+    ) {
+    }
 }

 /// Field registry for [`UserData`] implementors.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 pub trait UserDataFields<'lua, T: UserData> {
    /// Add a regular field getter as a method which accepts a `&T` as the parameter.
    ///
@@ -440,7 +530,7 @@ pub trait UserDataFields<'lua, T: UserData> {
    ///
    /// Prefer to use [`add_field_method_get`] as it is easier to use.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
    /// [`add_field_method_get`]: #method.add_field_method_get
    fn add_field_function_get<S, R, F>(&mut self, name: &S, function: F)
    where
@@ -453,7 +543,7 @@ pub trait UserDataFields<'lua, T: UserData> {
    ///
    /// Prefer to use [`add_field_method_set`] as it is easier to use.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
    /// [`add_field_method_set`]: #method.add_field_method_set
    fn add_field_function_set<S, A, F>(&mut self, name: &S, function: F)
    where
@@ -474,12 +564,24 @@ pub trait UserDataFields<'lua, T: UserData> {
        S: Into<MetaMethod>,
        F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>,
        R: ToLua<'lua>;
+
+    //
+    // Below are internal methods used in generated code
+    //
+
+    #[doc(hidden)]
+    fn add_field_getter(&mut self, _name: Vec<u8>, _callback: Callback<'lua, 'static>) {}
+
+    #[doc(hidden)]
+    fn add_field_setter(&mut self, _name: Vec<u8>, _callback: Callback<'lua, 'static>) {}
 }

 /// Trait for custom userdata types.
 ///
-/// By implementing this trait, a struct becomes eligible for use inside Lua code. Implementations
-/// of [`ToLua`] and [`FromLua`] are automatically provided.
+/// By implementing this trait, a struct becomes eligible for use inside Lua code.
+/// Implementation of [`ToLua`] is automatically provided, [`FromLua`] is implemented
+/// only for `T: UserData + Clone`.
+///
 ///
 /// # Examples
 ///
@@ -537,10 +639,10 @@ pub trait UserDataFields<'lua, T: UserData> {
 /// # }
 /// ```
 ///
-/// [`ToLua`]: trait.ToLua.html
-/// [`FromLua`]: trait.FromLua.html
-/// [`UserDataFields`]: trait.UserDataFields.html
-/// [`UserDataMethods`]: trait.UserDataMethods.html
+/// [`ToLua`]: crate::ToLua
+/// [`FromLua`]: crate::FromLua
+/// [`UserDataFields`]: crate::UserDataFields
+/// [`UserDataMethods`]: crate::UserDataMethods
 pub trait UserData: Sized {
    /// Adds custom fields specific to this userdata.
    fn add_fields<'lua, F: UserDataFields<'lua, Self>>(_fields: &mut F) {}
@@ -550,93 +652,109 @@ pub trait UserData: Sized {
 }

 // Wraps UserData in a way to always implement `serde::Serialize` trait.
-pub(crate) enum UserDataCell<T> {
-    Arc(Arc<RefCell<UserDataWrapped<T>>>),
-    Plain(RefCell<UserDataWrapped<T>>),
-}
+pub(crate) struct UserDataCell<T>(RefCell<UserDataWrapped<T>>);

 impl<T> UserDataCell<T> {
+    #[inline]
    pub(crate) fn new(data: T) -> Self {
-        UserDataCell::Plain(RefCell::new(UserDataWrapped {
-            data: Box::into_raw(Box::new(data)),
-            #[cfg(feature = "serialize")]
-            ser: Box::into_raw(Box::new(UserDataSerializeError)),
-        }))
-    }
-
-    pub(crate) fn new_arc(data: T) -> Self {
-        UserDataCell::Arc(Arc::new(RefCell::new(UserDataWrapped {
-            data: Box::into_raw(Box::new(data)),
-            #[cfg(feature = "serialize")]
-            ser: Box::into_raw(Box::new(UserDataSerializeError)),
-        })))
+        UserDataCell(RefCell::new(UserDataWrapped::new(data)))
    }

    #[cfg(feature = "serialize")]
+    #[inline]
    pub(crate) fn new_ser(data: T) -> Self
    where
        T: 'static + Serialize,
    {
-        let data_raw = Box::into_raw(Box::new(data));
-        UserDataCell::Plain(RefCell::new(UserDataWrapped {
-            data: data_raw,
-            ser: data_raw,
-        }))
+        UserDataCell(RefCell::new(UserDataWrapped::new_ser(data)))
+    }
+
+    // Immutably borrows the wrapped value.
+    #[inline]
+    pub(crate) fn try_borrow(&self) -> Result<Ref<T>> {
+        self.0
+            .try_borrow()
+            .map(|r| Ref::map(r, |r| r.deref()))
+            .map_err(|_| Error::UserDataBorrowError)
+    }
+
+    // Mutably borrows the wrapped value.
+    #[inline]
+    pub(crate) fn try_borrow_mut(&self) -> Result<RefMut<T>> {
+        self.0
+            .try_borrow_mut()
+            .map(|r| RefMut::map(r, |r| r.deref_mut()))
+            .map_err(|_| Error::UserDataBorrowMutError)
+    }
+
+    // Consumes this `UserDataCell`, returning the wrapped value.
+    #[inline]
+    fn into_inner(self) -> T {
+        self.0.into_inner().into_inner()
    }
 }

-impl<T> Deref for UserDataCell<T> {
-    type Target = RefCell<UserDataWrapped<T>>;
+pub(crate) enum UserDataWrapped<T> {
+    Default(Box<T>),
+    #[cfg(feature = "serialize")]
+    Serializable(Box<dyn erased_serde::Serialize>),
+}

+impl<T> UserDataWrapped<T> {
+    #[inline]
+    fn new(data: T) -> Self {
+        UserDataWrapped::Default(Box::new(data))
+    }
+
+    #[cfg(feature = "serialize")]
+    #[inline]
+    fn new_ser(data: T) -> Self
+    where
+        T: 'static + Serialize,
+    {
+        UserDataWrapped::Serializable(Box::new(data))
+    }
+
+    #[inline]
+    fn into_inner(self) -> T {
+        match self {
+            Self::Default(data) => *data,
+            #[cfg(feature = "serialize")]
+            Self::Serializable(data) => unsafe { *Box::from_raw(Box::into_raw(data) as *mut T) },
+        }
+    }
+}
+
+impl<T> Deref for UserDataWrapped<T> {
+    type Target = T;
+
+    #[inline]
    fn deref(&self) -> &Self::Target {
        match self {
-            UserDataCell::Arc(t) => &*t,
-            UserDataCell::Plain(t) => &*t,
-        }
-    }
-}
-
-impl<T> Clone for UserDataCell<T> {
-    fn clone(&self) -> Self {
-        match self {
-            UserDataCell::Arc(t) => UserDataCell::Arc(t.clone()),
-            UserDataCell::Plain(_) => mlua_panic!("cannot clone non-arc userdata"),
-        }
-    }
-}
-
-pub(crate) struct UserDataWrapped<T> {
-    pub(crate) data: *mut T,
-    #[cfg(feature = "serialize")]
-    ser: *mut dyn erased_serde::Serialize,
-}
-
-impl<T> Drop for UserDataWrapped<T> {
-    fn drop(&mut self) {
-        unsafe {
-            drop(Box::from_raw(self.data));
+            Self::Default(data) => data,
            #[cfg(feature = "serialize")]
-            if self.data as *mut () != self.ser as *mut () {
-                drop(Box::from_raw(self.ser));
-            }
+            Self::Serializable(data) => unsafe {
+                &*(data.as_ref() as *const _ as *const Self::Target)
+            },
        }
    }
 }

-impl<T> AsRef<T> for UserDataWrapped<T> {
-    fn as_ref(&self) -> &T {
-        unsafe { &*self.data }
-    }
-}
-
-impl<T> AsMut<T> for UserDataWrapped<T> {
-    fn as_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.data }
+impl<T> DerefMut for UserDataWrapped<T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        match self {
+            Self::Default(data) => data,
+            #[cfg(feature = "serialize")]
+            Self::Serializable(data) => unsafe {
+                &mut *(data.as_mut() as *mut _ as *mut Self::Target)
+            },
+        }
    }
 }

 #[cfg(feature = "serialize")]
-pub(crate) struct UserDataSerializeError;
+struct UserDataSerializeError;

 #[cfg(feature = "serialize")]
 impl Serialize for UserDataSerializeError {
@@ -661,9 +779,9 @@ impl Serialize for UserDataSerializeError {
 /// This API should only be used when necessary. Implementing [`UserData`] already allows defining
 /// methods which check the type and acquire a borrow behind the scenes.
 ///
-/// [`UserData`]: trait.UserData.html
-/// [`is`]: #method.is
-/// [`borrow`]: #method.borrow
+/// [`UserData`]: crate::UserData
+/// [`is`]: crate::AnyUserData::is
+/// [`borrow`]: crate::AnyUserData::borrow
 #[derive(Clone, Debug)]
 pub struct AnyUserData<'lua>(pub(crate) LuaRef<'lua>);

@@ -683,79 +801,255 @@ impl<'lua> AnyUserData<'lua> {
    ///
    /// Returns a `UserDataBorrowError` if the userdata is already mutably borrowed. Returns a
    /// `UserDataTypeMismatch` if the userdata is not of type `T`.
+    #[inline]
    pub fn borrow<T: 'static + UserData>(&self) -> Result<Ref<T>> {
-        self.inspect(|cell| {
-            let cell_ref = cell.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
-            Ok(Ref::map(cell_ref, |x| unsafe { &*x.data }))
-        })
+        self.inspect(|cell| cell.try_borrow())
    }

    /// Borrow this userdata mutably if it is of type `T`.
    ///
    /// # Errors
    ///
-    /// Returns a `UserDataBorrowMutError` if the userdata is already borrowed. Returns a
-    /// `UserDataTypeMismatch` if the userdata is not of type `T`.
+    /// Returns a `UserDataBorrowMutError` if the userdata cannot be mutably borrowed.
+    /// Returns a `UserDataTypeMismatch` if the userdata is not of type `T`.
+    #[inline]
    pub fn borrow_mut<T: 'static + UserData>(&self) -> Result<RefMut<T>> {
-        self.inspect(|cell| {
-            let cell_ref = cell
-                .try_borrow_mut()
-                .map_err(|_| Error::UserDataBorrowMutError)?;
-            Ok(RefMut::map(cell_ref, |x| unsafe { &mut *x.data }))
-        })
+        self.inspect(|cell| cell.try_borrow_mut())
+    }
+
+    /// Takes out the value of `UserData` and sets the special "destructed" metatable that prevents
+    /// any further operations with this userdata.
+    ///
+    /// All associated user values will be also cleared.
+    pub fn take<T: 'static + UserData>(&self) -> Result<T> {
+        let lua = self.0.lua;
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 3)?;
+
+            let type_id = lua.push_userdata_ref(&self.0)?;
+            match type_id {
+                Some(type_id) if type_id == TypeId::of::<T>() => {
+                    // Try to borrow userdata exclusively
+                    let _ = (*get_userdata::<UserDataCell<T>>(lua.state, -1)).try_borrow_mut()?;
+
+                    // Clear associated user values
+                    #[cfg(feature = "lua54")]
+                    for i in 1..=USER_VALUE_MAXSLOT {
+                        ffi::lua_pushnil(lua.state);
+                        ffi::lua_setiuservalue(lua.state, -2, i as c_int);
+                    }
+                    #[cfg(any(feature = "lua53", feature = "lua52"))]
+                    {
+                        ffi::lua_pushnil(lua.state);
+                        ffi::lua_setuservalue(lua.state, -2);
+                    }
+                    #[cfg(any(feature = "lua51", feature = "luajit"))]
+                    protect_lua!(lua.state, 1, 1, fn(state) {
+                        ffi::lua_newtable(state);
+                        ffi::lua_setuservalue(state, -2);
+                    })?;
+
+                    Ok(take_userdata::<UserDataCell<T>>(lua.state).into_inner())
+                }
+                _ => Err(Error::UserDataTypeMismatch),
+            }
+        }
    }

    /// Sets an associated value to this `AnyUserData`.
    ///
    /// The value may be any Lua value whatsoever, and can be retrieved with [`get_user_value`].
-    /// As Lua < 5.3 allows to store only tables, the value will be stored in a table at index 1.
+    ///
+    /// This is the same as calling [`set_nth_user_value`] with `n` set to 1.
    ///
    /// [`get_user_value`]: #method.get_user_value
+    /// [`set_nth_user_value`]: #method.set_nth_user_value
+    #[inline]
    pub fn set_user_value<V: ToLua<'lua>>(&self, v: V) -> Result<()> {
+        self.set_nth_user_value(1, v)
+    }
+
+    /// Returns an associated value set by [`set_user_value`].
+    ///
+    /// This is the same as calling [`get_nth_user_value`] with `n` set to 1.
+    ///
+    /// [`set_user_value`]: #method.set_user_value
+    /// [`get_nth_user_value`]: #method.get_nth_user_value
+    #[inline]
+    pub fn get_user_value<V: FromLua<'lua>>(&self) -> Result<V> {
+        self.get_nth_user_value(1)
+    }
+
+    /// Sets an associated `n`th value to this `AnyUserData`.
+    ///
+    /// The value may be any Lua value whatsoever, and can be retrieved with [`get_nth_user_value`].
+    /// `n` starts from 1 and can be up to 65535.
+    ///
+    /// This is supported for all Lua versions.
+    /// In Lua 5.4 first 7 elements are stored in a most efficient way.
+    /// For other Lua versions this functionality is provided using a wrapping table.
+    ///
+    /// [`get_nth_user_value`]: #method.get_nth_user_value
+    pub fn set_nth_user_value<V: ToLua<'lua>>(&self, n: usize, v: V) -> Result<()> {
+        if n < 1 || n > u16::MAX as usize {
+            return Err(Error::RuntimeError(
+                "user value index out of bounds".to_string(),
+            ));
+        }
+
        let lua = self.0.lua;
-        #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-        let v = {
-            // Lua <= 5.2 allows to store only a table. Then we will wrap the value.
-            let t = lua.create_table_with_capacity(1, 0)?;
-            t.raw_set(1, v)?;
-            Value::Table(t)
-        };
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        let v = v.to_lua(lua)?;
        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+            check_stack(lua.state, 5)?;

            lua.push_userdata_ref(&self.0)?;
-            lua.push_value(v)?;
-            ffi::lua_setuservalue(lua.state, -2);
+            lua.push_value(v.to_lua(lua)?)?;
+
+            #[cfg(feature = "lua54")]
+            if n < USER_VALUE_MAXSLOT {
+                ffi::lua_setiuservalue(lua.state, -2, n as c_int);
+                return Ok(());
+            }
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            protect_lua!(lua.state, 2, 0, |state| {
+                if getuservalue_table(lua.state, -2) != ffi::LUA_TTABLE {
+                    // Create a new table to use as uservalue
+                    ffi::lua_pop(lua.state, 1);
+                    ffi::lua_newtable(state);
+                    ffi::lua_pushvalue(state, -1);
+
+                    #[cfg(feature = "lua54")]
+                    ffi::lua_setiuservalue(lua.state, -4, USER_VALUE_MAXSLOT as c_int);
+                    #[cfg(not(feature = "lua54"))]
+                    ffi::lua_setuservalue(lua.state, -4);
+                }
+                ffi::lua_pushvalue(state, -2);
+                #[cfg(feature = "lua54")]
+                ffi::lua_rawseti(state, -2, (n - USER_VALUE_MAXSLOT + 1) as ffi::lua_Integer);
+                #[cfg(not(feature = "lua54"))]
+                ffi::lua_rawseti(state, -2, n as ffi::lua_Integer);
+            })?;

            Ok(())
        }
    }

-    /// Returns an associated value set by [`set_user_value`].
+    /// Returns an associated `n`th value set by [`set_nth_user_value`].
    ///
-    /// For Lua < 5.3 the value will be automatically extracted from the table wrapper from index 1.
+    /// `n` starts from 1 and can be up to 65535.
    ///
-    /// [`set_user_value`]: #method.set_user_value
-    pub fn get_user_value<V: FromLua<'lua>>(&self) -> Result<V> {
+    /// This is supported for all Lua versions.
+    /// In Lua 5.4 first 7 elements are stored in a most efficient way.
+    /// For other Lua versions this functionality is provided using a wrapping table.
+    ///
+    /// [`set_nth_user_value`]: #method.set_nth_user_value
+    pub fn get_nth_user_value<V: FromLua<'lua>>(&self, n: usize) -> Result<V> {
+        if n < 1 || n > u16::MAX as usize {
+            return Err(Error::RuntimeError(
+                "user value index out of bounds".to_string(),
+            ));
+        }
+
        let lua = self.0.lua;
-        let res = unsafe {
+        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+            check_stack(lua.state, 4)?;

            lua.push_userdata_ref(&self.0)?;
-            ffi::lua_getuservalue(lua.state, -1);
-            lua.pop_value()
-        };
-        #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-        return match <Option<Table>>::from_lua(res, lua)? {
-            Some(t) => t.get(1),
-            None => V::from_lua(Value::Nil, lua),
-        };
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        V::from_lua(res, lua)
+
+            #[cfg(feature = "lua54")]
+            if n < USER_VALUE_MAXSLOT {
+                ffi::lua_getiuservalue(lua.state, -1, n as c_int);
+                return V::from_lua(lua.pop_value(), lua);
+            }
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            protect_lua!(lua.state, 1, 1, |state| {
+                if getuservalue_table(lua.state, -1) != ffi::LUA_TTABLE {
+                    ffi::lua_pushnil(lua.state);
+                    return;
+                }
+                #[cfg(feature = "lua54")]
+                ffi::lua_rawgeti(state, -1, (n - USER_VALUE_MAXSLOT + 1) as ffi::lua_Integer);
+                #[cfg(not(feature = "lua54"))]
+                ffi::lua_rawgeti(state, -1, n as ffi::lua_Integer);
+            })?;
+
+            V::from_lua(lua.pop_value(), lua)
+        }
+    }
+
+    /// Sets an associated value to this `AnyUserData` by name.
+    ///
+    /// The value can be retrieved with [`get_named_user_value`].
+    ///
+    /// [`get_named_user_value`]: #method.get_named_user_value
+    pub fn set_named_user_value<S, V>(&self, name: &S, v: V) -> Result<()>
+    where
+        S: AsRef<[u8]> + ?Sized,
+        V: ToLua<'lua>,
+    {
+        let lua = self.0.lua;
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 5)?;
+
+            lua.push_userdata_ref(&self.0)?;
+            lua.push_value(v.to_lua(lua)?)?;
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            let name = name.as_ref();
+            protect_lua!(lua.state, 2, 0, |state| {
+                if getuservalue_table(lua.state, -2) != ffi::LUA_TTABLE {
+                    // Create a new table to use as uservalue
+                    ffi::lua_pop(lua.state, 1);
+                    ffi::lua_newtable(state);
+                    ffi::lua_pushvalue(state, -1);
+
+                    #[cfg(feature = "lua54")]
+                    ffi::lua_setiuservalue(lua.state, -4, USER_VALUE_MAXSLOT as c_int);
+                    #[cfg(not(feature = "lua54"))]
+                    ffi::lua_setuservalue(lua.state, -4);
+                }
+                ffi::lua_pushlstring(state, name.as_ptr() as *const c_char, name.len());
+                ffi::lua_pushvalue(state, -3);
+                ffi::lua_rawset(state, -3);
+            })?;
+
+            Ok(())
+        }
+    }
+
+    /// Returns an associated value by name set by [`set_named_user_value`].
+    ///
+    /// [`set_named_user_value`]: #method.set_named_user_value
+    pub fn get_named_user_value<S, V>(&self, name: &S) -> Result<V>
+    where
+        S: AsRef<[u8]> + ?Sized,
+        V: FromLua<'lua>,
+    {
+        let lua = self.0.lua;
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 4)?;
+
+            lua.push_userdata_ref(&self.0)?;
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            let name = name.as_ref();
+            protect_lua!(lua.state, 1, 1, |state| {
+                if getuservalue_table(lua.state, -1) != ffi::LUA_TTABLE {
+                    ffi::lua_pushnil(lua.state);
+                    return;
+                }
+                ffi::lua_pushlstring(state, name.as_ptr() as *const c_char, name.len());
+                ffi::lua_rawget(state, -2);
+            })?;
+
+            V::from_lua(lua.pop_value(), lua)
+        }
    }

    /// Returns a metatable of this `UserData`.
@@ -765,7 +1059,7 @@ impl<'lua> AnyUserData<'lua> {
    ///
    /// For `T: UserData + 'static` returned metatable is shared among all instances of type `T`.
    ///
-    /// [`UserDataMetatable`]: struct.UserDataMetatable.html
+    /// [`UserDataMetatable`]: crate::UserDataMetatable
    pub fn get_metatable(&self) -> Result<UserDataMetatable<'lua>> {
        self.get_raw_metatable().map(UserDataMetatable)
    }
@@ -811,25 +1105,14 @@ impl<'lua> AnyUserData<'lua> {
        let lua = self.0.lua;
        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+            check_stack(lua.state, 2)?;

-            lua.push_ref(&self.0);
-            if ffi::lua_getmetatable(lua.state, -1) == 0 {
-                return Err(Error::UserDataTypeMismatch);
-            }
-            lua.push_userdata_metatable::<T>()?;
-
-            if ffi::lua_rawequal(lua.state, -1, -2) == 0 {
-                // Maybe UserData destructed?
-                ffi::lua_pop(lua.state, 1);
-                get_destructed_userdata_metatable(lua.state);
-                if ffi::lua_rawequal(lua.state, -1, -2) == 1 {
-                    Err(Error::UserDataDestructed)
-                } else {
-                    Err(Error::UserDataTypeMismatch)
+            let type_id = lua.push_userdata_ref(&self.0)?;
+            match type_id {
+                Some(type_id) if type_id == TypeId::of::<T>() => {
+                    func(&*get_userdata::<UserDataCell<T>>(lua.state, -1))
                }
-            } else {
-                func(&*get_userdata::<UserDataCell<T>>(lua.state, -3))
+                _ => Err(Error::UserDataTypeMismatch),
            }
        }
    }
@@ -848,6 +1131,13 @@ impl<'lua> AsRef<AnyUserData<'lua>> for AnyUserData<'lua> {
    }
 }

+unsafe fn getuservalue_table(state: *mut ffi::lua_State, idx: c_int) -> c_int {
+    #[cfg(feature = "lua54")]
+    return ffi::lua_getiuservalue(state, idx, USER_VALUE_MAXSLOT as c_int);
+    #[cfg(not(feature = "lua54"))]
+    return ffi::lua_getuservalue(state, idx);
+}
+
 /// Handle to a `UserData` metatable.
 #[derive(Clone, Debug)]
 pub struct UserDataMetatable<'lua>(pub(crate) Table<'lua>);
@@ -885,7 +1175,7 @@ impl<'lua> UserDataMetatable<'lua> {
    ///
    /// The pairs are wrapped in a [`Result`], since they are lazily converted to `V` type.
    ///
-    /// [`Result`]: type.Result.html
+    /// [`Result`]: crate::Result
    pub fn pairs<V: FromLua<'lua>>(self) -> UserDataMetatablePairs<'lua, V> {
        UserDataMetatablePairs(self.0.pairs())
    }
@@ -897,8 +1187,8 @@ impl<'lua> UserDataMetatable<'lua> {
 ///
 /// This struct is created by the [`UserDataMetatable::pairs`] method.
 ///
-/// [`UserData`]: trait.UserData.html
-/// [`UserDataMetatable::pairs`]: struct.UserDataMetatable.html#method.pairs
+/// [`UserData`]: crate::UserData
+/// [`UserDataMetatable::pairs`]: crate::UserDataMetatable::method.pairs
 pub struct UserDataMetatablePairs<'lua, V>(TablePairs<'lua, StdString, V>);

 impl<'lua, V> Iterator for UserDataMetatablePairs<'lua, V>
@@ -928,17 +1218,19 @@ impl<'lua> Serialize for AnyUserData<'lua> {
    where
        S: Serializer,
    {
-        let res = (|| unsafe {
-            let lua = self.0.lua;
+        let lua = self.0.lua;
+        let data = unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+            check_stack(lua.state, 3).map_err(ser::Error::custom)?;

-            lua.push_userdata_ref(&self.0)?;
+            lua.push_userdata_ref(&self.0).map_err(ser::Error::custom)?;
            let ud = &*get_userdata::<UserDataCell<()>>(lua.state, -1);
-            (*ud.try_borrow().map_err(|_| Error::UserDataBorrowError)?.ser)
-                .serialize(serializer)
-                .map_err(|err| Error::SerializeError(err.to_string()))
-        })();
-        res.map_err(ser::Error::custom)
+            ud.0.try_borrow()
+                .map_err(|_| ser::Error::custom(Error::UserDataBorrowError))?
+        };
+        match &*data {
+            UserDataWrapped::Default(_) => UserDataSerializeError.serialize(serializer),
+            UserDataWrapped::Serializable(ser) => ser.serialize(serializer),
+        }
    }
 }
@@ -1,24 +1,27 @@
 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::os::raw::{c_char, c_int, c_void};
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::{mem, ptr, slice};

 use once_cell::sync::Lazy;
+use rustc_hash::FxHashMap;

 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))
+static METATABLE_CACHE: Lazy<FxHashMap<TypeId, u8>> = Lazy::new(|| {
+    let mut map = FxHashMap::with_capacity_and_hasher(32, Default::default());
+    crate::lua::init_metatable_cache(&mut map);
+    map.insert(TypeId::of::<WrappedFailure>(), 0);
+    map.insert(TypeId::of::<String>(), 0);
+    map
 });

 // Checks that Lua has enough free stack space for future stack operations. On failure, this will
 // panic with an internal error message.
+#[inline]
 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
@@ -30,6 +33,7 @@ pub unsafe fn assert_stack(state: *mut ffi::lua_State, amount: c_int) {
 }

 // Checks that Lua has enough free stack space and returns `Error::StackError` on failure.
+#[inline]
 pub unsafe fn check_stack(state: *mut ffi::lua_State, amount: c_int) -> Result<()> {
    if ffi::lua_checkstack(state, amount) == 0 {
        Err(Error::StackError)
@@ -48,6 +52,7 @@ 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.
+    #[inline]
    pub unsafe fn new(state: *mut ffi::lua_State) -> StackGuard {
        StackGuard {
            state,
@@ -57,6 +62,7 @@ impl StackGuard {
    }

    // Similar to `new`, but checks and keeps `extra` elements from top of the stack on Drop.
+    #[inline]
    pub unsafe fn new_extra(state: *mut ffi::lua_State, extra: c_int) -> StackGuard {
        StackGuard {
            state,
@@ -86,16 +92,17 @@ impl Drop for StackGuard {
 // 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(
+// always `LUA_MULTRET`. Provided function must *not* panic, and since it will generally be lonjmping,
+// should not contain any values that implements Drop.
+// Internally uses 2 extra stack spaces, and does not call checkstack.
+pub unsafe fn protect_lua_call(
    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
+    f: unsafe extern "C" fn(*mut ffi::lua_State) -> c_int,
 ) -> Result<()> {
    let stack_start = ffi::lua_gettop(state) - nargs;

-    ffi::lua_pushcfunction(state, ffi::safe::error_traceback);
+    ffi::lua_pushcfunction(state, error_traceback);
    ffi::lua_pushcfunction(state, f);
    if nargs > 0 {
        ffi::lua_rotate(state, stack_start + 1, 2);
@@ -111,6 +118,78 @@ pub unsafe fn protect_lua(
    }
 }

+// Call a function that calls into the Lua API and may trigger a Lua error (longjmp) in a safe way.
+// Wraps the inner function in a call to `lua_pcall`, so the inner function only has access to a
+// limited lua stack. `nargs` and `nresults` are similar to the parameters of `lua_pcall`, but the
+// given function return type is not the return value count, instead the inner function return
+// values are assumed to match the `nresults` param. Provided function must *not* panic, and since it
+// will generally be lonjmping, should not contain any values that implements Drop.
+// Internally uses 3 extra stack spaces, and does not call checkstack.
+pub unsafe fn protect_lua_closure<F, R>(
+    state: *mut ffi::lua_State,
+    nargs: c_int,
+    nresults: c_int,
+    f: F,
+) -> Result<R>
+where
+    F: Fn(*mut ffi::lua_State) -> R,
+    R: Copy,
+{
+    union URes<R: Copy> {
+        uninit: (),
+        init: R,
+    }
+
+    struct Params<F, R: Copy> {
+        function: F,
+        result: URes<R>,
+        nresults: c_int,
+    }
+
+    unsafe extern "C" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
+    where
+        R: Copy,
+        F: Fn(*mut ffi::lua_State) -> R,
+    {
+        let params = ffi::lua_touserdata(state, -1) as *mut Params<F, R>;
+        ffi::lua_pop(state, 1);
+
+        (*params).result.init = ((*params).function)(state);
+
+        if (*params).nresults == ffi::LUA_MULTRET {
+            ffi::lua_gettop(state)
+        } else {
+            (*params).nresults
+        }
+    }
+
+    let stack_start = ffi::lua_gettop(state) - nargs;
+
+    ffi::lua_pushcfunction(state, error_traceback);
+    ffi::lua_pushcfunction(state, do_call::<F, R>);
+    if nargs > 0 {
+        ffi::lua_rotate(state, stack_start + 1, 2);
+    }
+
+    let mut params = Params {
+        function: f,
+        result: URes { uninit: () },
+        nresults,
+    };
+
+    ffi::lua_pushlightuserdata(state, &mut params as *mut Params<F, R> as *mut c_void);
+    let ret = ffi::lua_pcall(state, nargs + 1, nresults, stack_start + 1);
+    ffi::lua_remove(state, stack_start + 1);
+
+    if ret == ffi::LUA_OK {
+        // `LUA_OK` is only returned when the `do_call` function has completed successfully, so
+        // `params.result` is definitely initialized.
+        Ok(params.result.init)
+    } 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.
@@ -123,52 +202,103 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
        "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
+    match get_gc_userdata::<WrappedFailure>(state, -1).as_mut() {
+        Some(WrappedFailure::Error(err)) => {
+            ffi::lua_pop(state, 1);
+            err.clone()
        }
-    } else {
-        let err_string = to_string(state, -1);
-        ffi::lua_pop(state, 1);
+        Some(WrappedFailure::Panic(panic)) => {
+            if let Some(p) = panic.take() {
+                resume_unwind(p);
+            } else {
+                Error::PreviouslyResumedPanic
+            }
+        }
+        _ => {
+            let err_string = to_string(state, -1);
+            ffi::lua_pop(state, 1);

-        match err_code {
-            ffi::LUA_ERRRUN => Error::RuntimeError(err_string),
-            ffi::LUA_ERRSYNTAX => {
-                Error::SyntaxError {
-                    // This seems terrible, but as far as I can tell, this is exactly what the
-                    // stock Lua REPL does.
-                    incomplete_input: err_string.ends_with("<eof>")
-                        || err_string.ends_with("'<eof>'"),
-                    message: err_string,
+            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"),
            }
-            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"),
        }
    }
 }

+// Uses 3 stack spaces, does not call checkstack.
+#[inline]
+pub unsafe fn push_string<S: AsRef<[u8]> + ?Sized>(
+    state: *mut ffi::lua_State,
+    s: &S,
+) -> Result<()> {
+    let s = s.as_ref();
+    protect_lua!(state, 0, 1, |state| {
+        ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
+    })
+}
+
+// Uses 3 stack spaces, does not call checkstack.
+#[inline]
+pub unsafe fn push_table(state: *mut ffi::lua_State, narr: c_int, nrec: c_int) -> Result<()> {
+    protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
+}
+
+// Uses 4 stack spaces, does not call checkstack.
+pub unsafe fn rawset_field<S>(state: *mut ffi::lua_State, table: c_int, field: &S) -> Result<()>
+where
+    S: AsRef<[u8]> + ?Sized,
+{
+    let field = field.as_ref();
+    ffi::lua_pushvalue(state, table);
+    protect_lua!(state, 2, 0, |state| {
+        ffi::lua_pushlstring(state, field.as_ptr() as *const c_char, field.len());
+        ffi::lua_rotate(state, -3, 2);
+        ffi::lua_rawset(state, -3);
+    })
+}
+
 // Internally uses 3 stack spaces, does not call checkstack.
+#[inline]
 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;
+    let ud = protect_lua!(state, 0, 1, |state| {
+        ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
+    })?;
    ptr::write(ud, t);
    Ok(())
 }

+// Internally uses 3 stack spaces, does not call checkstack.
+#[cfg(feature = "lua54")]
+#[inline]
+pub unsafe fn push_userdata_uv<T>(state: *mut ffi::lua_State, t: T, nuvalue: c_int) -> Result<()> {
+    let ud = protect_lua!(state, 0, 1, |state| {
+        ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
+    })?;
+    ptr::write(ud, t);
+    Ok(())
+}
+
+#[inline]
 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");
@@ -195,7 +325,7 @@ pub unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
 // 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);
+    get_gc_metatable::<T>(state);
    ffi::lua_setmetatable(state, -2);
    Ok(())
 }
@@ -206,7 +336,7 @@ pub unsafe fn get_gc_userdata<T: Any>(state: *mut ffi::lua_State, index: c_int)
    if ud.is_null() || ffi::lua_getmetatable(state, index) == 0 {
        return ptr::null_mut();
    }
-    get_gc_metatable_for::<T>(state);
+    get_gc_metatable::<T>(state);
    let res = ffi::lua_rawequal(state, -1, -2);
    ffi::lua_pop(state, 2);
    if res == 0 {
@@ -230,13 +360,99 @@ pub unsafe fn init_userdata_metatable<T>(
    field_setters: Option<c_int>,
    methods: Option<c_int>,
 ) -> Result<()> {
+    // Wrapper to lookup in `field_getters` first, then `methods`, ending original `__index`.
+    // Used only if `field_getters` or `methods` set.
+    unsafe extern "C" fn meta_index_impl(state: *mut ffi::lua_State) -> c_int {
+        // stack: self, key
+        ffi::luaL_checkstack(state, 2, ptr::null());
+
+        // lookup in `field_getters` table
+        if ffi::lua_isnil(state, ffi::lua_upvalueindex(2)) == 0 {
+            ffi::lua_pushvalue(state, -1); // `key` arg
+            if ffi::lua_rawget(state, ffi::lua_upvalueindex(2)) != ffi::LUA_TNIL {
+                ffi::lua_insert(state, -3); // move function
+                ffi::lua_pop(state, 1); // remove `key`
+                ffi::lua_call(state, 1, 1);
+                return 1;
+            }
+            ffi::lua_pop(state, 1); // pop the nil value
+        }
+        // lookup in `methods` table
+        if ffi::lua_isnil(state, ffi::lua_upvalueindex(3)) == 0 {
+            ffi::lua_pushvalue(state, -1); // `key` arg
+            if ffi::lua_rawget(state, ffi::lua_upvalueindex(3)) != ffi::LUA_TNIL {
+                ffi::lua_insert(state, -3);
+                ffi::lua_pop(state, 2);
+                return 1;
+            }
+            ffi::lua_pop(state, 1); // pop the nil value
+        }
+
+        // lookup in `__index`
+        ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
+        match ffi::lua_type(state, -1) {
+            ffi::LUA_TNIL => {
+                ffi::lua_pop(state, 1); // pop the nil value
+                let field = ffi::lua_tostring(state, -1);
+                ffi::luaL_error(state, cstr!("attempt to get an unknown field '%s'"), field);
+            }
+            ffi::LUA_TTABLE => {
+                ffi::lua_insert(state, -2);
+                ffi::lua_gettable(state, -2);
+            }
+            ffi::LUA_TFUNCTION => {
+                ffi::lua_insert(state, -3);
+                ffi::lua_call(state, 2, 1);
+            }
+            _ => unreachable!(),
+        }
+
+        1
+    }
+
+    // Similar to `meta_index_impl`, checks `field_setters` table first, then `__newindex` metamethod.
+    // Used only if `field_setters` set.
+    unsafe extern "C" fn meta_newindex_impl(state: *mut ffi::lua_State) -> c_int {
+        // stack: self, key, value
+        ffi::luaL_checkstack(state, 2, ptr::null());
+
+        // lookup in `field_setters` table
+        ffi::lua_pushvalue(state, -2); // `key` arg
+        if ffi::lua_rawget(state, ffi::lua_upvalueindex(2)) != ffi::LUA_TNIL {
+            ffi::lua_remove(state, -3); // remove `key`
+            ffi::lua_insert(state, -3); // move function
+            ffi::lua_call(state, 2, 0);
+            return 0;
+        }
+        ffi::lua_pop(state, 1); // pop the nil value
+
+        // lookup in `__newindex`
+        ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
+        match ffi::lua_type(state, -1) {
+            ffi::LUA_TNIL => {
+                ffi::lua_pop(state, 1); // pop the nil value
+                let field = ffi::lua_tostring(state, -2);
+                ffi::luaL_error(state, cstr!("attempt to set an unknown field '%s'"), field);
+            }
+            ffi::LUA_TTABLE => {
+                ffi::lua_insert(state, -3);
+                ffi::lua_settable(state, -3);
+            }
+            ffi::LUA_TFUNCTION => {
+                ffi::lua_insert(state, -4);
+                ffi::lua_call(state, 3, 0);
+            }
+            _ => unreachable!(),
+        }
+
+        0
+    }
+
    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);
+        push_string(state, "__index")?;
+        let index_type = ffi::lua_rawget(state, -2);
        match index_type {
            ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
                for &idx in &[field_getters, methods] {
@@ -246,35 +462,37 @@ pub unsafe fn init_userdata_metatable<T>(
                        ffi::lua_pushnil(state);
                    }
                }
-                ffi::safe::lua_pushcclosure(state, ffi::safe::meta_index_impl, 3)?;
+                protect_lua!(state, 3, 1, fn(state) {
+                    ffi::lua_pushcclosure(state, meta_index_impl, 3);
+                })?;
            }
            _ => mlua_panic!("improper __index type {}", index_type),
        }

-        ffi::safe::lua_rawset(state, -3)?;
+        rawset_field(state, -2, "__index")?;
    }

    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);
+        push_string(state, "__newindex")?;
+        let newindex_type = ffi::lua_rawget(state, -2);
        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)?;
+                protect_lua!(state, 2, 1, fn(state) {
+                    ffi::lua_pushcclosure(state, meta_newindex_impl, 2);
+                })?;
            }
            _ => mlua_panic!("improper __newindex type {}", newindex_type),
        }

-        ffi::safe::lua_rawset(state, -3)?;
+        rawset_field(state, -2, "__newindex")?;
    }

-    ffi::safe::lua_pushrclosure(state, userdata_destructor::<T>, 0)?;
-    ffi::safe::lua_rawsetfield(state, -2, "__gc")?;
+    ffi::lua_pushcfunction(state, userdata_destructor::<T>);
+    rawset_field(state, -2, "__gc")?;

    ffi::lua_pushboolean(state, 0);
-    ffi::safe::lua_rawsetfield(state, -2, "__metatable")?;
+    rawset_field(state, -2, "__metatable")?;

    ffi::lua_pop(state, 1);

@@ -282,29 +500,42 @@ pub unsafe fn init_userdata_metatable<T>(
 }

 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)
-    })
+    // It's probably NOT a good idea to catch Rust panics in finalizer
+    // Lua 5.4 ignores it, other versions generates `LUA_ERRGCMM` without calling message handler
+    take_userdata::<T>(state);
+    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).
+// returns an error, *or if the given function panics*, this will result in a call to `lua_error` (a
+// longjmp). The error or panic is wrapped in such a way that when calling `pop_error` back on
+// the Rust side, it will resume the panic.
 //
 // This function assumes the structure of the stack at the beginning of a callback, that the only
 // elements on the stack are the arguments to the callback.
 //
 // This function uses some of the bottom of the stack for error handling, the given callback will be
 // given the number of arguments available as an argument, and should return the number of returns
-// as normal, but cannot assume that the arguments available start at 1.
-pub unsafe fn callback_error<F>(state: *mut ffi::lua_State, f: F) -> c_int
+// as normal, but cannot assume that the arguments available start at 0.
+pub unsafe fn callback_error<F, R>(state: *mut ffi::lua_State, f: F) -> R
 where
-    F: FnOnce(c_int) -> Result<c_int>,
+    F: FnOnce(c_int) -> Result<R>,
 {
-    let nargs = ffi::lua_gettop(state) - 1;
+    let nargs = ffi::lua_gettop(state);
+
+    // We need 2 extra stack spaces to store preallocated memory and error/panic metatable
+    let extra_stack = if nargs < 2 { 2 - nargs } else { 1 };
+    ffi::luaL_checkstack(
+        state,
+        extra_stack,
+        cstr!("not enough stack space for callback error handling"),
+    );
+
+    // We cannot shadow Rust errors with Lua ones, we pre-allocate enough memory
+    // to store a wrapped error or panic *before* we proceed.
+    let ud = ffi::lua_newuserdata(state, mem::size_of::<WrappedFailure>());
+    ffi::lua_rotate(state, 1, 1);
+
    match catch_unwind(AssertUnwindSafe(|| f(nargs))) {
        Ok(Ok(r)) => {
            ffi::lua_remove(state, 1);
@@ -312,42 +543,126 @@ where
        }
        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);
+
+            let wrapped_error = ud as *mut WrappedFailure;
+
+            // Build `CallbackError` with traceback
+            let traceback = if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+                ffi::luaL_traceback(state, state, ptr::null(), 0);
+                let traceback = to_string(state, -1);
+                ffi::lua_pop(state, 1);
+                traceback
+            } else {
+                "<not enough stack space for traceback>".to_string()
+            };
+            let cause = Arc::new(err);
+            ptr::write(
+                wrapped_error,
+                WrappedFailure::Error(Error::CallbackError { traceback, cause }),
+            );
+            get_gc_metatable::<WrappedFailure>(state);
            ffi::lua_setmetatable(state, -2);
-            -1
+
+            ffi::lua_error(state)
        }
        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);
+            ptr::write(ud as *mut WrappedFailure, WrappedFailure::Panic(Some(p)));
+            get_gc_metatable::<WrappedFailure>(state);
            ffi::lua_setmetatable(state, -2);
-            -2
+            ffi::lua_error(state)
        }
    }
 }

-// 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 };
+pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
+    if ffi::lua_checkstack(state, 2) == 0 {
+        // If we don't have enough stack space to even check the error type, do
+        // nothing so we don't risk shadowing a rust panic.
+        return 1;
+    }
+
+    if get_gc_userdata::<WrappedFailure>(state, -1).is_null() {
+        let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
+        if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+            ffi::luaL_traceback(state, state, s, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+
+    1
+}
+
+// A variant of `pcall` that does not allow Lua to catch Rust panics from `callback_error`.
+pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
+    ffi::luaL_checkstack(state, 2, ptr::null());
+
+    let top = ffi::lua_gettop(state);
+    if top == 0 {
+        ffi::lua_pushstring(state, cstr!("not enough arguments to pcall"));
+        ffi::lua_error(state);
+    }
+
+    if ffi::lua_pcall(state, top - 1, ffi::LUA_MULTRET, 0) == ffi::LUA_OK {
+        ffi::lua_pushboolean(state, 1);
+        ffi::lua_insert(state, 1);
+        ffi::lua_gettop(state)
+    } else {
+        if let Some(WrappedFailure::Panic(_)) =
+            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+        {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushboolean(state, 0);
+        ffi::lua_insert(state, -2);
+        2
+    }
+}
+
+// A variant of `xpcall` that does not allow Lua to catch Rust panics from `callback_error`.
+pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
+    unsafe extern "C" fn xpcall_msgh(state: *mut ffi::lua_State) -> c_int {
+        ffi::luaL_checkstack(state, 2, ptr::null());
+
+        if let Some(WrappedFailure::Panic(_)) =
+            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+        {
+            1
+        } else {
+            ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
+            ffi::lua_insert(state, 1);
+            ffi::lua_call(state, ffi::lua_gettop(state) - 1, ffi::LUA_MULTRET);
+            ffi::lua_gettop(state)
+        }
+    }
+
+    ffi::luaL_checkstack(state, 2, ptr::null());
+
+    let top = ffi::lua_gettop(state);
+    if top < 2 {
+        ffi::lua_pushstring(state, cstr!("not enough arguments to xpcall"));
+        ffi::lua_error(state);
+    }
+
+    ffi::lua_pushvalue(state, 2);
+    ffi::lua_pushcclosure(state, xpcall_msgh, 1);
+    ffi::lua_copy(state, 1, 2);
+    ffi::lua_replace(state, 1);
+
+    if ffi::lua_pcall(state, ffi::lua_gettop(state) - 2, ffi::LUA_MULTRET, 1) == ffi::LUA_OK {
+        ffi::lua_pushboolean(state, 1);
+        ffi::lua_insert(state, 2);
+        ffi::lua_gettop(state) - 1
+    } else {
+        if let Some(WrappedFailure::Panic(_)) =
+            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+        {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushboolean(state, 0);
+        ffi::lua_insert(state, -2);
+        2
+    }
 }

 // Returns Lua main thread for Lua >= 5.2 or checks that the passed thread is main for Lua 5.1.
@@ -373,75 +688,44 @@ pub unsafe fn get_main_state(state: *mut ffi::lua_State) -> Option<*mut ffi::lua
    }
 }

-// 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>(
+pub unsafe fn init_gc_metatable<T: Any>(
    state: *mut ffi::lua_State,
    customize_fn: Option<fn(*mut ffi::lua_State) -> Result<()>>,
-) -> Result<*const u8> {
+) -> Result<()> {
    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
-    };
+    push_table(state, 0, 3)?;

-    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_pushcfunction(state, userdata_destructor::<T>);
+    rawset_field(state, -2, "__gc")?;

    ffi::lua_pushboolean(state, 0);
-    ffi::safe::lua_rawsetfield(state, -2, "__metatable")?;
+    rawset_field(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)?;
+    let type_id = TypeId::of::<T>();
+    let ref_addr = &METATABLE_CACHE[&type_id] as *const u8;
+    protect_lua!(state, 1, 0, |state| {
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, ref_addr as *const c_void);
+    })?;

-    Ok(ref_addr)
+    Ok(())
 }

-pub unsafe fn get_gc_metatable_for<T: Any>(state: *mut ffi::lua_State) {
+pub unsafe fn get_gc_metatable<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
-    };
+    let ref_addr =
+        mlua_expect!(METATABLE_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)> {
+pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
    check_stack(state, 7)?;

    // Create error and panic metatables
@@ -450,103 +734,66 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<(*const
        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);
+            let err_buf = match get_gc_userdata::<WrappedFailure>(state, -1).as_ref() {
+                Some(WrappedFailure::Error(error)) => {
+                    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
+                    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
+                    let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
+                    ffi::lua_pop(state, 2);

-                (*err_buf).clear();
-                // Depending on how the API is used and what error types scripts are given, it may
-                // be possible to make this consume arbitrary amounts of memory (for example, some
-                // kind of recursive error structure?)
-                let _ = write!(&mut (*err_buf), "{}", error);
-                // 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);
+                    (*err_buf).clear();
+                    // Depending on how the API is used and what error types scripts are given, it may
+                    // be possible to make this consume arbitrary amounts of memory (for example, some
+                    // kind of recursive error structure?)
+                    let _ = write!(&mut (*err_buf), "{}", error);
+                    Ok(err_buf)
                }
-                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 {
+                Some(WrappedFailure::Panic(Some(ref panic))) => {
                    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
                    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
                    let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
                    (*err_buf).clear();
                    ffi::lua_pop(state, 2);

-                    if let Some(msg) = p.downcast_ref::<&str>() {
+                    if let Some(msg) = panic.downcast_ref::<&str>() {
                        let _ = write!(&mut (*err_buf), "{}", msg);
-                    } else if let Some(msg) = p.downcast_ref::<String>() {
+                    } else if let Some(msg) = panic.downcast_ref::<String>() {
                        let _ = write!(&mut (*err_buf), "{}", msg);
                    } else {
                        let _ = write!(&mut (*err_buf), "<panic>");
                    };
                    Ok(err_buf)
-                } else {
-                    Err(Error::PreviouslyResumedPanic)
                }
-            } else {
-                // I'm not sure whether this is possible to trigger without bugs in mlua?
-                Err(Error::UserDataTypeMismatch)
+                Some(WrappedFailure::Panic(None)) => Err(Error::PreviouslyResumedPanic),
+                _ => {
+                    // I'm not sure whether this is possible to trigger without bugs in mlua?
+                    Err(Error::UserDataTypeMismatch)
+                }
            }?;

-            ffi::safe::lua_pushstring(state, &*err_buf)?;
+            push_string(state, &*err_buf)?;
            (*err_buf).clear();

            Ok(1)
        })
    }

-    let wrapped_error_key = init_gc_metatable_for::<WrappedError>(
+    init_gc_metatable::<WrappedFailure>(
        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")
+            ffi::lua_pushcfunction(state, error_tostring);
+            rawset_field(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
-        })
+        callback_error(state, |_| Err(Error::CallbackDestructed))
    }

-    ffi::safe::lua_createtable(state, 0, 26)?;
-    ffi::safe::lua_pushrclosure(state, destructed_error, 0)?;
+    push_table(state, 0, 26)?;
+    ffi::lua_pushcfunction(state, destructed_error);
    for &method in &[
        "__add",
        "__sub",
@@ -578,36 +825,47 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<(*const
        "__newindex",
        "__call",
        "__tostring",
-        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+        #[cfg(any(
+            feature = "lua54",
+            feature = "lua53",
+            feature = "lua52",
+            feature = "luajit52"
+        ))]
        "__pairs",
-        #[cfg(any(feature = "lua53", feature = "lua52"))]
+        #[cfg(any(feature = "lua53", feature = "lua52", feature = "luajit52"))]
        "__ipairs",
        #[cfg(feature = "lua54")]
        "__close",
    ] {
        ffi::lua_pushvalue(state, -1);
-        ffi::safe::lua_rawsetfield(state, -3, method)?;
+        rawset_field(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)?;
+    protect_lua!(state, 1, 0, fn(state) {
+        let destructed_mt_key = &DESTRUCTED_USERDATA_METATABLE as *const u8 as *const c_void;
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, destructed_mt_key);
+    })?;

    // Create error print buffer
-    init_gc_metatable_for::<String>(state, None)?;
+    init_gc_metatable::<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)?;
+    protect_lua!(state, 1, 0, fn(state) {
+        let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
+    })?;

-    Ok((wrapped_error_key, wrapped_panic_key))
+    Ok(())
 }

-pub(crate) struct WrappedError(pub Error);
-pub(crate) struct WrappedPanic(pub Option<Box<dyn Any + Send + 'static>>);
+pub(crate) enum WrappedFailure {
+    Error(Error),
+    Panic(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 {
+pub(crate) 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(),
@@ -49,10 +49,11 @@ pub enum Value<'lua> {
    /// `Error` is a special builtin userdata type. When received from Lua it is implicitly cloned.
    Error(Error),
 }
+
 pub use self::Value::Nil;

 impl<'lua> Value<'lua> {
-    pub fn type_name(&self) -> &'static str {
+    pub const fn type_name(&self) -> &'static str {
        match *self {
            Value::Nil => "nil",
            Value::Boolean(_) => "boolean",
@@ -157,18 +158,27 @@ pub struct MultiValue<'lua>(Vec<Value<'lua>>);

 impl<'lua> MultiValue<'lua> {
    /// Creates an empty `MultiValue` containing no values.
+    #[inline]
    pub fn new() -> MultiValue<'lua> {
        MultiValue(Vec::new())
    }
+
+    /// Similar to `new` but can return previously used container with allocated capacity.
+    #[inline]
+    pub(crate) fn new_or_cached(lua: &'lua Lua) -> MultiValue<'lua> {
+        lua.new_or_cached_multivalue()
+    }
 }

 impl<'lua> Default for MultiValue<'lua> {
+    #[inline]
    fn default() -> MultiValue<'lua> {
        MultiValue::new()
    }
 }

 impl<'lua> FromIterator<Value<'lua>> for MultiValue<'lua> {
+    #[inline]
    fn from_iter<I: IntoIterator<Item = Value<'lua>>>(iter: I) -> Self {
        MultiValue::from_vec(Vec::from_iter(iter))
    }
@@ -178,6 +188,7 @@ impl<'lua> IntoIterator for MultiValue<'lua> {
    type Item = Value<'lua>;
    type IntoIter = iter::Rev<vec::IntoIter<Value<'lua>>>;

+    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter().rev()
    }
@@ -187,46 +198,78 @@ impl<'a, 'lua> IntoIterator for &'a MultiValue<'lua> {
    type Item = &'a Value<'lua>;
    type IntoIter = iter::Rev<slice::Iter<'a, Value<'lua>>>;

+    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        (&self.0).iter().rev()
    }
 }

 impl<'lua> MultiValue<'lua> {
+    #[inline]
    pub fn from_vec(mut v: Vec<Value<'lua>>) -> MultiValue<'lua> {
        v.reverse();
        MultiValue(v)
    }

+    #[inline]
    pub fn into_vec(self) -> Vec<Value<'lua>> {
        let mut v = self.0;
        v.reverse();
        v
    }

+    #[inline]
    pub(crate) fn reserve(&mut self, size: usize) {
        self.0.reserve(size);
    }

+    #[inline]
    pub(crate) fn push_front(&mut self, value: Value<'lua>) {
        self.0.push(value);
    }

+    #[inline]
    pub(crate) fn pop_front(&mut self) -> Option<Value<'lua>> {
        self.0.pop()
    }

+    #[inline]
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+
+    #[inline]
    pub fn len(&self) -> usize {
        self.0.len()
    }

+    #[inline]
    pub fn is_empty(&self) -> bool {
-        self.0.len() == 0
+        self.0.is_empty()
    }

+    #[inline]
    pub fn iter(&self) -> iter::Rev<slice::Iter<Value<'lua>>> {
        self.0.iter().rev()
    }
+
+    #[inline]
+    pub(crate) fn drain_all(&mut self) -> iter::Rev<vec::Drain<Value<'lua>>> {
+        self.0.drain(..).rev()
+    }
+
+    #[inline]
+    pub(crate) fn refill(
+        &mut self,
+        iter: impl IntoIterator<Item = Result<Value<'lua>>>,
+    ) -> Result<()> {
+        self.0.clear();
+        for value in iter {
+            self.0.push(value?);
+        }
+        self.0.reverse();
+        Ok(())
+    }
 }

 /// Trait for types convertible to any number of Lua values.
@@ -3,7 +3,7 @@
 use std::cell::Cell;
 use std::rc::Rc;
 use std::sync::{
-    atomic::{AtomicI64, Ordering},
+    atomic::{AtomicI64, AtomicU64, Ordering},
    Arc,
 };
 use std::time::Duration;
@@ -12,7 +12,8 @@ use futures_timer::Delay;
 use futures_util::stream::TryStreamExt;

 use mlua::{
-    Error, Function, Lua, Result, Table, TableExt, Thread, UserData, UserDataMethods, Value,
+    Error, Function, Lua, LuaOptions, MetaMethod, Result, StdLib, Table, TableExt, Thread,
+    UserData, UserDataMethods, Value,
 };

 #[tokio::test]
@@ -227,7 +228,8 @@ async fn test_async_thread() -> Result<()> {

 #[tokio::test]
 async fn test_async_table() -> Result<()> {
-    let lua = Lua::new();
+    let options = LuaOptions::new().thread_cache_size(4);
+    let lua = Lua::new_with(StdLib::ALL_SAFE, options)?;

    let table = lua.create_table()?;
    table.set("val", 10)?;
@@ -276,7 +278,7 @@ async fn test_async_table() -> Result<()> {
 #[tokio::test]
 async fn test_async_userdata() -> Result<()> {
    #[derive(Clone)]
-    struct MyUserData(Arc<AtomicI64>);
+    struct MyUserData(Arc<AtomicU64>);

    impl UserData for MyUserData {
        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
@@ -295,13 +297,20 @@ async fn test_async_userdata() -> Result<()> {
                Delay::new(Duration::from_millis(n)).await;
                Ok(format!("elapsed:{}ms", n))
            });
+
+            #[cfg(not(feature = "lua51"))]
+            methods.add_async_meta_method(MetaMethod::Call, |_, data, ()| async move {
+                let n = data.0.load(Ordering::Relaxed);
+                Delay::new(Duration::from_millis(n)).await;
+                Ok(format!("elapsed:{}ms", n))
+            });
        }
    }

    let lua = Lua::new();
    let globals = lua.globals();

-    let userdata = lua.create_userdata(MyUserData(Arc::new(AtomicI64::new(11))))?;
+    let userdata = lua.create_userdata(MyUserData(Arc::new(AtomicU64::new(11))))?;
    globals.set("userdata", userdata.clone())?;

    lua.load(
@@ -315,6 +324,16 @@ async fn test_async_userdata() -> Result<()> {
    .exec_async()
    .await?;

+    #[cfg(not(feature = "lua51"))]
+    lua.load(
+        r#"
+        userdata:set_value(15)
+        assert(userdata() == "elapsed:15ms")
+    "#,
+    )
+    .exec_async()
+    .await?;
+
    Ok(())
 }

@@ -2,7 +2,7 @@ use bstr::{BStr, BString};
 use mlua::{Lua, Result};

 #[test]
-fn byte_string_round_trip() -> Result<()> {
+fn test_byte_string_round_trip() -> Result<()> {
    let lua = Lua::new();

    lua.load(
@@ -1,13 +1,13 @@
 error[E0373]: closure may outlive the current function, but it borrows `test`, which is owned by the current function
-  --> $DIR/function_borrow.rs:9:33
+  --> tests/compile/function_borrow.rs:9:33
   |
 9  |     let _ = lua.create_function(|_, ()| -> Result<i32> {
   |                                 ^^^^^^^^^^^^^^^^^^^^^^ may outlive borrowed value `test`
 10 |         Ok(test.0)
-   |            ---- `test` is borrowed here
+   |            ------ `test` is borrowed here
   |
 note: function requires argument type to outlive `'static`
-  --> $DIR/function_borrow.rs:9:13
+  --> tests/compile/function_borrow.rs:9:13
   |
 9  |       let _ = lua.create_function(|_, ()| -> Result<i32> {
   |  _____________^
@@ -17,4 +17,4 @@ note: function requires argument type to outlive `'static`
 help: to force the closure to take ownership of `test` (and any other referenced variables), use the `move` keyword
   |
 9  |     let _ = lua.create_function(move |_, ()| -> Result<i32> {
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                 ++++
@@ -1,16 +1,35 @@
 error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/lua_norefunwindsafe.rs:7:5
+   --> tests/compile/lua_norefunwindsafe.rs:7:5
    |
 7   |     catch_unwind(|| lua.create_table().unwrap());
    |     ^^^^^^^^^^^^ `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
    |
-   ::: $RUST/std/src/panic.rs
-    |
-    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
-    |
    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<()>`
    = note: required because it appears within the type `PhantomData<UnsafeCell<()>>`
    = note: required because it appears within the type `Lua`
    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
+    |
+    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
+
+error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+   --> tests/compile/lua_norefunwindsafe.rs:7:5
+    |
+7   |     catch_unwind(|| lua.create_table().unwrap());
+    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+    |
+    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
+    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>`
+    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>>`
+    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::ExtraData>>`
+    = note: required because it appears within the type `Lua`
+    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
+    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
+    |
+    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
@@ -1,14 +1,9 @@
 error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/ref_nounwindsafe.rs:8:5
+   --> tests/compile/ref_nounwindsafe.rs:8:5
    |
 8   |     catch_unwind(move || table.set("a", "b").unwrap());
    |     ^^^^^^^^^^^^ `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
    |
-   ::: $RUST/std/src/panic.rs
-    |
-    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
-    |
    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<()>`
    = note: required because it appears within the type `PhantomData<UnsafeCell<()>>`
    = note: required because it appears within the type `Lua`
@@ -16,3 +11,29 @@ error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a re
    = note: required because it appears within the type `mlua::types::LuaRef<'_>`
    = note: required because it appears within the type `LuaTable<'_>`
    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
+    |
+    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
+
+error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+   --> tests/compile/ref_nounwindsafe.rs:8:5
+    |
+8   |     catch_unwind(move || table.set("a", "b").unwrap());
+    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+    |
+    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
+    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>`
+    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>>`
+    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::ExtraData>>`
+    = note: required because it appears within the type `Lua`
+    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
+    = note: required because it appears within the type `mlua::types::LuaRef<'_>`
+    = note: required because it appears within the type `LuaTable<'_>`
+    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
+    |
+    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
@@ -1,5 +1,5 @@
 error[E0521]: borrowed data escapes outside of closure
-  --> $DIR/scope_callback_inner.rs:7:17
+  --> tests/compile/scope_callback_inner.rs:7:17
   |
 5  |       lua.scope(|scope| {
   |                  -----
@@ -16,7 +16,7 @@ error[E0521]: borrowed data escapes outside of closure
   | |______________^ `scope` escapes the closure body here

 error[E0373]: closure may outlive the current function, but it borrows `inner`, which is owned by the current function
-  --> $DIR/scope_callback_inner.rs:8:34
+  --> tests/compile/scope_callback_inner.rs:8:34
   |
 5  |     lua.scope(|scope| {
   |                ----- has type `&Scope<'_, '2>`
@@ -27,7 +27,7 @@ error[E0373]: closure may outlive the current function, but it borrows `inner`,
   |                 ----- `inner` is borrowed here
   |
 note: function requires argument type to outlive `'2`
-  --> $DIR/scope_callback_inner.rs:7:17
+  --> tests/compile/scope_callback_inner.rs:7:17
   |
 7  |           let f = scope
   |  _________________^
@@ -39,4 +39,4 @@ note: function requires argument type to outlive `'2`
 help: to force the closure to take ownership of `inner` (and any other referenced variables), use the `move` keyword
   |
 8  |             .create_function_mut(move |_, t: Table| {
-   |                                  ^^^^^^^^^^^^^^^^^^
+   |                                  ++++
@@ -1,5 +1,5 @@
 error[E0373]: closure may outlive the current function, but it borrows `test`, which is owned by the current function
-  --> $DIR/scope_invariance.rs:14:38
+  --> tests/compile/scope_invariance.rs:14:38
   |
 9  |     lua.scope(|scope| {
   |                ----- has type `&Scope<'_, '1>`
@@ -7,10 +7,10 @@ error[E0373]: closure may outlive the current function, but it borrows `test`, w
 14 |                 .create_function_mut(|_, ()| {
   |                                      ^^^^^^^ may outlive borrowed value `test`
 15 |                     test.field = 42;
-   |                     ---- `test` is borrowed here
+   |                     ---------- `test` is borrowed here
   |
 note: function requires argument type to outlive `'1`
-  --> $DIR/scope_invariance.rs:13:13
+  --> tests/compile/scope_invariance.rs:13:13
   |
 13 | /             scope
 14 | |                 .create_function_mut(|_, ()| {
@@ -22,4 +22,4 @@ note: function requires argument type to outlive `'1`
 help: to force the closure to take ownership of `test` (and any other referenced variables), use the `move` keyword
   |
 14 |                 .create_function_mut(move |_, ()| {
-   |                                      ^^^^^^^^^^^^
+   |                                      ++++
@@ -2,7 +2,7 @@ use mlua::{Lua, UserData};

 fn main() {
    struct MyUserData<'a>(&'a mut i32);
-    impl<'a> UserData for MyUserData<'a> {};
+    impl<'a> UserData for MyUserData<'a> {}

    let mut i = 1;

@@ -3,7 +3,7 @@ use mlua::{Lua, UserData};
 fn main() {
    // Should not allow userdata borrow to outlive lifetime of AnyUserData handle
    struct MyUserData<'a>(&'a i32);
-    impl<'a> UserData for MyUserData<'a> {};
+    impl<'a> UserData for MyUserData<'a> {}

    let igood = 1;

@@ -1,9 +1,9 @@
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::ffi::CString;
+use std::ffi::{CStr, CString};

 use maplit::{btreemap, btreeset, hashmap, hashset};
-use mlua::{Lua, Result};
+use mlua::{Error, Lua, Result};

 #[test]
 fn test_conv_vec() -> Result<()> {
@@ -12,7 +12,7 @@ fn test_conv_vec() -> Result<()> {
    let v = vec![1, 2, 3];
    lua.globals().set("v", v.clone())?;
    let v2: Vec<i32> = lua.globals().get("v")?;
-    assert!(v == v2);
+    assert_eq!(v, v2);

    Ok(())
 }
@@ -24,7 +24,7 @@ fn test_conv_hashmap() -> Result<()> {
    let map = hashmap! {"hello".to_string() => "world".to_string()};
    lua.globals().set("map", map.clone())?;
    let map2: HashMap<String, String> = lua.globals().get("map")?;
-    assert!(map == map2);
+    assert_eq!(map, map2);

    Ok(())
 }
@@ -36,7 +36,10 @@ fn test_conv_hashset() -> Result<()> {
    let set = hashset! {"hello".to_string(), "world".to_string()};
    lua.globals().set("set", set.clone())?;
    let set2: HashSet<String> = lua.globals().get("set")?;
-    assert!(set == set2);
+    assert_eq!(set, set2);
+
+    let set3 = lua.load(r#"{"a", "b", "c"}"#).eval::<HashSet<String>>()?;
+    assert_eq!(set3, hashset! { "a".into(), "b".into(), "c".into() });

    Ok(())
 }
@@ -48,7 +51,7 @@ fn test_conv_btreemap() -> Result<()> {
    let map = btreemap! {"hello".to_string() => "world".to_string()};
    lua.globals().set("map", map.clone())?;
    let map2: BTreeMap<String, String> = lua.globals().get("map")?;
-    assert!(map == map2);
+    assert_eq!(map, map2);

    Ok(())
 }
@@ -60,7 +63,10 @@ fn test_conv_btreeset() -> Result<()> {
    let set = btreeset! {"hello".to_string(), "world".to_string()};
    lua.globals().set("set", set.clone())?;
    let set2: BTreeSet<String> = lua.globals().get("set")?;
-    assert!(set == set2);
+    assert_eq!(set, set2);
+
+    let set3 = lua.load(r#"{"a", "b", "c"}"#).eval::<BTreeSet<String>>()?;
+    assert_eq!(set3, btreeset! { "a".into(), "b".into(), "c".into() });

    Ok(())
 }
@@ -72,7 +78,12 @@ fn test_conv_cstring() -> Result<()> {
    let s = CString::new(b"hello".to_vec()).unwrap();
    lua.globals().set("s", s.clone())?;
    let s2: CString = lua.globals().get("s")?;
-    assert!(s == s2);
+    assert_eq!(s, s2);
+
+    let cs = CStr::from_bytes_with_nul(b"hello\0").unwrap();
+    lua.globals().set("cs", cs)?;
+    let cs2: CString = lua.globals().get("cs")?;
+    assert_eq!(cs, cs2.as_c_str());

    Ok(())
 }
@@ -84,7 +95,7 @@ fn test_conv_cow() -> Result<()> {
    let s = Cow::from("hello");
    lua.globals().set("s", s.clone())?;
    let s2: String = lua.globals().get("s")?;
-    assert!(s == s2);
+    assert_eq!(s, s2);

    Ok(())
 }
@@ -96,7 +107,7 @@ fn test_conv_boxed_str() -> Result<()> {
    let s = String::from("hello").into_boxed_str();
    lua.globals().set("s", s.clone())?;
    let s2: Box<str> = lua.globals().get("s")?;
-    assert!(s == s2);
+    assert_eq!(s, s2);

    Ok(())
 }
@@ -108,7 +119,22 @@ fn test_conv_boxed_slice() -> Result<()> {
    let v = vec![1, 2, 3].into_boxed_slice();
    lua.globals().set("v", v.clone())?;
    let v2: Box<[i32]> = lua.globals().get("v")?;
-    assert!(v == v2);
+    assert_eq!(v, v2);
+
+    Ok(())
+}
+
+#[test]
+fn test_conv_array() -> Result<()> {
+    let lua = Lua::new();
+
+    let v = [1, 2, 3];
+    lua.globals().set("v", v)?;
+    let v2: [i32; 3] = lua.globals().get("v")?;
+    assert_eq!(v, v2);
+
+    let v2 = lua.globals().get::<_, [i32; 4]>("v");
+    assert!(matches!(v2, Err(Error::FromLuaConversionError { .. })));

    Ok(())
 }
@@ -76,6 +76,23 @@ fn test_rust_function() -> Result<()> {
    Ok(())
 }

+#[test]
+fn test_c_function() -> Result<()> {
+    let lua = Lua::new();
+
+    unsafe extern "C" fn c_function(state: *mut mlua::lua_State) -> std::os::raw::c_int {
+        let lua = Lua::init_from_ptr(state);
+        lua.globals().set("c_function", true).unwrap();
+        0
+    }
+
+    let func = unsafe { lua.create_c_function(c_function)? };
+    func.call(())?;
+    assert_eq!(lua.globals().get::<_, bool>("c_function")?, true);
+
+    Ok(())
+}
+
 #[test]
 fn test_dump() -> Result<()> {
    let lua = unsafe { Lua::unsafe_new() };
@@ -3,24 +3,32 @@ use std::ops::Deref;
 use std::str;
 use std::sync::{Arc, Mutex};

-use mlua::{Error, HookTriggers, Lua, Result, Value};
+use mlua::{DebugEvent, Error, HookTriggers, Lua, Result, Value};

 #[test]
-fn line_counts() -> Result<()> {
+fn test_hook_triggers_bitor() {
+    let trigger = HookTriggers::on_calls()
+        | HookTriggers::on_returns()
+        | HookTriggers::every_line()
+        | HookTriggers::every_nth_instruction(5);
+
+    assert!(trigger.on_calls);
+    assert!(trigger.on_returns);
+    assert!(trigger.every_line);
+    assert_eq!(trigger.every_nth_instruction, Some(5));
+}
+
+#[test]
+fn test_line_counts() -> Result<()> {
    let output = Arc::new(Mutex::new(Vec::new()));
    let hook_output = output.clone();

    let lua = Lua::new();
-    lua.set_hook(
-        HookTriggers {
-            every_line: true,
-            ..Default::default()
-        },
-        move |_lua, debug| {
-            hook_output.lock().unwrap().push(debug.curr_line());
-            Ok(())
-        },
-    )?;
+    lua.set_hook(HookTriggers::every_line(), move |_lua, debug| {
+        assert_eq!(debug.event(), DebugEvent::Line);
+        hook_output.lock().unwrap().push(debug.curr_line());
+        Ok(())
+    })?;
    lua.load(
        r#"
            local x = 2 + 3
@@ -43,25 +51,20 @@ fn line_counts() -> Result<()> {
 }

 #[test]
-fn function_calls() -> Result<()> {
+fn test_function_calls() -> Result<()> {
    let output = Arc::new(Mutex::new(Vec::new()));
    let hook_output = output.clone();

    let lua = Lua::new();
-    lua.set_hook(
-        HookTriggers {
-            on_calls: true,
-            ..Default::default()
-        },
-        move |_lua, debug| {
-            let names = debug.names();
-            let source = debug.source();
-            let name = names.name.map(|s| str::from_utf8(s).unwrap().to_owned());
-            let what = source.what.map(|s| str::from_utf8(s).unwrap().to_owned());
-            hook_output.lock().unwrap().push((name, what));
-            Ok(())
-        },
-    )?;
+    lua.set_hook(HookTriggers::on_calls(), move |_lua, debug| {
+        assert_eq!(debug.event(), DebugEvent::Call);
+        let names = debug.names();
+        let source = debug.source();
+        let name = names.name.map(|s| str::from_utf8(s).unwrap().to_owned());
+        let what = source.what.map(|s| str::from_utf8(s).unwrap().to_owned());
+        hook_output.lock().unwrap().push((name, what));
+        Ok(())
+    })?;

    lua.load(
        r#"
@@ -95,19 +98,14 @@ fn function_calls() -> Result<()> {
 }

 #[test]
-fn error_within_hook() -> Result<()> {
+fn test_error_within_hook() -> Result<()> {
    let lua = Lua::new();
-    lua.set_hook(
-        HookTriggers {
-            every_line: true,
-            ..Default::default()
-        },
-        |_lua, _debug| {
-            Err(Error::RuntimeError(
-                "Something happened in there!".to_string(),
-            ))
-        },
-    )?;
+
+    lua.set_hook(HookTriggers::every_line(), |_lua, _debug| {
+        Err(Error::RuntimeError(
+            "Something happened in there!".to_string(),
+        ))
+    })?;

    let err = lua
        .load("x = 1")
@@ -126,7 +124,7 @@ fn error_within_hook() -> Result<()> {
 }

 #[test]
-fn limit_execution_instructions() -> Result<()> {
+fn test_limit_execution_instructions() -> Result<()> {
    let lua = Lua::new();
    let mut max_instructions = 10000;

@@ -135,11 +133,9 @@ fn limit_execution_instructions() -> Result<()> {
    lua.load("jit.off()").exec()?;

    lua.set_hook(
-        HookTriggers {
-            every_nth_instruction: Some(30),
-            ..Default::default()
-        },
-        move |_lua, _debug| {
+        HookTriggers::every_nth_instruction(30),
+        move |_lua, debug| {
+            assert_eq!(debug.event(), DebugEvent::Count);
            max_instructions -= 30;
            if max_instructions < 0 {
                Err(Error::RuntimeError("time's up".to_string()))
@@ -165,20 +161,14 @@ fn limit_execution_instructions() -> Result<()> {
 }

 #[test]
-fn hook_removal() -> Result<()> {
+fn test_hook_removal() -> Result<()> {
    let lua = Lua::new();

-    lua.set_hook(
-        HookTriggers {
-            every_nth_instruction: Some(1),
-            ..Default::default()
-        },
-        |_lua, _debug| {
-            Err(Error::RuntimeError(
-                "this hook should've been removed by this time".to_string(),
-            ))
-        },
-    )?;
+    lua.set_hook(HookTriggers::every_nth_instruction(1), |_lua, _debug| {
+        Err(Error::RuntimeError(
+            "this hook should've been removed by this time".to_string(),
+        ))
+    })?;

    assert!(lua.load("local x = 1").exec().is_err());
    lua.remove_hook();
@@ -188,7 +178,7 @@ fn hook_removal() -> Result<()> {
 }

 #[test]
-fn hook_swap_within_hook() -> Result<()> {
+fn test_hook_swap_within_hook() -> Result<()> {
    thread_local! {
        static TL_LUA: RefCell<Option<Lua>> = RefCell::new(None);
    }
@@ -198,19 +188,14 @@ fn hook_swap_within_hook() -> Result<()> {
    });

    TL_LUA.with(|tl| {
-        tl.borrow().as_ref().unwrap().set_hook(
-            HookTriggers {
-                every_line: true,
-                ..Default::default()
-            },
-            move |lua, _debug| {
+        tl.borrow()
+            .as_ref()
+            .unwrap()
+            .set_hook(HookTriggers::every_line(), move |lua, _debug| {
                lua.globals().set("ok", 1i64)?;
                TL_LUA.with(|tl| {
                    tl.borrow().as_ref().unwrap().set_hook(
-                        HookTriggers {
-                            every_line: true,
-                            ..Default::default()
-                        },
+                        HookTriggers::every_line(),
                        move |lua, _debug| {
                            lua.load(
                                r#"
@@ -228,8 +213,7 @@ fn hook_swap_within_hook() -> Result<()> {
                        },
                    )
                })
-            },
-        )
+            })
    })?;

    TL_LUA.with(|tl| {
@@ -38,6 +38,9 @@ fn test_gc_control() -> Result<()> {
    let lua = Lua::new();
    let globals = lua.globals();

+    #[cfg(feature = "lua54")]
+    assert_eq!(lua.gc_gen(0, 0), mlua::GCMode::Incremental);
+
    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
    {
        assert!(lua.gc_is_running());
@@ -59,6 +62,9 @@ fn test_gc_control() -> Result<()> {
    lua.gc_collect()?;
    assert_eq!(Arc::strong_count(&rc), 1);

+    #[cfg(feature = "lua54")]
+    assert_eq!(lua.gc_inc(0, 0, 0), mlua::GCMode::Generational);
+
    Ok(())
 }

@@ -1,5 +1,8 @@
 [target.x86_64-apple-darwin]
 rustflags = ["-C", "link-args=-rdynamic"]

+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-args=-rdynamic"]
+
 [target.x86_64-unknown-linux-gnu]
 rustflags = ["-C", "link-args=-rdynamic"]
@@ -15,6 +15,32 @@ fn test_module() -> Result<()> {
    .exec()
 }

+#[test]
+fn test_module_multi() -> Result<()> {
+    let lua = make_lua()?;
+    lua.load(
+        r#"
+        local mod = require("rust_module")
+        local mod2 = require("rust_module.second")
+        assert(mod.check_userdata(mod2.userdata) == 123)
+    "#,
+    )
+    .exec()
+}
+
+#[test]
+fn test_module_error() -> Result<()> {
+    let lua = make_lua()?;
+    lua.load(
+        r#"
+        local ok, err = pcall(require, "rust_module.error")
+        assert(not ok)
+        assert(string.find(tostring(err), "custom module error"))
+    "#,
+    )
+    .exec()
+}
+
 #[cfg(any(
    feature = "lua54",
    feature = "lua53",
@@ -8,7 +8,7 @@ use mlua::{
 };

 #[test]
-fn scope_func() -> Result<()> {
+fn test_scope_func() -> Result<()> {
    let lua = Lua::new();

    let rc = Rc::new(Cell::new(0));
@@ -38,7 +38,7 @@ fn scope_func() -> Result<()> {
 }

 #[test]
-fn scope_capture() -> Result<()> {
+fn test_scope_capture() -> Result<()> {
    let lua = Lua::new();

    let mut i = 0;
@@ -56,7 +56,7 @@ fn scope_capture() -> Result<()> {
 }

 #[test]
-fn scope_outer_lua_access() -> Result<()> {
+fn test_scope_outer_lua_access() -> Result<()> {
    let lua = Lua::new();

    let table = lua.create_table()?;
@@ -71,7 +71,7 @@ fn scope_outer_lua_access() -> Result<()> {
 }

 #[test]
-fn scope_userdata_fields() -> Result<()> {
+fn test_scope_userdata_fields() -> Result<()> {
    struct MyUserData<'a>(&'a Cell<i64>);

    impl<'a> UserData for MyUserData<'a> {
@@ -106,7 +106,7 @@ fn scope_userdata_fields() -> Result<()> {
 }

 #[test]
-fn scope_userdata_methods() -> Result<()> {
+fn test_scope_userdata_methods() -> Result<()> {
    struct MyUserData<'a>(&'a Cell<i64>);

    impl<'a> UserData for MyUserData<'a> {
@@ -147,7 +147,7 @@ fn scope_userdata_methods() -> Result<()> {
 }

 #[test]
-fn scope_userdata_functions() -> Result<()> {
+fn test_scope_userdata_functions() -> Result<()> {
    struct MyUserData<'a>(&'a i64);

    impl<'a> UserData for MyUserData<'a> {
@@ -189,7 +189,7 @@ fn scope_userdata_functions() -> Result<()> {
 }

 #[test]
-fn scope_userdata_mismatch() -> Result<()> {
+fn test_scope_userdata_mismatch() -> Result<()> {
    struct MyUserData<'a>(&'a Cell<i64>);

    impl<'a> UserData for MyUserData<'a> {
@@ -241,7 +241,7 @@ fn scope_userdata_mismatch() -> Result<()> {
 }

 #[test]
-fn scope_userdata_drop() -> Result<()> {
+fn test_scope_userdata_drop() -> Result<()> {
    let lua = Lua::new();

    struct MyUserData(Rc<()>);
@@ -299,7 +299,7 @@ fn scope_userdata_drop() -> Result<()> {
 }

 #[test]
-fn scope_nonstatic_userdata_drop() -> Result<()> {
+fn test_scope_nonstatic_userdata_drop() -> Result<()> {
    let lua = Lua::new();

    struct MyUserData<'a>(&'a Cell<i64>, Arc<()>);
@@ -2,7 +2,10 @@

 use std::collections::HashMap;

-use mlua::{Error, Lua, LuaSerdeExt, Result as LuaResult, SerializeOptions, UserData, Value};
+use mlua::{
+    DeserializeOptions, Error, Lua, LuaSerdeExt, Result as LuaResult, SerializeOptions, UserData,
+    Value,
+};
 use serde::{Deserialize, Serialize};

 #[test]
@@ -175,30 +178,6 @@ fn test_to_value_struct() -> LuaResult<()> {
 fn test_to_value_enum() -> LuaResult<()> {
    let lua = Lua::new();
    let globals = lua.globals();
-    globals.set("null", lua.null())?;
-
-    #[derive(Serialize)]
-    struct Test {
-        name: String,
-        key: i64,
-        data: Option<bool>,
-    }
-
-    let test = Test {
-        name: "alex".to_string(),
-        key: -16,
-        data: None,
-    };
-
-    globals.set("value", lua.to_value(&test)?)?;
-    lua.load(
-        r#"
-            assert(value["name"] == "alex")
-            assert(value["key"] == -16)
-            assert(value["data"] == null)
-        "#,
-    )
-    .exec()?;

    #[derive(Serialize)]
    enum E {
@@ -302,6 +281,36 @@ fn test_to_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

+#[test]
+fn test_from_value_nested_tables() -> Result<(), Box<dyn std::error::Error>> {
+    let lua = Lua::new();
+
+    let value = lua
+        .load(
+            r#"
+            local table_a = {a = "a"}
+            local table_b = {"b"}
+            return {
+                a = table_a,
+                b = {table_b, table_b},
+                ab = {a = table_a, b = table_b}
+            }
+        "#,
+        )
+        .eval::<Value>()?;
+    let got = lua.from_value::<serde_json::Value>(value)?;
+    assert_eq!(
+        got,
+        serde_json::json!({
+            "a": {"a": "a"},
+            "b": [["b"], ["b"]],
+            "ab": {"a": {"a": "a"}, "b": ["b"]},
+        })
+    );
+
+    Ok(())
+}
+
 #[test]
 fn test_from_value_struct() -> Result<(), Box<dyn std::error::Error>> {
    let lua = Lua::new();
@@ -310,7 +319,7 @@ fn test_from_value_struct() -> Result<(), Box<dyn std::error::Error>> {
    struct Test {
        int: u32,
        seq: Vec<String>,
-        map: std::collections::HashMap<i32, i32>,
+        map: HashMap<i32, i32>,
        empty: Vec<()>,
        tuple: (u8, u8, u8),
    }
@@ -413,3 +422,60 @@ fn test_from_value_enum_untagged() -> Result<(), Box<dyn std::error::Error>> {

    Ok(())
 }
+
+#[test]
+fn test_from_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
+    let lua = Lua::new();
+
+    // Deny unsupported types by default
+    let value = Value::Function(lua.create_function(|_, ()| Ok(()))?);
+    match lua.from_value::<Option<String>>(value) {
+        Ok(v) => panic!("expected deserialization error, got {:?}", v),
+        Err(Error::DeserializeError(err)) => {
+            assert!(err.contains("unsupported value type"))
+        }
+        Err(err) => panic!("expected `DeserializeError` error, got {:?}", err),
+    };
+
+    // Allow unsupported types
+    let value = Value::Function(lua.create_function(|_, ()| Ok(()))?);
+    let options = DeserializeOptions::new().deny_unsupported_types(false);
+    assert_eq!(lua.from_value_with::<()>(value, options)?, ());
+
+    // Allow unsupported types (in a table seq)
+    let value = lua.load(r#"{"a", "b", function() end, "c"}"#).eval()?;
+    let options = DeserializeOptions::new().deny_unsupported_types(false);
+    assert_eq!(
+        lua.from_value_with::<Vec<String>>(value, options)?,
+        vec!["a".to_string(), "b".to_string(), "c".to_string()]
+    );
+
+    // Deny recursive tables by default
+    let value = lua.load(r#"local t = {}; t.t = t; return t"#).eval()?;
+    match lua.from_value::<HashMap<String, Option<String>>>(value) {
+        Ok(v) => panic!("expected deserialization error, got {:?}", v),
+        Err(Error::DeserializeError(err)) => {
+            assert!(err.contains("recursive table detected"))
+        }
+        Err(err) => panic!("expected `DeserializeError` error, got {:?}", err),
+    };
+
+    // Check recursion when using `Serialize` impl
+    let t = lua.create_table()?;
+    t.set("t", t.clone())?;
+    assert!(serde_json::to_string(&t).is_err());
+
+    // Serialize Lua globals table
+    #[derive(Debug, Deserialize)]
+    struct Globals {
+        hello: String,
+    }
+    let options = DeserializeOptions::new()
+        .deny_unsupported_types(false)
+        .deny_recursive_tables(false);
+    lua.load(r#"hello = "world""#).exec()?;
+    let globals: Globals = lua.from_value_with(Value::Table(lua.globals()), options)?;
+    assert_eq!(globals.hello, "world");
+
+    Ok(())
+}
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use mlua::{Lua, Result, String};

 #[test]
-fn compare() {
+fn test_string_compare() {
    fn with_str<F: FnOnce(String)>(s: &str, f: F) {
        f(Lua::new().create_string(s).unwrap());
    }
@@ -21,7 +21,7 @@ fn compare() {
 }

 #[test]
-fn string_views() -> Result<()> {
+fn test_string_views() -> Result<()> {
    let lua = Lua::new();

    lua.load(
@@ -39,6 +39,10 @@ fn string_views() -> Result<()> {
    let empty: String = globals.get("empty")?;

    assert_eq!(ok.to_str()?, "null bytes are valid utf-8, wh\0 knew?");
+    assert_eq!(
+        ok.to_string_lossy(),
+        "null bytes are valid utf-8, wh\0 knew?"
+    );
    assert_eq!(
        ok.as_bytes(),
        &b"null bytes are valid utf-8, wh\0 knew?"[..]
@@ -55,7 +59,7 @@ fn string_views() -> Result<()> {
 }

 #[test]
-fn raw_string() -> Result<()> {
+fn test_raw_string() -> Result<()> {
    let lua = Lua::new();

    let rs = lua.create_string(&[0, 1, 2, 3, 0, 1, 2, 3])?;
@@ -1,4 +1,4 @@
-use mlua::{Lua, Nil, Result, Table, TableExt, Value};
+use mlua::{Error, Lua, Nil, Result, Table, TableExt, Value};

 #[test]
 fn test_set_get() -> Result<()> {
@@ -139,14 +139,6 @@ fn test_table_sequence_from() -> Result<()> {
        vec![1, 2, 3]
    );

-    assert_eq!(
-        get_table
-            .call::<_, Table>(&[1, 2, 3])?
-            .sequence_values()
-            .collect::<Result<Vec<i64>>>()?,
-        vec![1, 2, 3]
-    );
-
    Ok(())
 }

@@ -274,7 +266,12 @@ fn test_table_call() -> Result<()> {

    lua.load(
        r#"
-        table = {a = 1}
+        table = {a = 1, b = 2}
+        setmetatable(table, {
+            __call = function(t, key)
+                return "call_"..t[key]
+            end
+        })

        function table.func(key)
            return "func_"..key
@@ -289,11 +286,19 @@ fn test_table_call() -> Result<()> {

    let table: Table = lua.globals().get("table")?;

+    assert_eq!(table.call::<_, String>("b")?, "call_2");
    assert_eq!(table.call_function::<_, _, String>("func", "a")?, "func_a");
    assert_eq!(
        table.call_method::<_, _, String>("method", "a")?,
        "method_1"
    );

+    // Test calling non-callable table
+    let table2 = lua.create_table()?;
+    assert!(matches!(
+        table2.call::<_, ()>(()),
+        Err(Error::RuntimeError(_))
+    ));
+
    Ok(())
 }
@@ -1,6 +1,8 @@
+use std::collections::HashMap;
 use std::iter::FromIterator;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::string::String as StdString;
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
 use std::{error, f32, f64, fmt};

@@ -82,6 +84,7 @@ fn test_safety() -> Result<()> {
 #[test]
 fn test_load() -> Result<()> {
    let lua = Lua::new();
+
    let func = lua.load("return 1+2").into_function()?;
    let result: i32 = func.call(())?;
    assert_eq!(result, 3);
@@ -394,7 +397,7 @@ fn test_panic() -> Result<()> {
        Ok(lua)
    }

-    // Test triggerting Lua error passing Rust panic (must be resumed)
+    // Test triggering Lua error with sending Rust panic (must be resumed)
    {
        let lua = make_lua(LuaOptions::default())?;

@@ -450,7 +453,7 @@ fn test_panic() -> Result<()> {
        }
    }

-    // Test representing rust panic as a string
+    // Test representing Rust panic as a string
    match catch_unwind(|| -> Result<()> {
        let lua = make_lua(LuaOptions::default())?;
        lua.load(
@@ -485,7 +488,7 @@ fn test_panic() -> Result<()> {
        Err(p) => assert!(*p.downcast::<StdString>().unwrap() == "rust panic from lua"),
    }

-    // Test enabling `catch_rust_panics` option / xpcall correctness
+    // Test disabling `catch_rust_panics` option / xpcall correctness
    match catch_unwind(|| -> Result<()> {
        let lua = make_lua(LuaOptions::new().catch_rust_panics(false))?;
        lua.load(
@@ -611,7 +614,7 @@ fn test_pcall_xpcall() -> Result<()> {
    assert!(lua.load("xpcall()").exec().is_err());
    assert!(lua.load("xpcall(function() end)").exec().is_err());

-    // Lua 5.3/5.2 / LuaJIT compatible version of xpcall
+    // Lua >= 5.2 compatible version of xpcall for 5.1
    #[cfg(feature = "lua51")]
    lua.load(
        r#"
@@ -797,6 +800,23 @@ fn test_drop_registry_value() -> Result<()> {
    Ok(())
 }

+#[test]
+fn test_lua_registry_hash() -> Result<()> {
+    let lua = Lua::new();
+
+    let r1 = Arc::new(lua.create_registry_value("value1")?);
+    let r2 = Arc::new(lua.create_registry_value("value2")?);
+
+    let mut map = HashMap::new();
+    map.insert(r1.clone(), "value1");
+    map.insert(r2.clone(), "value2");
+
+    assert_eq!(map[&r1], "value1");
+    assert_eq!(map[&r2], "value2");
+
+    Ok(())
+}
+
 #[test]
 fn test_lua_registry_ownership() -> Result<()> {
    let lua1 = Lua::new();
@@ -828,7 +848,57 @@ fn test_mismatched_registry_key() -> Result<()> {
 }

 #[test]
-fn too_many_returns() -> Result<()> {
+fn test_application_data() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.set_app_data("test1");
+    lua.set_app_data(vec!["test2"]);
+
+    let f = lua.create_function(|lua, ()| {
+        {
+            let data1 = lua.app_data_ref::<&str>().unwrap();
+            assert_eq!(*data1, "test1");
+        }
+        let mut data2 = lua.app_data_mut::<Vec<&str>>().unwrap();
+        assert_eq!(*data2, vec!["test2"]);
+        data2.push("test3");
+        Ok(())
+    })?;
+    f.call(())?;
+
+    assert_eq!(*lua.app_data_ref::<&str>().unwrap(), "test1");
+    assert_eq!(
+        *lua.app_data_ref::<Vec<&str>>().unwrap(),
+        vec!["test2", "test3"]
+    );
+
+    lua.remove_app_data::<Vec<&str>>();
+    assert!(matches!(lua.app_data_ref::<Vec<&str>>(), None));
+
+    Ok(())
+}
+
+#[test]
+fn test_recursion() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = lua.create_function(move |lua, i: i32| {
+        if i < 64 {
+            lua.globals()
+                .get::<_, Function>("f")?
+                .call::<_, ()>(i + 1)?;
+        }
+        Ok(())
+    })?;
+
+    lua.globals().set("f", f.clone())?;
+    f.call::<_, ()>(1)?;
+
+    Ok(())
+}
+
+#[test]
+fn test_too_many_returns() -> Result<()> {
    let lua = Lua::new();
    let f = lua.create_function(|_, ()| Ok(Variadic::from_iter(1..1000000)))?;
    assert!(f.call::<_, Vec<u32>>(()).is_err());
@@ -836,7 +906,7 @@ fn too_many_returns() -> Result<()> {
 }

 #[test]
-fn too_many_arguments() -> Result<()> {
+fn test_too_many_arguments() -> Result<()> {
    let lua = Lua::new();
    lua.load("function test(...) end").exec()?;
    let args = Variadic::from_iter(1..1000000);
@@ -850,23 +920,20 @@ fn too_many_arguments() -> Result<()> {

 #[test]
 #[cfg(not(feature = "luajit"))]
-fn too_many_recursions() -> Result<()> {
+fn test_too_many_recursions() -> Result<()> {
    let lua = Lua::new();
+
    let f = lua
        .create_function(move |lua, ()| lua.globals().get::<_, Function>("f")?.call::<_, ()>(()))?;
-    lua.globals().set("f", f)?;

-    assert!(lua
-        .globals()
-        .get::<_, Function>("f")?
-        .call::<_, ()>(())
-        .is_err());
+    lua.globals().set("f", f.clone())?;
+    assert!(f.call::<_, ()>(()).is_err());

    Ok(())
 }

 #[test]
-fn too_many_binds() -> Result<()> {
+fn test_too_many_binds() -> Result<()> {
    let lua = Lua::new();
    let globals = lua.globals();
    lua.load(
@@ -905,7 +972,7 @@ fn test_ref_stack_exhaustion() {
 }

 #[test]
-fn large_args() -> Result<()> {
+fn test_large_args() -> Result<()> {
    let lua = Lua::new();
    let globals = lua.globals();

@@ -940,7 +1007,7 @@ fn large_args() -> Result<()> {
 }

 #[test]
-fn large_args_ref() -> Result<()> {
+fn test_large_args_ref() -> Result<()> {
    let lua = Lua::new();

    let f = lua.create_function(|_, args: Variadic<String>| {
@@ -956,7 +1023,7 @@ fn large_args_ref() -> Result<()> {
 }

 #[test]
-fn chunk_env() -> Result<()> {
+fn test_chunk_env() -> Result<()> {
    let lua = Lua::new();

    let assert: Function = lua.globals().get("assert")?;
@@ -998,7 +1065,7 @@ fn chunk_env() -> Result<()> {
 }

 #[test]
-fn context_thread() -> Result<()> {
+fn test_context_thread() -> Result<()> {
    let lua = Lua::new();

    let f = lua
@@ -1010,18 +1077,23 @@ fn context_thread() -> Result<()> {
        )
        .into_function()?;

-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52"
+    ))]
    f.call::<_, ()>(lua.current_thread())?;

-    #[cfg(any(feature = "lua51", feature = "luajit"))]
+    #[cfg(any(feature = "lua51", all(feature = "luajit", not(feature = "luajit52"))))]
    f.call::<_, ()>(Nil)?;

    Ok(())
 }

 #[test]
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-fn context_thread_51() -> Result<()> {
+#[cfg(any(feature = "lua51", all(feature = "luajit", not(feature = "luajit52"))))]
+fn test_context_thread_51() -> Result<()> {
    let lua = Lua::new();

    let thread = lua.create_thread(
@@ -1051,3 +1123,136 @@ fn test_jit_version() -> Result<()> {
        .contains("LuaJIT"));
    Ok(())
 }
+
+#[test]
+fn test_load_from_function() -> Result<()> {
+    let lua = Lua::new();
+
+    let i = Arc::new(AtomicU32::new(0));
+    let i2 = i.clone();
+    let func = lua.create_function(move |lua, modname: String| {
+        i2.fetch_add(1, Ordering::Relaxed);
+        let t = lua.create_table()?;
+        t.set("__name", modname)?;
+        Ok(t)
+    })?;
+
+    let t: Table = lua.load_from_function("my_module", func.clone())?;
+    assert_eq!(t.get::<_, String>("__name")?, "my_module");
+    assert_eq!(i.load(Ordering::Relaxed), 1);
+
+    let _: Value = lua.load_from_function("my_module", func.clone())?;
+    assert_eq!(i.load(Ordering::Relaxed), 1);
+
+    let func_nil = lua.create_function(move |_, _: String| Ok(Value::Nil))?;
+    let v: Value = lua.load_from_function("my_module2", func_nil)?;
+    assert_eq!(v, Value::Boolean(true));
+
+    // Test unloading and loading again
+    lua.unload("my_module")?;
+    let _: Value = lua.load_from_function("my_module", func)?;
+    assert_eq!(i.load(Ordering::Relaxed), 2);
+
+    // Unloading nonexistent module must not fail
+    lua.unload("my_module2")?;
+
+    Ok(())
+}
+
+#[test]
+fn test_inspect_stack() -> Result<()> {
+    let lua = Lua::new();
+
+    // Not inside any function
+    assert!(lua.inspect_stack(0).is_none());
+
+    let logline = lua.create_function(|lua, msg: StdString| {
+        let debug = lua.inspect_stack(1).unwrap(); // caller
+        let source = debug.source().short_src.map(core::str::from_utf8);
+        let source = source.transpose().unwrap().unwrap_or("?");
+        let line = debug.curr_line();
+        Ok(format!("{}:{} {}", source, line, msg))
+    })?;
+    lua.globals().set("logline", logline)?;
+
+    lua.load(
+        r#"
+        local function foo()
+            local line = logline("hello")
+            return line
+        end
+        local function bar()
+            return foo()
+        end
+
+        assert(foo() == '[string "chunk"]:3 hello')
+        assert(bar() == '[string "chunk"]:3 hello')
+        assert(logline("world") == '[string "chunk"]:12 world')
+    "#,
+    )
+    .set_name("chunk")?
+    .exec()?;
+
+    Ok(())
+}
+
+#[test]
+fn test_multi_states() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = lua.create_function(|_, g: Option<Function>| {
+        if let Some(g) = g {
+            g.call(())?;
+        }
+        Ok(())
+    })?;
+    lua.globals().set("f", f)?;
+
+    lua.load("f(function() coroutine.wrap(function() f() end)() end)")
+        .exec()?;
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "lua54")]
+fn test_warnings() -> Result<()> {
+    let lua = Lua::new();
+    lua.set_app_data::<Vec<(StdString, bool)>>(Vec::new());
+
+    lua.set_warning_function(|lua, msg, tocont| {
+        let msg = msg.to_string_lossy().to_string();
+        lua.app_data_mut::<Vec<(StdString, bool)>>()
+            .unwrap()
+            .push((msg, tocont));
+        Ok(())
+    });
+
+    lua.warning("native warning ...", true)?;
+    lua.warning("finish", false)?;
+    lua.load(r#"warn("lua warning", "continue")"#).exec()?;
+
+    lua.remove_warning_function();
+    lua.warning("one more warning", false)?;
+
+    let messages = lua.app_data_ref::<Vec<(StdString, bool)>>().unwrap();
+    assert_eq!(
+        *messages,
+        vec![
+            ("native warning ...".to_string(), true),
+            ("finish".to_string(), false),
+            ("lua warning".to_string(), true),
+            ("continue".to_string(), false),
+        ]
+    );
+
+    // Trigger error inside warning
+    lua.set_warning_function(|_, _, _| Err(Error::RuntimeError("warning error".to_string())));
+    assert!(matches!(
+        lua.load(r#"warn("test")"#).exec(),
+        Err(Error::CallbackError { cause, .. })
+            if matches!(*cause, Error::RuntimeError(ref err) if err == "warning error")
+    ));
+
+    Ok(())
+}
@@ -93,8 +93,8 @@ fn test_thread() -> Result<()> {
    Ok(())
 }

-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
 #[test]
+#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
 fn test_thread_reset() -> Result<()> {
    use mlua::{AnyUserData, UserData};
    use std::sync::Arc;
@@ -137,7 +137,7 @@ fn test_thread_reset() -> Result<()> {
 }

 #[test]
-fn coroutine_from_closure() -> Result<()> {
+fn test_coroutine_from_closure() -> Result<()> {
    let lua = Lua::new();

    let thrd_main = lua.create_function(|_, ()| Ok(()))?;
@@ -161,7 +161,7 @@ fn coroutine_from_closure() -> Result<()> {
 }

 #[test]
-fn coroutine_panic() {
+fn test_coroutine_panic() {
    match catch_unwind(|| -> Result<()> {
        // check that coroutines propagate panics correctly
        let lua = Lua::new();
@@ -1,4 +1,7 @@
-use std::sync::Arc;
+use std::sync::{Arc, Mutex, RwLock};
+
+#[cfg(not(feature = "send"))]
+use std::{cell::RefCell, rc::Rc};

 #[cfg(feature = "lua54")]
 use std::sync::atomic::{AtomicI64, Ordering};
@@ -33,6 +36,7 @@ fn test_user_data() -> Result<()> {

 #[test]
 fn test_methods() -> Result<()> {
+    #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
    struct MyUserData(i64);

    impl UserData for MyUserData {
@@ -45,29 +49,38 @@ fn test_methods() -> Result<()> {
        }
    }

-    let lua = Lua::new();
-    let globals = lua.globals();
-    let userdata = lua.create_userdata(MyUserData(42))?;
-    globals.set("userdata", userdata.clone())?;
-    lua.load(
-        r#"
-        function get_it()
-            return userdata:get_value()
-        end
+    fn check_methods(lua: &Lua, userdata: AnyUserData) -> Result<()> {
+        let globals = lua.globals();
+        globals.set("userdata", userdata.clone())?;
+        lua.load(
+            r#"
+            function get_it()
+                return userdata:get_value()
+            end

-        function set_it(i)
-            return userdata:set_value(i)
-        end
-    "#,
-    )
-    .exec()?;
-    let get = globals.get::<_, Function>("get_it")?;
-    let set = globals.get::<_, Function>("set_it")?;
-    assert_eq!(get.call::<_, i64>(())?, 42);
-    userdata.borrow_mut::<MyUserData>()?.0 = 64;
-    assert_eq!(get.call::<_, i64>(())?, 64);
-    set.call::<_, ()>(100)?;
-    assert_eq!(get.call::<_, i64>(())?, 100);
+            function set_it(i)
+                return userdata:set_value(i)
+            end
+        "#,
+        )
+        .exec()?;
+        let get = globals.get::<_, Function>("get_it")?;
+        let set = globals.get::<_, Function>("set_it")?;
+        assert_eq!(get.call::<_, i64>(())?, 42);
+        userdata.borrow_mut::<MyUserData>()?.0 = 64;
+        assert_eq!(get.call::<_, i64>(())?, 64);
+        set.call::<_, ()>(100)?;
+        assert_eq!(get.call::<_, i64>(())?, 100);
+        Ok(())
+    }
+
+    let lua = Lua::new();
+
+    check_methods(&lua, lua.create_userdata(MyUserData(42))?)?;
+
+    // Additionally check serializable userdata
+    #[cfg(feature = "serialize")]
+    check_methods(&lua, lua.create_ser_userdata(MyUserData(42))?)?;

    Ok(())
 }
@@ -98,7 +111,12 @@ fn test_metamethods() -> Result<()> {
                    Err("no such custom index".to_lua_err())
                }
            });
-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "luajit52"
+            ))]
            methods.add_meta_method(MetaMethod::Pairs, |lua, data, ()| {
                use std::iter::FromIterator;
                let stateless_iter = lua.create_function(|_, (data, i): (MyUserData, i64)| {
@@ -123,11 +141,16 @@ fn test_metamethods() -> Result<()> {
        10
    );

-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    let pairs_it = {
-        lua.load(
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52"
+    ))]
+    let pairs_it = lua
+        .load(
            r#"
-            function pairs_it()
+            function()
                local r = 0
                for i, v in pairs(userdata1) do
                    r = r + v
@@ -136,17 +159,21 @@ fn test_metamethods() -> Result<()> {
            end
        "#,
        )
-        .exec()?;
-        globals.get::<_, Function>("pairs_it")?
-    };
+        .eval::<Function>()?;

    assert_eq!(lua.load("userdata1 - userdata2").eval::<MyUserData>()?.0, 4);
    assert_eq!(lua.load("userdata1:get()").eval::<i64>()?, 7);
    assert_eq!(lua.load("userdata2.inner").eval::<i64>()?, 3);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    assert_eq!(pairs_it.call::<_, i64>(())?, 28);
    assert!(lua.load("userdata2.nonexist_field").eval::<()>().is_err());

+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52"
+    ))]
+    assert_eq!(pairs_it.call::<_, i64>(())?, 28);
+
    let userdata2: Value = globals.get("userdata2")?;
    let userdata3: Value = globals.get("userdata3")?;

@@ -249,6 +276,79 @@ fn test_gc_userdata() -> Result<()> {
    Ok(())
 }

+#[test]
+fn test_userdata_take() -> Result<()> {
+    #[derive(Debug)]
+    struct MyUserdata(Arc<i64>);
+
+    impl UserData for MyUserdata {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_method("num", |_, this, ()| Ok(*this.0))
+        }
+    }
+
+    #[cfg(feature = "serialize")]
+    impl serde::Serialize for MyUserdata {
+        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer,
+        {
+            serializer.serialize_i64(*self.0)
+        }
+    }
+
+    fn check_userdata_take(lua: &Lua, userdata: AnyUserData, rc: Arc<i64>) -> Result<()> {
+        lua.globals().set("userdata", userdata.clone())?;
+        assert_eq!(Arc::strong_count(&rc), 3);
+        let userdata_copy = userdata.clone();
+        {
+            let _value = userdata.borrow::<MyUserdata>()?;
+            // We should not be able to take userdata if it's borrowed
+            match userdata_copy.take::<MyUserdata>() {
+                Err(Error::UserDataBorrowMutError) => {}
+                r => panic!("expected `UserDataBorrowMutError` error, got {:?}", r),
+            }
+        }
+
+        let value = userdata_copy.take::<MyUserdata>()?;
+        assert_eq!(*value.0, 18);
+        drop(value);
+        lua.gc_collect()?;
+        assert_eq!(Arc::strong_count(&rc), 1);
+
+        match userdata.borrow::<MyUserdata>() {
+            Err(Error::UserDataDestructed) => {}
+            r => panic!("expected `UserDataDestructed` error, got {:?}", r),
+        }
+        match lua.load("userdata:num()").exec() {
+            Err(Error::CallbackError { ref cause, .. }) => match cause.as_ref() {
+                Error::CallbackDestructed => {}
+                err => panic!("expected `CallbackDestructed`, got {:?}", err),
+            },
+            r => panic!("improper return for destructed userdata: {:?}", r),
+        }
+        Ok(())
+    }
+
+    let lua = Lua::new();
+
+    let rc = Arc::new(18);
+    let userdata = lua.create_userdata(MyUserdata(rc.clone()))?;
+    userdata.set_nth_user_value(2, MyUserdata(rc.clone()))?;
+    check_userdata_take(&lua, userdata, rc)?;
+
+    // Additionally check serializable userdata
+    #[cfg(feature = "serialize")]
+    {
+        let rc = Arc::new(18);
+        let userdata = lua.create_ser_userdata(MyUserdata(rc.clone()))?;
+        userdata.set_nth_user_value(2, MyUserdata(rc.clone()))?;
+        check_userdata_take(&lua, userdata, rc)?;
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_destroy_userdata() -> Result<()> {
    struct MyUserdata(Arc<()>);
@@ -272,16 +372,32 @@ fn test_destroy_userdata() -> Result<()> {
 }

 #[test]
-fn test_user_value() -> Result<()> {
+fn test_user_values() -> Result<()> {
    struct MyUserData;

    impl UserData for MyUserData {}

    let lua = Lua::new();
    let ud = lua.create_userdata(MyUserData)?;
-    ud.set_user_value("hello")?;
-    assert_eq!(ud.get_user_value::<String>()?, "hello");
-    assert!(ud.get_user_value::<u32>().is_err());
+
+    ud.set_nth_user_value(1, "hello")?;
+    ud.set_nth_user_value(2, "world")?;
+    ud.set_nth_user_value(65535, 321)?;
+    assert_eq!(ud.get_nth_user_value::<String>(1)?, "hello");
+    assert_eq!(ud.get_nth_user_value::<String>(2)?, "world");
+    assert_eq!(ud.get_nth_user_value::<Value>(3)?, Value::Nil);
+    assert_eq!(ud.get_nth_user_value::<i32>(65535)?, 321);
+
+    assert!(ud.get_nth_user_value::<Value>(0).is_err());
+    assert!(ud.get_nth_user_value::<Value>(65536).is_err());
+
+    // Named user values
+    ud.set_named_user_value("name", "alex")?;
+    ud.set_named_user_value("age", 10)?;
+
+    assert_eq!(ud.get_named_user_value::<_, String>("name")?, "alex");
+    assert_eq!(ud.get_named_user_value::<_, i32>("age")?, 10);
+    assert_eq!(ud.get_named_user_value::<_, Value>("nonexist")?, Value::Nil);

    Ok(())
 }
@@ -359,6 +475,12 @@ fn test_fields() -> Result<()> {
                index.set("f", 321)?;
                Ok(index)
            });
+            fields.add_meta_field_with(MetaMethod::NewIndex, |lua| {
+                lua.create_function(|lua, (_, field, val): (AnyUserData, String, Value)| {
+                    lua.globals().set(field, val)?;
+                    Ok(())
+                })
+            })
        }
    }

@@ -376,6 +498,9 @@ fn test_fields() -> Result<()> {
        assert(ud.uval == "hello")

        assert(ud.f == 321)
+
+        ud.unknown = 789
+        assert(unknown == 789)
    "#,
    )
    .exec()?;
@@ -451,3 +576,69 @@ fn test_metatable() -> Result<()> {

    Ok(())
 }
+
+#[test]
+fn test_userdata_wrapped() -> Result<()> {
+    struct MyUserData(i64);
+
+    impl UserData for MyUserData {
+        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field_method_get("data", |_, this| Ok(this.0));
+            fields.add_field_method_set("data", |_, this, val| {
+                this.0 = val;
+                Ok(())
+            })
+        }
+    }
+
+    let lua = Lua::new();
+    let globals = lua.globals();
+
+    #[cfg(not(feature = "send"))]
+    {
+        let ud1 = Rc::new(RefCell::new(MyUserData(1)));
+        globals.set("rc_refcell_ud", ud1.clone())?;
+        lua.load(
+            r#"
+            rc_refcell_ud.data = rc_refcell_ud.data + 1
+            assert(rc_refcell_ud.data == 2)
+        "#,
+        )
+        .exec()?;
+        assert_eq!(ud1.borrow().0, 2);
+        globals.set("rc_refcell_ud", Nil)?;
+        lua.gc_collect()?;
+        assert_eq!(Rc::strong_count(&ud1), 1);
+    }
+
+    let ud2 = Arc::new(Mutex::new(MyUserData(2)));
+    globals.set("arc_mutex_ud", ud2.clone())?;
+    lua.load(
+        r#"
+        arc_mutex_ud.data = arc_mutex_ud.data + 1
+        assert(arc_mutex_ud.data == 3)
+    "#,
+    )
+    .exec()?;
+    assert_eq!(ud2.lock().unwrap().0, 3);
+
+    let ud3 = Arc::new(RwLock::new(MyUserData(3)));
+    globals.set("arc_rwlock_ud", ud3.clone())?;
+    lua.load(
+        r#"
+        arc_rwlock_ud.data = arc_rwlock_ud.data + 1
+        assert(arc_rwlock_ud.data == 4)
+    "#,
+    )
+    .exec()?;
+    assert_eq!(ud3.read().unwrap().0, 4);
+
+    // Test drop
+    globals.set("arc_mutex_ud", Nil)?;
+    globals.set("arc_rwlock_ud", Nil)?;
+    lua.gc_collect()?;
+    assert_eq!(Arc::strong_count(&ud2), 1);
+    assert_eq!(Arc::strong_count(&ud3), 1);
+
+    Ok(())
+}
Author	SHA1	Message	Date
Alex Orlenko	418e8fba32	v0.7.2	2022-01-17 11:12:46 +00:00
Alex Orlenko	08a7e30820	Update README	2022-01-17 11:11:56 +00:00
Alex Orlenko	19676bda40	Update CHANGELOG	2022-01-16 23:50:26 +00:00
Alex Orlenko	5a06778fbc	Always restore original Lua state after creating Future in async call. Fixes #121	2022-01-16 20:57:43 +00:00
Alex Orlenko	e33bdddc7a	Pass Box wrapped pointer to allocator fn instead of reference	2022-01-08 23:06:01 +00:00
Alex Orlenko	cfb5d3fd45	Fix clippy warnings	2021-12-28 12:23:06 +00:00
Alex Orlenko	84a174c94d	Allow `pkg-config` to omit include paths if they equals to standard. See #114	2021-12-28 12:02:02 +00:00
Alex Orlenko	888b2bbf8d	Refactor `build/find_normal.rs` to include error messages instead of `unwrap()`	2021-12-28 10:26:12 +00:00
Alex Orlenko	386eb7a2b7	v0.7.1	2021-12-23 19:42:52 +00:00
Alex Orlenko	66c9c633b2	Generate traceback from level 0 (instead of 1) Fixes #112	2021-12-23 17:53:20 +00:00
Alex Orlenko	f1e357ce52	Hide (doc) into_static/from_static methods	2021-12-01 00:28:08 +00:00
Alex Orlenko	be09a1fabf	Update lifetimes for few functions in Lua	2021-11-30 23:14:08 +00:00
Alex Orlenko	30af045c6f	Lift minimum Rust requirement to 1.53+	2021-11-29 10:46:09 +00:00
Alex Orlenko	e809640b7e	Update CI (switch to ubuntu-20.04 and add luajit52)	2021-11-27 13:44:30 +00:00
Alex Orlenko	cb3ef20ffc	Update README (remove ref to benchmarks)	2021-11-27 13:44:09 +00:00
Alex Orlenko	3b6564c02a	Update compile tests (messages)	2021-11-27 13:42:22 +00:00
Alex Orlenko	89580dd863	v0.7.0	2021-11-25 18:18:38 +00:00
Alex Orlenko	a0554a56d4	Update dependencies	2021-11-25 18:12:29 +00:00
Alex Orlenko	2fee3e7891	Update docs	2021-11-25 18:01:41 +00:00
Alex Orlenko	9f073ad879	Update README & CHANGELOG	2021-11-25 13:32:13 +00:00
Alex Orlenko	1b74c89509	More performance optimizations	2021-11-25 11:16:12 +00:00
Alex Orlenko	440862de38	Update tests	2021-11-23 19:12:27 +00:00
Alex Orlenko	066d28f5e5	Update `Lua::unload` doc & fix clippy warnings	2021-11-23 19:01:23 +00:00
Alex Orlenko	4528f93345	Merge pull request #103 from polachok/unload Add `Lua::unload()` to unload modules	2021-11-23 18:11:13 +00:00
Alexander Polakov	d49757c7db	Add unload() to remove module	2021-11-23 18:36:57 +03:00
Alex Orlenko	170818c469	Add `call()` function to `TableExt` to call tables with `__call` metamethod as functions	2021-11-21 23:47:45 +00:00
Alex Orlenko	55c8af1e6b	Add minimum Rust requirements to README	2021-11-21 23:42:49 +00:00
Alex Orlenko	e2ebe65306	Add `get_named_user_value` and `set_named_user_value` to `AnyUserData`	2021-11-21 23:42:47 +00:00
Alex Orlenko	f0f5a8a0af	Update CHANGELOG	2021-11-17 23:41:30 +00:00
Alex Orlenko	0e1be19cbb	Move hook_proc under `Lua::set_hook` to use callback_error_ext	2021-11-16 12:27:56 +00:00
Alex Orlenko	0ef709672d	Add set_warning_function/remove_warning_function/warning functions to Lua for 5.4 This utilizes Lua 5.4 warnings system (https://www.lua.org/manual/5.4/manual.html#pdf-warn)	2021-11-16 12:05:34 +00:00
Alex Orlenko	41503b4fb8	Update callback_error_ext (+ fix callback multi states handling)	2021-11-16 11:53:51 +00:00
Alex Orlenko	19bd254e1e	Update comments	2021-11-14 23:27:20 +00:00
Alex Orlenko	50f20e0c2c	Add thread (coroutine) cache to reset and later reuse to execute async functions. It works on Lua 5.4 and LuaJIT (vendored) with `lua_resetthread` function.	2021-11-14 23:19:47 +00:00
Alex Orlenko	7efe807199	Include `StdLib` to prelude	2021-11-14 23:19:47 +00:00
Alex Orlenko	63ea8c7662	Rename wrapped_failures pool to cache	2021-11-14 23:19:47 +00:00
Alex Orlenko	863d36d5a1	Performance optimization: cache and reuse `MultiValue` containers	2021-11-12 15:32:53 +00:00
Alex Orlenko	a8017c10b9	Update callback_error(_ext)	2021-11-12 12:41:03 +00:00
Alex Orlenko	2c7d7117d2	Optimize MultiValue allocations (recycle old container)	2021-11-12 10:55:20 +00:00
Alex Orlenko	6d689c35aa	Update `hook::Debug` struct	2021-11-09 18:20:36 +00:00
Alex Orlenko	8af1304fd0	Add `Lua::inspect_stack` to get information about the interpreter runtime stack. This functionality is provided by `lua_getstack`.	2021-11-09 14:18:14 +00:00
Alex Orlenko	153502ec73	Add `set_nth_user_value` and `get_nth_user_value` to `AnyUserData` with `n` up to 65535 for all Lua versions.	2021-11-08 21:16:31 +00:00
Alex Orlenko	2ea2b1f4fb	Refactor `Error::CallbackError` reporting and include source to fmt::Display implementation. This fixes #71.	2021-11-07 22:53:37 +00:00
Alex Orlenko	ef8c1556e6	Add optional Send to Lua::app_data	2021-11-07 15:03:17 +00:00
Alex Orlenko	b0da2fc439	Switch Table::serialize to FxHashSet	2021-11-07 14:49:19 +00:00
Alex Orlenko	204eedde3c	Merge branch 'dev'	2021-11-07 13:07:22 +00:00
Alex Orlenko	fbc2973aff	Fix recursive tables serialization when using `serde::ser::Serialize` implementation for Table. Fixes #98.	2021-11-06 21:12:00 +00:00
Alex Orlenko	d0641d812f	Refactor a bit conversion int->number	2021-11-04 13:15:26 +00:00
Alex Orlenko	ad70ba54a5	Publish `AnyUserData::take`	2021-11-04 12:32:19 +00:00
Alex Orlenko	806f0bcef4	Add luajit52 support (LuaJIT with partial compatibility with Lua 5.2)	2021-11-04 12:26:11 +00:00
Alex Orlenko	0741db7565	Make (De)SerializeOptions as const	2021-11-04 01:07:38 +00:00
Alex Orlenko	d88a4282c7	Replace macro-based implementation `ToLua` for arrays to const generics	2021-11-04 00:59:39 +00:00
Alex Orlenko	d7d987fa14	Add async meta methods for all Lua except 51	2021-11-04 00:57:49 +00:00
Alex Orlenko	4d3ac6d8c5	Add new "application data" api	2021-10-19 11:45:39 +01:00
Alex Orlenko	a9ca99349c	Switch to FxHash	2021-10-19 11:45:38 +01:00
Alex Orlenko	f71db80a74	Change definition of `lua_State` to opaque struct	2021-10-19 11:45:38 +01:00
Alex Orlenko	09af3e021a	v0.6.6	2021-10-12 12:22:14 +01:00
Alex Orlenko	9e3d495f91	Calculate coverage for Lua 5.4 instead of Lua 5.3	2021-10-12 12:10:04 +01:00
Alex Orlenko	cab2e5a48e	Fix clippy warnings	2021-10-12 12:02:42 +01:00
Alex Orlenko	25a4879cde	Update examples: async_http_client/async_http_server/async_tcp_server Make them following best practices and remove `unsafe` code.	2021-10-12 11:55:25 +01:00
Alex Orlenko	ed48b11e7f	Update documentation references Using rustdoc links (see RFC https://github.com/rust-lang/rfcs/pull/1946)	2021-10-12 00:49:45 +01:00
Alex Orlenko	559f9e6c6b	Add `target.aarch64-apple-darwin` conf to module examples	2021-10-11 18:07:34 +01:00
Alex Orlenko	458b06796c	Fixed LUA_REGISTRYINDEX when generating `glue.rs` on cross-compiling for lua51(jit)	2021-10-08 21:15:22 +01:00
Alex Orlenko	259eb09ae1	v0.6.5	2021-10-05 18:11:32 +01:00
Alex Orlenko	a544e41b33	Add (hidden) method `UserData::take()` to take out value from userdata	2021-10-05 15:46:50 +01:00
Alex Orlenko	235fba821e	Update CHANGELOG	2021-10-04 23:28:24 +01:00
Alex Orlenko	c8c64a1b5a	Add serializing i128/u128 types. Fixes #81.	2021-10-04 23:20:11 +01:00
Alex Orlenko	eff0bbb052	Add `Location::caller()` information to `Lua::load()` if chunk's name is None	2021-10-03 23:20:07 +01:00
Alex Orlenko	d098c9ccf6	Refactor Waker handling in async code. Instead of storing `Option<Waker>` in the Lua registry, store it on the reference thread. It gives approx +10% performance gain when calling async function.	2021-10-03 22:09:19 +01:00
Alex Orlenko	c62b17a5c8	Fixed bug when polling async futures (#77 ) We expect first value returned via coroutine.yield() to be a special Pending type. But instead we checked second value.	2021-10-02 07:23:24 +01:00
Alex Orlenko	584b377640	v0.6.4	2021-09-28 18:53:47 +01:00
Alex Orlenko	1141073a65	Update CHANGELOG	2021-09-28 18:51:42 +01:00
Alex Orlenko	5b1483bd56	Change syntax of `protect_lua` macro	2021-09-28 18:47:08 +01:00
Alex Orlenko	a74b637ed4	Update check_stack requirements	2021-09-28 18:41:25 +01:00
Alex Orlenko	7623016d4a	Fix doc feature labels	2021-09-28 18:15:53 +01:00
Alex Orlenko	bdd3c923ba	Fix table traversal used in recursion detection. This fixes serializing same table multiple times within a parent table.	2021-09-28 16:41:39 +01:00
Alex Orlenko	d586eef0f5	Refactor UserData metatables handling	2021-09-28 16:33:36 +01:00
Alex Orlenko	01154c0616	Minor refacor of wrapped failures cache	2021-09-28 16:27:24 +01:00
Alex Orlenko	e42d67c70d	Make `protect_lua` as a smart macro to choose from C/closure	2021-09-28 16:26:30 +01:00
Alex Orlenko	771a7775c5	Perf optimization: refactor metatable cache	2021-09-28 16:25:08 +01:00
Alex Orlenko	ee1c8a1a3d	Add inline attributes to few hot funcs	2021-09-28 16:19:29 +01:00
Alex Orlenko	3597e34ffb	Fix internal HookCallback type (missing optional Send)	2021-09-28 16:19:12 +01:00
Alex Orlenko	35eedd5a5e	v0.6.3	2021-09-16 00:55:49 +01:00
Alex Orlenko	53f873a482	Update compile tests error messages	2021-09-16 00:49:17 +01:00
Alex Orlenko	fc1fe2c15e	Add `DeserializeOptions` struct to control deserializer behavior. This solves #74 and provides a way to deserialize a Lua globals table.	2021-09-15 23:45:08 +01:00
Alex Orlenko	7e7a44f4cd	Update CHANGELOG	2021-08-22 16:31:14 +01:00
Alex Orlenko	63c4861520	Create FUNDING.yml	2021-08-22 16:22:20 +01:00
Alex Orlenko	27e7facf9b	Fix clippy warnings	2021-08-22 00:35:31 +01:00
Alex Orlenko	31d32f2dda	Wrap `ExtraData` to `Arc<UnsafeCell>>` instead of raw pointer and attach finalizer. This would allow to properly deallocate memory in module mode when closing lua state.	2021-08-21 23:17:09 +01:00
Alex Orlenko	7d1b322e18	Change `ExtraData::mem_info` to `Box<MemoryInfo>`	2021-08-19 01:42:32 +01:00
Alex Orlenko	d906405818	Simplify interface of `hook::HookTriggers`	2021-08-18 18:49:17 +01:00
Alex Orlenko	60fd060d47	Clarify about calling `Lua::init_from_ptr()` multiple times	2021-08-17 15:34:34 +01:00
Alex Orlenko	9f02a9ca09	Add `Debug::event()` to the hook's Debug structure	2021-08-17 15:17:03 +01:00
Alex Orlenko	1d7f105585	Don't catch Rust panics in userdata finalizer on drop	2021-08-06 11:14:16 +01:00
Alex Orlenko	1020315a9b	Update documentation about `FromLua` for UserData. Closes #64	2021-08-04 12:12:02 +01:00
Alex Orlenko	628b70f561	v0.6.2	2021-07-13 20:29:25 +01:00
Alex Orlenko	8a7e546c66	Shrink unsafe block in `Lua::load_from_function` and update doc	2021-07-13 16:43:00 +01:00
Alex Orlenko	97bd288f56	Add CI tests with enabled address sanitizer Don't use release mode in tests Try to use cache in CI	2021-07-13 16:17:29 +01:00
Alex Orlenko	59253410bb	Update trybuild messages	2021-07-13 11:59:33 +01:00
Alex Orlenko	5fb7b96704	Replace custom `UserDataRef(Mut)` with standard `Ref`(Mut)	2021-07-13 10:53:10 +01:00
Alex Orlenko	17162b1e0b	UserData improvements: 1) Optimize `make_userdata` call 2) Refactor `UserDataWrapped` and make it enum	2021-07-11 01:30:17 +01:00
Alex Orlenko	934aa3b65f	Forgotten optimization for `box_method_mut`	2021-07-09 23:25:48 +01:00
Alex Orlenko	3bffe1d7c3	Combine WrappedError and WrappedPanic structs to WrappedFailure enum	2021-07-09 00:05:29 +01:00
Alex Orlenko	582b2c585f	Rename init_gc_metatable_for and get_gc_metatable_for	2021-07-08 22:57:54 +01:00
Alex Orlenko	56b6b128b5	Minor fixes/compilation after revert	2021-07-08 22:53:53 +01:00
Alex Orlenko	1731f5d61b	Revert "Make `protect_lua` as a smart macro to choose from C/closure" This reverts commit `84fe5f7f76`.	2021-07-08 18:41:10 +01:00
Alex Orlenko	60822d12d2	Revert "Move away from metatable hashmap cache to direct keys" This reverts commit `adbc9ccc9b`.	2021-07-08 18:40:14 +01:00
Alex Orlenko	8ff610529b	Don't wrap ExtraData to Arc<Mutex> and use raw pointer instead. This causes serious performance issues and given that Lua is single threaded (not Sync) it's safe to use a raw pointer instead.	2021-07-08 17:32:20 +01:00
Alex Orlenko	adbc9ccc9b	Move away from metatable hashmap cache to direct keys	2021-07-08 15:37:18 +01:00
Alex Orlenko	84fe5f7f76	Make `protect_lua` as a smart macro to choose from C/closure	2021-07-07 12:54:19 +01:00
Alex Orlenko	1fe583027b	Add new functions: `lua.load_from_function()` and `lua.create_c_function()` This should be useful to register embedded C modules to Lua state. Provides a solution for #61	2021-07-05 00:03:18 +01:00
Alex Orlenko	7b5b78fa3d	Add codecov.yml to don't fail on coverage change	2021-06-30 21:52:50 +01:00
Alex Orlenko	41aae83304	Optimize callback creation Attach only one upvalue to callbacks rather than two. This leads to less lookup to Lua registry.	2021-06-30 16:50:50 +01:00
Alex Orlenko	fc84e8623e	v0.6.1	2021-06-28 00:10:07 +01:00
Alex Orlenko	8aae9a7c3e	Update chunk! documentation	2021-06-28 00:10:04 +01:00
Alex Orlenko	24bbd62564	Fix converting Lua sequence table to HashSet/BTreeSet	2021-06-25 01:49:09 +01:00
Alex Orlenko	30af919931	Lower once_cell dependency to 1.0	2021-06-25 00:39:10 +01:00
Alex Orlenko	89b5981c59	Fix typos	2021-06-25 00:38:49 +01:00
Alex Orlenko	7feabffc37	v0.6.0	2021-06-21 23:19:56 +01:00
Alex Orlenko	f24fdfdb80	Update `AsChunk::env` function prototype	2021-06-21 23:19:33 +01:00
Alex Orlenko	c702c5eff2	Add userdata example	2021-06-21 20:28:14 +01:00
Alex Orlenko	e4daff8c16	Add limited recursion test to increase coverage	2021-06-21 12:30:17 +01:00
Alex Orlenko	8d474bbf8d	Fix clippy warning	2021-06-21 03:25:21 +01:00
Alex Orlenko	9e3b0ecc1e	Even better optimization after `14d5c2c887`	2021-06-20 19:48:33 +01:00
Alex Orlenko	42b396d0d1	Optimize non-wrapped userdata method calls	2021-06-20 12:38:47 +01:00
Alex Orlenko	14d5c2c887	Lua->Rust callback performance improvements	2021-06-20 00:24:53 +01:00
Alex Orlenko	b84c10fde6	Update README (include publishing to luarocks section)	2021-06-19 15:00:04 +01:00
Alex Orlenko	b49f9539b6	Update CHANGELOG	2021-06-19 14:59:32 +01:00
Alex Orlenko	a208156ed2	Update examples to include `chunk!` macro	2021-06-19 14:41:48 +01:00
Alex Orlenko	242bdafa75	More tests for arc/rc wrapped userdata	2021-06-19 00:03:09 +01:00
Alex Orlenko	b84d1bd65f	Update test names	2021-06-18 23:13:56 +01:00
Alex Orlenko	4e92ea341b	Fix userdata memleak in edge case. This can happen if we unable to push metatable with `__gc` metamethod after pushing userdata. In this case Lua will never execute drop. Instead, we will push metatable first and then userdata.	2021-06-18 17:45:20 +01:00
Alex Orlenko	bf286751fa	Improve code coverage	2021-06-17 00:47:15 +01:00
Alex Orlenko	3b94b4e86f	Implement Hash for RegistryKey. Closes #57	2021-06-16 12:12:42 +01:00
Alex Orlenko	9f0378b77e	Complitely remove the C shim	2021-06-16 22:21:45 +01:00
Alex Orlenko	d3f44354e0	Revert commit `ced808d5ab` I think this experiment is unsuccessful and does not work well in a module mode with dynamic symbols resolution and mixing between different mlua instances. Overall the Rust bug has been fixed and we can wait for the "C-unwind" feature become stable.	2021-06-16 22:13:01 +01:00
Alex Orlenko	fca21d56d3	Check stack in entrypoint1 before pushing value to a stack	2021-06-13 23:30:56 +01:00
Alex Orlenko	6e52bb7e65	Fix clippy warnings && tests	2021-06-13 23:30:54 +01:00
Alex Orlenko	08ffeb0ca9	Improve module mode: - Don't hide module function inside `luaopen_%` function. - Raise Lua exception instead of panic if module function returns error.	2021-06-13 22:38:51 +01:00
Alex Orlenko	3b9d8a7b5f	Keep all Lua symbols in unsafe mode to load C modules	2021-06-12 18:00:55 +01:00
Alex Orlenko	0fe898c0dd	v0.6.0-beta.3	2021-06-04 12:38:09 +01:00
Alex Orlenko	821f1125b6	Add `String::to_string_lossy`	2021-06-04 00:16:40 +01:00
Alex Orlenko	6c0096d8ac	Update examples	2021-06-03 23:52:29 +01:00
Alex Orlenko	abb95c3c56	Remove `T: Clone` requirement from `add_async_function`	2021-06-03 23:21:00 +01:00
Alex Orlenko	64faebf407	Add `__ipairs` metamethod (again) for Lua 5.2 only	2021-06-03 18:43:29 +01:00
Alex Orlenko	a944f4ad6f	Implement `UserData` for Rc<RefCell>/Arc<Mutex>/Arc<RwLock> wrappers	2021-06-03 16:42:55 +01:00
Alex Orlenko	bae424672a	Treat errors as `Send + Sync` to be compatible with `anyhow` crate	2021-05-31 11:05:51 +01:00
Alex Orlenko	6f9eb82649	Update README	2021-05-18 20:13:28 +01:00
Alex Orlenko	e8de2a458a	Allow multiple entrypoints in a single module share the same Lua state. Previously it would initialize different Lua instances. Fixes #49.	2021-05-18 20:07:34 +01:00