v0.8.5

- Use reference thread directly for simple cases
- Fix issue when calling raw_set on readonly table (Luau)
- Add fasttrack methods for get/set/len when metatable is not set

.github/workflows/coverage.yml

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

.github/workflows/main.yml

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

CHANGELOG.md

@@ -1,3 +1,34 @@
+## v0.8.5
+
+- Fixed potential unsoundness when using `Layout::from_size_align_unchecked` and Rust 1.65+
+- Performance optimizations around string and table creation in standalone mode
+- Added fast track path to Table `get`/`set`/`len` methods without metatable
+- Added new methods `push`/`pop`/`raw_push`/`raw_pop` to Table
+- Fix getting caller information from `Lua::load`
+- Better checks and tests when trying to modify a Luau readonly table
+
+## v0.8.4
+
+- Minimal Luau updated to 0.548
+
+## v0.8.3
+
+- Close to-be-closed variables for Lua 5.4 when using call_async functions (#192)
+- Fixed Lua assertion when inspecting another thread stack. (#195)
+- Use more reliable way to create LuaJIT VM (which can fail if use Rust allocator on non-x86 platforms)
+
+## v0.8.2
+
+- Performance optimizations in handling UserData
+- Minimal Luau updated to 0.536
+- Fixed bug in `Function::bind` when passing empty binds and no arguments (#189)
+
+## v0.8.1
+
+- Added `Lua::create_proxy` for accessing to UserData static fields and functions without instance
+- Added `Table::to_pointer()` and `String::to_pointer()` functions
+- Bugfixes and improvements (#176 #179)
+
 ## v0.8.0
 Changes since 0.7.4
 - Roblox Luau support

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.8.0" # remember to update html_root_url and mlua_derive
+version = "0.8.5" # remember to update html_root_url and mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
 edition = "2021"
 repository = "https://github.com/khvzak/mlua"
@@ -58,10 +58,10 @@ cc = { version = "1.0" }
 pkg-config = { version = "0.3.17" }
 lua-src = { version = ">= 544.0.0, < 550.0.0", optional = true }
 luajit-src = { version = ">= 210.4.0, < 220.0.0", optional = true }
-luau0-src = { version = "0.3.2", optional = true }
+luau0-src = { version = "0.4.0", optional = true }
 
 [dev-dependencies]
-rustyline = "9.0"
+rustyline = "10.0"
 criterion = { version = "0.3.4", features = ["html_reports", "async_tokio"] }
 trybuild = "1.0"
 futures = "0.3.5"

FAQ.md

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

README.md

@@ -11,7 +11,11 @@
 [codecov.io]: https://codecov.io/gh/khvzak/mlua
 [MSRV]: https://img.shields.io/badge/rust-1.56+-brightgreen.svg?&logo=rust
 
-[Guided Tour](examples/guided_tour.rs)
+[Guided Tour] | [Benchmarks] | [FAQ]
+
+[Guided Tour]: examples/guided_tour.rs
+[Benchmarks]: https://github.com/khvzak/script-bench-rs
+[FAQ]: FAQ.md
 
 `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.

examples/repl.rs

@@ -5,7 +5,7 @@ use rustyline::Editor;
 
 fn main() {
     let lua = Lua::new();
-    let mut editor = Editor::<()>::new();
+    let mut editor = Editor::<()>::new().expect("Failed to make rustyline editor");
 
     loop {
         let mut prompt = "> ";

src/chunk.rs

@@ -484,7 +484,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
                     return ChunkMode::Binary;
                 }
                 #[cfg(feature = "luau")]
-                if *source.get(0).unwrap_or(&u8::MAX) < b'\n' {
+                if *source.first().unwrap_or(&u8::MAX) < b'\n' {
                     return ChunkMode::Binary;
                 }
                 ChunkMode::Text

src/ffi/lua51/lua.rs

@@ -324,6 +324,12 @@ pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
 }
 
+#[inline(always)]
+pub unsafe fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int) {
+    lua_pushvalue(from, idx);
+    lua_xmove(from, to, 1);
+}
+
 //
 // Debug API
 //

src/ffi/lua52/lua.rs

@@ -410,6 +410,12 @@ pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
     lua_tolstring(L, i, ptr::null_mut())
 }
 
+#[inline(always)]
+pub unsafe fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int) {
+    lua_pushvalue(from, idx);
+    lua_xmove(from, to, 1);
+}
+
 //
 // Debug API
 //

src/ffi/lua53/lua.rs

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

src/ffi/lua54/lua.rs

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

src/ffi/luau/compat.rs

@@ -341,7 +341,7 @@ pub unsafe fn luaL_loadbufferx(
         fn free(p: *mut c_void);
     }
 
-    let chunk_is_text = (*data as u8) >= b'\n';
+    let chunk_is_text = size == 0 || (*data as u8) >= b'\n';
     if !mode.is_null() {
         let modeb = CStr::from_ptr(mode).to_bytes();
         if !chunk_is_text && !modeb.contains(&b'b') {
@@ -423,7 +423,7 @@ pub unsafe fn luaL_traceback(
             level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
         } else {
             lua_getinfo(L1, level, cstr!("sln"), &mut ar);
-            lua_pushfstring(L, cstr!("\n\t%s:"), ar.short_src.as_ptr());
+            lua_pushfstring(L, cstr!("\n\t%s:"), ar.short_src);
             if ar.currentline > 0 {
                 lua_pushfstring(L, cstr!("%d:"), ar.currentline);
             }

src/ffi/luau/lua.rs

@@ -257,15 +257,18 @@ extern "C" {
 extern "C" {
     pub fn lua_error(L: *mut lua_State) -> !;
     pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawiter(L: *mut lua_State, idx: c_int, iter: c_int) -> c_int;
     pub fn lua_concat(L: *mut lua_State, n: c_int);
     // TODO: lua_encodepointer
     pub fn lua_clock() -> c_double;
+    pub fn lua_setuserdatatag(L: *mut lua_State, idx: c_int, tag: c_int);
     pub fn lua_setuserdatadtor(
         L: *mut lua_State,
         tag: c_int,
         dtor: Option<unsafe extern "C" fn(*mut lua_State, *mut c_void)>,
     );
     pub fn lua_clonefunction(L: *mut lua_State, idx: c_int);
+    pub fn lua_cleartable(L: *mut lua_State, idx: c_int);
 }
 
 //
@@ -437,7 +440,12 @@ extern "C" {
     pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
 
     pub fn lua_singlestep(L: *mut lua_State, enabled: c_int);
-    pub fn lua_breakpoint(L: *mut lua_State, funcindex: c_int, line: c_int, enabled: c_int);
+    pub fn lua_breakpoint(
+        L: *mut lua_State,
+        funcindex: c_int,
+        line: c_int,
+        enabled: c_int,
+    ) -> c_int;
 
     pub fn lua_getcoverage(
         L: *mut lua_State,
@@ -454,13 +462,14 @@ pub struct lua_Debug {
     pub name: *const c_char,
     pub what: *const c_char,
     pub source: *const c_char,
+    pub short_src: *const c_char,
     pub linedefined: c_int,
     pub currentline: c_int,
     pub nupvals: u8,
     pub nparams: u8,
     pub isvararg: c_char,
-    pub short_src: [c_char; LUA_IDSIZE],
     pub userdata: *mut c_void,
+    pub ssbuf: [c_char; LUA_IDSIZE],
 }
 
 //

src/ffi/mod.rs

@@ -79,9 +79,11 @@ pub(crate) fn keep_lua_symbols() {
     symbols.push(lua_tocfunction as _);
     symbols.push(luaL_loadstring as _);
     symbols.push(luaL_openlibs as _);
-    if cfg!(any(feature = "lua54", feature = "lua53", feature = "lua52")) {
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    {
         symbols.push(lua_getglobal as _);
         symbols.push(lua_setglobal as _);
+        symbols.push(luaL_setfuncs as _);
     }
 }
 

src/function.rs

@@ -114,7 +114,7 @@ impl<'lua> Function<'lua> {
         R::from_lua_multi(results, lua)
     }
 
-    /// Returns a Feature that, when polled, calls `self`, passing `args` as function arguments,
+    /// Returns a future that, when polled, calls `self`, passing `args` as function arguments,
     /// and drives the execution.
     ///
     /// Internally it wraps the function to an [`AsyncThread`].
@@ -198,7 +198,9 @@ impl<'lua> Function<'lua> {
             for i in 0..nbinds {
                 ffi::lua_pushvalue(state, ffi::lua_upvalueindex(i + 2));
             }
-            ffi::lua_rotate(state, 1, nbinds);
+            if nargs > 0 {
+                ffi::lua_rotate(state, 1, nbinds);
+            }
 
             nargs + nbinds
         }
@@ -208,6 +210,10 @@ impl<'lua> Function<'lua> {
         let args = args.to_lua_multi(lua)?;
         let nargs = args.len() as c_int;
 
+        if nargs == 0 {
+            return Ok(self.clone());
+        }
+
         if nargs + 1 > ffi::LUA_MAX_UPVALUES {
             return Err(Error::BindError);
         }
@@ -267,10 +273,13 @@ impl<'lua> Function<'lua> {
                 name_what: None,
                 what: ptr_to_cstr_bytes(ar.what).map(|s| s.to_vec()),
                 source: ptr_to_cstr_bytes(ar.source).map(|s| s.to_vec()),
-                short_src: ptr_to_cstr_bytes(&ar.short_src as *const _).map(|s| s.to_vec()),
-                line_defined: ar.linedefined as i32,
                 #[cfg(not(feature = "luau"))]
-                last_line_defined: ar.lastlinedefined as i32,
+                short_src: ptr_to_cstr_bytes(ar.short_src.as_ptr()).map(|s| s.to_vec()),
+                #[cfg(feature = "luau")]
+                short_src: ptr_to_cstr_bytes(ar.short_src).map(|s| s.to_vec()),
+                line_defined: ar.linedefined,
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: ar.lastlinedefined,
             }
         }
     }
@@ -306,8 +315,7 @@ impl<'lua> Function<'lua> {
 
             lua.push_ref(&self.0);
             let data_ptr = &mut data as *mut Vec<u8> as *mut c_void;
-            let strip = if strip { 1 } else { 0 };
-            ffi::lua_dump(lua.state, writer, data_ptr, strip);
+            ffi::lua_dump(lua.state, writer, data_ptr, strip as i32);
             ffi::lua_pop(lua.state, 1);
         }
 

src/hook.rs

@@ -102,10 +102,13 @@ impl<'lua> Debug<'lua> {
 
             DebugSource {
                 source: ptr_to_cstr_bytes((*self.ar.get()).source),
-                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src.as_ptr()),
-                line_defined: (*self.ar.get()).linedefined as i32,
                 #[cfg(not(feature = "luau"))]
-                last_line_defined: (*self.ar.get()).lastlinedefined as i32,
+                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src.as_ptr()),
+                #[cfg(feature = "luau")]
+                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src),
+                line_defined: (*self.ar.get()).linedefined,
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: (*self.ar.get()).lastlinedefined,
                 what: ptr_to_cstr_bytes((*self.ar.get()).what),
             }
         }
@@ -125,7 +128,7 @@ impl<'lua> Debug<'lua> {
                 "lua_getinfo failed with `l`"
             );
 
-            (*self.ar.get()).currentline as i32
+            (*self.ar.get()).currentline
         }
     }
 

src/lib.rs

@@ -72,7 +72,7 @@
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
 // mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.8.0")]
+#![doc(html_root_url = "https://docs.rs/mlua/0.8.5")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]

src/lua.rs

@@ -25,11 +25,11 @@ use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
 use crate::types::{
-    Callback, CallbackUpvalue, DestructedUserdataMT, Integer, LightUserData, LuaRef, MaybeSend,
+    Callback, CallbackUpvalue, DestructedUserdata, Integer, LightUserData, LuaRef, MaybeSend,
     Number, RegistryKey,
 };
 use crate::userdata::{AnyUserData, UserData, UserDataCell};
-use crate::userdata_impl::{StaticUserDataFields, StaticUserDataMethods};
+use crate::userdata_impl::{StaticUserDataFields, StaticUserDataMethods, UserDataProxy};
 use crate::util::{
     self, assert_stack, callback_error, check_stack, get_destructed_userdata_metatable,
     get_gc_metatable, get_gc_userdata, get_main_state, get_userdata, init_error_registry,
@@ -111,6 +111,9 @@ pub(crate) struct ExtraData {
     #[cfg(feature = "async")]
     recycled_thread_cache: Vec<c_int>,
 
+    // Address of `WrappedFailure` metatable
+    wrapped_failure_mt_ptr: *const c_void,
+
     // Index of `Option<Waker>` userdata on the ref thread
     #[cfg(feature = "async")]
     ref_waker_idx: c_int,
@@ -126,7 +129,7 @@ pub(crate) struct ExtraData {
     sandboxed: bool,
 }
 
-#[cfg_attr(any(feature = "lua51", feature = "luajit"), allow(dead_code))]
+#[derive(Default)]
 struct MemoryInfo {
     used_memory: isize,
     memory_limit: isize,
@@ -399,6 +402,11 @@ impl Lua {
                 return ptr::null_mut();
             }
 
+            // Do not allocate more than isize::MAX
+            if nsize > isize::MAX as usize {
+                return ptr::null_mut();
+            }
+
             // Are we fit to the memory limits?
             let mut mem_diff = nsize as isize;
             if !ptr.is_null() {
@@ -408,12 +416,14 @@ impl Lua {
             if mem_info.memory_limit > 0 && new_used_memory > mem_info.memory_limit {
                 return ptr::null_mut();
             }
-
-            let new_layout = Layout::from_size_align_unchecked(nsize, ffi::SYS_MIN_ALIGN);
             mem_info.used_memory += mem_diff;
 
             if ptr.is_null() {
                 // Allocate new memory
+                let new_layout = match Layout::from_size_align(nsize, ffi::SYS_MIN_ALIGN) {
+                    Ok(layout) => layout,
+                    Err(_) => return ptr::null_mut(),
+                };
                 let new_ptr = alloc::alloc(new_layout) as *mut c_void;
                 if new_ptr.is_null() {
                     alloc::handle_alloc_error(new_layout);
@@ -425,17 +435,28 @@ impl Lua {
             let old_layout = Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
             let new_ptr = alloc::realloc(ptr as *mut u8, old_layout, nsize) as *mut c_void;
             if new_ptr.is_null() {
-                alloc::handle_alloc_error(new_layout);
+                alloc::handle_alloc_error(old_layout);
             }
             new_ptr
         }
 
-        let mem_info = Box::into_raw(Box::new(MemoryInfo {
-            used_memory: 0,
-            memory_limit: 0,
-        }));
+        // Skip Rust allocator for non-vendored LuaJIT (see https://github.com/khvzak/mlua/issues/176)
+        let use_rust_allocator = !(cfg!(feature = "luajit") && cfg!(not(feature = "vendored")));
 
-        let state = ffi::lua_newstate(allocator, mem_info as *mut c_void);
+        let (state, mem_info) = if use_rust_allocator {
+            let mut mem_info = Box::into_raw(Box::new(MemoryInfo::default()));
+            let mut state = ffi::lua_newstate(allocator, mem_info as *mut c_void);
+            // If state is null (it's possible for LuaJIT on non-x86 arch) then switch to Lua internal allocator
+            if state.is_null() {
+                drop(Box::from_raw(mem_info));
+                mem_info = ptr::null_mut();
+                state = ffi::luaL_newstate();
+            }
+            (state, mem_info)
+        } else {
+            (ffi::luaL_newstate(), ptr::null_mut())
+        };
+        assert!(!state.is_null(), "Failed to instantiate Lua VM");
 
         ffi::luaL_requiref(state, cstr!("_G"), ffi::luaopen_base, 1);
         ffi::lua_pop(state, 1);
@@ -489,6 +510,7 @@ impl Lua {
     /// by calling this function again.
     #[allow(clippy::missing_safety_doc)]
     pub unsafe fn init_from_ptr(state: *mut ffi::lua_State) -> Lua {
+        assert!(!state.is_null(), "Lua state is NULL");
         let main_state = get_main_state(state).unwrap_or(state);
         let main_state_top = ffi::lua_gettop(main_state);
 
@@ -534,6 +556,13 @@ impl Lua {
             "Error while creating ref thread",
         );
 
+        let wrapped_failure_mt_ptr = {
+            get_gc_metatable::<WrappedFailure>(state);
+            let ptr = ffi::lua_topointer(state, -1);
+            ffi::lua_pop(state, 1);
+            ptr
+        };
+
         // Create empty Waker slot on the ref thread
         #[cfg(feature = "async")]
         let ref_waker_idx = {
@@ -564,6 +593,7 @@ impl Lua {
             multivalue_cache: Vec::with_capacity(MULTIVALUE_CACHE_SIZE),
             #[cfg(feature = "async")]
             recycled_thread_cache: Vec::new(),
+            wrapped_failure_mt_ptr,
             #[cfg(feature = "async")]
             ref_waker_idx,
             #[cfg(not(feature = "luau"))]
@@ -587,13 +617,13 @@ impl Lua {
             "Error while storing extra data",
         );
 
-        // Register `DestructedUserdataMT` type
+        // Register `DestructedUserdata` type
         get_destructed_userdata_metatable(main_state);
         let destructed_mt_ptr = ffi::lua_topointer(main_state, -1);
-        let destructed_mt_typeid = Some(TypeId::of::<DestructedUserdataMT>());
+        let destructed_ud_typeid = TypeId::of::<DestructedUserdata>();
         (*extra.get())
             .registered_userdata_mt
-            .insert(destructed_mt_ptr, destructed_mt_typeid);
+            .insert(destructed_mt_ptr, Some(destructed_ud_typeid));
         ffi::lua_pop(main_state, 1);
 
         mlua_debug_assert!(
@@ -859,10 +889,8 @@ impl Lua {
                         ffi::luaL_sandboxthread(state);
                     } else {
                         // Restore original `LUA_GLOBALSINDEX`
-                        self.ref_thread_exec(|ref_thread| {
-                            ffi::lua_xpush(ref_thread, state, ffi::LUA_GLOBALSINDEX);
-                            ffi::lua_replace(state, ffi::LUA_GLOBALSINDEX);
-                        });
+                        ffi::lua_xpush(self.ref_thread(), state, ffi::LUA_GLOBALSINDEX);
+                        ffi::lua_replace(state, ffi::LUA_GLOBALSINDEX);
                         ffi::luaL_sandbox(state, 0);
                     }
                 })?;
@@ -1101,7 +1129,7 @@ impl Lua {
     #[cfg_attr(docsrs, doc(cfg(feature = "lua54")))]
     pub fn warning<S: Into<Vec<u8>>>(&self, msg: S, tocont: bool) -> Result<()> {
         let msg = CString::new(msg).map_err(|err| Error::RuntimeError(err.to_string()))?;
-        unsafe { ffi::lua_warning(self.state, msg.as_ptr(), if tocont { 1 } else { 0 }) };
+        unsafe { ffi::lua_warning(self.state, msg.as_ptr(), tocont as c_int) };
         Ok(())
     }
 
@@ -1343,9 +1371,8 @@ impl Lua {
     where
         S: AsChunk<'lua> + ?Sized,
     {
-        let name = chunk
-            .name()
-            .unwrap_or_else(|| Location::caller().to_string());
+        let caller = Location::caller();
+        let name = chunk.name().unwrap_or_else(|| caller.to_string());
 
         Chunk {
             lua: self,
@@ -1405,11 +1432,15 @@ impl Lua {
         S: AsRef<[u8]> + ?Sized,
     {
         unsafe {
+            if self.unlikely_memory_error() {
+                push_string(self.ref_thread(), s.as_ref(), false)?;
+                return Ok(String(self.pop_ref_thread()));
+            }
+
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 3)?;
 
-            let protect = !self.unlikely_memory_error();
-            push_string(self.state, s, protect)?;
+            push_string(self.state, s.as_ref(), true)?;
             Ok(String(self.pop_ref()))
         }
     }
@@ -1425,11 +1456,15 @@ impl Lua {
     /// Lua may use these hints to preallocate memory for the new table.
     pub fn create_table_with_capacity(&self, narr: c_int, nrec: c_int) -> Result<Table> {
         unsafe {
+            if self.unlikely_memory_error() {
+                push_table(self.ref_thread(), narr, nrec, false)?;
+                return Ok(Table(self.pop_ref_thread()));
+            }
+
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 3)?;
 
-            let protect = !self.unlikely_memory_error();
-            push_table(self.state, narr, nrec, protect)?;
+            push_table(self.state, narr, nrec, true)?;
             Ok(Table(self.pop_ref()))
         }
     }
@@ -1697,15 +1732,16 @@ impl Lua {
         all(feature = "luajit", feature = "vendored"),
         feature = "luau",
     ))]
-    pub(crate) unsafe fn recycle_thread(&self, thread: &mut Thread) {
+    pub(crate) unsafe fn recycle_thread(&self, thread: &mut Thread) -> bool {
         let extra = &mut *self.extra.get();
-        let thread_state = ffi::lua_tothread(extra.ref_thread, thread.0.index);
         if extra.recycled_thread_cache.len() < extra.recycled_thread_cache.capacity() {
+            let thread_state = ffi::lua_tothread(extra.ref_thread, thread.0.index);
             #[cfg(feature = "lua54")]
             let status = ffi::lua_resetthread(thread_state);
             #[cfg(feature = "lua54")]
             if status != ffi::LUA_OK {
-                return;
+                // Error object is on top, drop it
+                ffi::lua_settop(thread_state, 0);
             }
             #[cfg(all(feature = "luajit", feature = "vendored"))]
             ffi::lua_resetthread(self.state, thread_state);
@@ -1713,10 +1749,15 @@ impl Lua {
             ffi::lua_resetthread(thread_state);
             extra.recycled_thread_cache.push(thread.0.index);
             thread.0.index = 0;
+            return true;
         }
+        false
     }
 
     /// Create a Lua userdata object from a custom userdata type.
+    ///
+    /// All userdata instances of type `T` shares the same metatable.
+    #[inline]
     pub fn create_userdata<T>(&self, data: T) -> Result<AnyUserData>
     where
         T: 'static + MaybeSend + UserData,
@@ -1729,6 +1770,7 @@ impl Lua {
     /// Requires `feature = "serialize"`
     #[cfg(feature = "serialize")]
     #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
+    #[inline]
     pub fn create_ser_userdata<T>(&self, data: T) -> Result<AnyUserData>
     where
         T: 'static + MaybeSend + UserData + Serialize,
@@ -1736,6 +1778,46 @@ impl Lua {
         unsafe { self.make_userdata(UserDataCell::new_ser(data)) }
     }
 
+    /// Create a Lua userdata "proxy" object from a custom userdata type.
+    ///
+    /// Proxy object is an empty userdata object that has `T` metatable attached.
+    /// The main purpose of this object is to provide access to static fields and functions
+    /// without creating an instance of type `T`.
+    ///
+    /// You can get or set uservalues on this object but you cannot borrow any Rust type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use mlua::{Lua, Result, UserData, UserDataFields, UserDataMethods};
+    /// # fn main() -> Result<()> {
+    /// # let lua = Lua::new();
+    /// struct MyUserData(i32);
+    ///
+    /// impl UserData for MyUserData {
+    ///     fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+    ///         fields.add_field_method_get("val", |_, this| Ok(this.0));
+    ///     }
+    ///
+    ///     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+    ///         methods.add_function("new", |_, value: i32| Ok(MyUserData(value)));
+    ///     }
+    /// }
+    ///
+    /// lua.globals().set("MyUserData", lua.create_proxy::<MyUserData>()?)?;
+    ///
+    /// lua.load("assert(MyUserData.new(321).val == 321)").exec()?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn create_proxy<T>(&self) -> Result<AnyUserData>
+    where
+        T: 'static + UserData,
+    {
+        unsafe { self.make_userdata(UserDataCell::new(UserDataProxy::<T>(PhantomData))) }
+    }
+
     /// Returns a handle to the global environment.
     pub fn globals(&self) -> Table {
         unsafe {
@@ -1946,7 +2028,7 @@ impl Lua {
             check_stack(self.state, 3)?;
 
             let protect = !self.unlikely_memory_error();
-            push_string(self.state, name, protect)?;
+            push_string(self.state, name.as_ref(), protect)?;
             ffi::lua_rawget(self.state, ffi::LUA_REGISTRYINDEX);
 
             self.pop_value()
@@ -2024,11 +2106,8 @@ impl Lua {
             let _sg = StackGuard::new(self.state);
             check_stack(self.state, 1)?;
 
-            ffi::lua_rawgeti(
-                self.state,
-                ffi::LUA_REGISTRYINDEX,
-                key.registry_id as Integer,
-            );
+            let id = key.registry_id as Integer;
+            ffi::lua_rawgeti(self.state, ffi::LUA_REGISTRYINDEX, id);
             self.pop_value()
         };
         T::from_lua(value, self)
@@ -2074,14 +2153,10 @@ impl Lua {
 
             self.push_value(t)?;
             // It must be safe to replace the value without triggering memory error
-            ffi::lua_rawseti(
-                self.state,
-                ffi::LUA_REGISTRYINDEX,
-                key.registry_id as Integer,
-            );
-
-            Ok(())
+            let id = key.registry_id as Integer;
+            ffi::lua_rawseti(self.state, ffi::LUA_REGISTRYINDEX, id);
         }
+        Ok(())
     }
 
     /// Returns true if the given `RegistryKey` was created by a `Lua` which shares the underlying
@@ -2193,7 +2268,7 @@ impl Lua {
             }
 
             Value::Boolean(b) => {
-                ffi::lua_pushboolean(self.state, if b { 1 } else { 0 });
+                ffi::lua_pushboolean(self.state, b as c_int);
             }
 
             Value::LightUserData(ud) => {
@@ -2245,6 +2320,8 @@ impl Lua {
     // Uses 2 stack spaces, does not call checkstack
     pub(crate) unsafe fn pop_value(&self) -> Value {
         let state = self.state;
+        let extra = &mut *self.extra.get();
+
         match ffi::lua_type(state, -1) {
             ffi::LUA_TNIL => {
                 ffi::lua_pop(state, 1);
@@ -2305,9 +2382,11 @@ impl Lua {
             ffi::LUA_TFUNCTION => Value::Function(Function(self.pop_ref())),
 
             ffi::LUA_TUSERDATA => {
+                let wrapped_failure_mt_ptr = extra.wrapped_failure_mt_ptr;
                 // We must prevent interaction with userdata types other than UserData OR a WrappedError.
                 // WrappedPanics are automatically resumed.
-                match get_gc_userdata::<WrappedFailure>(state, -1).as_mut() {
+                match get_gc_userdata::<WrappedFailure>(state, -1, wrapped_failure_mt_ptr).as_mut()
+                {
                     Some(WrappedFailure::Error(err)) => {
                         let err = err.clone();
                         ffi::lua_pop(state, 1);
@@ -2346,12 +2425,6 @@ impl Lua {
             "Lua instance passed Value created from a different main Lua state"
         );
         let extra = &*self.extra.get();
-        #[cfg(not(feature = "luau"))]
-        {
-            ffi::lua_pushvalue(extra.ref_thread, lref.index);
-            ffi::lua_xmove(extra.ref_thread, self.state, 1);
-        }
-        #[cfg(feature = "luau")]
         ffi::lua_xpush(extra.ref_thread, self.state, lref.index);
     }
 
@@ -2371,6 +2444,13 @@ impl Lua {
         LuaRef { lua: self, index }
     }
 
+    // Same as `pop_ref` but assumes the value is already on the reference thread
+    pub(crate) unsafe fn pop_ref_thread(&self) -> LuaRef {
+        let extra = &mut *self.extra.get();
+        let index = ref_stack_pop(extra);
+        LuaRef { lua: self, index }
+    }
+
     pub(crate) fn clone_ref<'lua>(&'lua self, lref: &LuaRef<'lua>) -> LuaRef<'lua> {
         unsafe {
             let extra = &mut *self.extra.get();
@@ -2389,16 +2469,6 @@ impl Lua {
         }
     }
 
-    /// Executes the function provided on the ref thread
-    #[inline]
-    pub(crate) unsafe fn ref_thread_exec<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(*mut ffi::lua_State) -> R,
-    {
-        let ref_thread = (*self.extra.get()).ref_thread;
-        f(ref_thread)
-    }
-
     unsafe fn push_userdata_metatable<T: 'static + UserData>(&self) -> Result<()> {
         let extra = &mut *self.extra.get();
 
@@ -2523,6 +2593,7 @@ impl Lua {
     pub(crate) unsafe fn push_userdata_ref(&self, lref: &LuaRef) -> Result<Option<TypeId>> {
         self.push_ref(lref);
         if ffi::lua_getmetatable(self.state, -1) == 0 {
+            ffi::lua_pop(self.state, 1);
             return Err(Error::UserDataTypeMismatch);
         }
         let mt_ptr = ffi::lua_topointer(self.state, -1);
@@ -2530,7 +2601,7 @@ impl Lua {
 
         let extra = &*self.extra.get();
         match extra.registered_userdata_mt.get(&mt_ptr) {
-            Some(&type_id) if type_id == Some(TypeId::of::<DestructedUserdataMT>()) => {
+            Some(&type_id) if type_id == Some(TypeId::of::<DestructedUserdata>()) => {
                 Err(Error::UserDataDestructed)
             }
             Some(&type_id) => Ok(type_id),
@@ -2866,7 +2937,7 @@ impl Lua {
         let _sg = StackGuard::new(state);
         assert_stack(state, 1);
         let extra = extra_data(state)?;
-        let inner = &*(*extra.get()).inner.as_ref().unwrap();
+        let inner = (*extra.get()).inner.as_ref().unwrap();
         Some(Lua(Arc::clone(inner)))
     }
 
@@ -2900,18 +2971,25 @@ impl Lua {
     }
 }
 
+impl LuaInner {
+    #[inline(always)]
+    pub(crate) fn ref_thread(&self) -> *mut ffi::lua_State {
+        unsafe { (*self.extra.get()).ref_thread }
+    }
+}
+
 struct StateGuard<'a>(&'a mut LuaInner, *mut ffi::lua_State);
 
 impl<'a> StateGuard<'a> {
     fn new(inner: &'a mut LuaInner, mut state: *mut ffi::lua_State) -> Self {
-        mem::swap(&mut (*inner).state, &mut state);
+        mem::swap(&mut inner.state, &mut state);
         Self(inner, state)
     }
 }
 
 impl<'a> Drop for StateGuard<'a> {
     fn drop(&mut self) {
-        mem::swap(&mut (*self.0).state, &mut self.1);
+        mem::swap(&mut self.0.state, &mut self.1);
     }
 }
 

src/luau.rs

@@ -85,10 +85,12 @@ fn lua_require(lua: &Lua, name: Option<std::string::String>) -> Result<Value> {
         search_path = "?.luau;?.lua".into();
     }
 
-    let mut source = None;
+    let (mut source, mut source_name) = (None, String::new());
     for path in search_path.split(';') {
-        if let Ok(buf) = std::fs::read(path.replacen('?', &name, 1)) {
+        let file_path = path.replacen('?', &name, 1);
+        if let Ok(buf) = std::fs::read(&file_path) {
             source = Some(buf);
+            source_name = file_path;
             break;
         }
     }
@@ -96,7 +98,7 @@ fn lua_require(lua: &Lua, name: Option<std::string::String>) -> Result<Value> {
 
     let value = lua
         .load(&source)
-        .set_name(&format!("={}", name))?
+        .set_name(&format!("={}", source_name))?
         .set_mode(ChunkMode::Text)
         .call::<_, Value>(())?;
 

src/scope.rs

@@ -597,6 +597,7 @@ impl<'lua, 'scope> Drop for Scope<'lua, 'scope> {
     }
 }
 
+#[allow(clippy::type_complexity)]
 enum NonStaticMethod<'lua, T> {
     Method(Box<dyn Fn(&'lua Lua, &T, MultiValue<'lua>) -> Result<MultiValue<'lua>>>),
     MethodMut(Box<dyn FnMut(&'lua Lua, &mut T, MultiValue<'lua>) -> Result<MultiValue<'lua>>>),

src/serde/de.rs

@@ -8,7 +8,6 @@ use rustc_hash::FxHashSet;
 use serde::de::{self, IntoDeserializer};
 
 use crate::error::{Error, Result};
-use crate::ffi;
 use crate::table::{Table, TablePairs, TableSequence};
 use crate::value::Value;
 
@@ -72,7 +71,7 @@ impl Options {
     ///
     /// [`deny_recursive_tables`]: #structfield.deny_recursive_tables
     #[must_use]
-    pub fn deny_recursive_tables(mut self, enabled: bool) -> Self {
+    pub const fn deny_recursive_tables(mut self, enabled: bool) -> Self {
         self.deny_recursive_tables = enabled;
         self
     }
@@ -563,9 +562,7 @@ impl RecursionGuard {
     #[inline]
     fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
         let visited = Rc::clone(visited);
-        let lua = table.0.lua;
-        let ptr =
-            unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+        let ptr = table.to_pointer();
         visited.borrow_mut().insert(ptr);
         RecursionGuard { ptr, visited }
     }
@@ -585,9 +582,7 @@ fn check_value_if_skip(
 ) -> Result<bool> {
     match value {
         Value::Table(table) => {
-            let lua = table.0.lua;
-            let ptr =
-                unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+            let ptr = table.to_pointer();
             if visited.borrow().contains(&ptr) {
                 if options.deny_recursive_tables {
                     return Err(de::Error::custom("recursive table detected"));

src/serde/mod.rs

@@ -10,7 +10,7 @@ use crate::ffi;
 use crate::lua::Lua;
 use crate::table::Table;
 use crate::types::LightUserData;
-use crate::util::{assert_stack, check_stack, StackGuard};
+use crate::util::check_stack;
 use crate::value::Value;
 
 /// Trait for serializing/deserializing Lua values using Serde.
@@ -205,12 +205,8 @@ impl<'lua> LuaSerdeExt<'lua> for Lua {
 
     fn array_metatable(&'lua self) -> Table<'lua> {
         unsafe {
-            let _sg = StackGuard::new(self.state);
-            assert_stack(self.state, 1);
-
-            push_array_metatable(self.state);
-
-            Table(self.pop_ref())
+            push_array_metatable(self.ref_thread());
+            Table(self.pop_ref_thread())
         }
     }
 

src/string.rs

@@ -1,5 +1,6 @@
 use std::borrow::{Borrow, Cow};
 use std::hash::{Hash, Hasher};
+use std::os::raw::c_void;
 use std::string::String as StdString;
 use std::{slice, str};
 
@@ -12,7 +13,6 @@ use {
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{assert_stack, StackGuard};
 
 /// Handle to an internal Lua string.
 ///
@@ -39,6 +39,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn to_str(&self) -> Result<&str> {
         str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
             from: "string",
@@ -65,6 +66,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn to_string_lossy(&self) -> Cow<'_, str> {
         StdString::from_utf8_lossy(self.as_bytes())
     }
@@ -86,6 +88,7 @@ impl<'lua> String<'lua> {
     /// # Ok(())
     /// # }
     /// ```
+    #[inline]
     pub fn as_bytes(&self) -> &[u8] {
         let nulled = self.as_bytes_with_nul();
         &nulled[..nulled.len() - 1]
@@ -93,25 +96,32 @@ impl<'lua> String<'lua> {
 
     /// Get the bytes that make up this string, including the trailing nul byte.
     pub fn as_bytes_with_nul(&self) -> &[u8] {
-        let lua = self.0.lua;
+        let ref_thread = self.0.lua.ref_thread();
         unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
-
-            lua.push_ref(&self.0);
             mlua_debug_assert!(
-                ffi::lua_type(lua.state, -1) == ffi::LUA_TSTRING,
+                ffi::lua_type(ref_thread, self.0.index) == ffi::LUA_TSTRING,
                 "string ref is not string type"
             );
 
             let mut size = 0;
             // This will not trigger a 'm' error, because the reference is guaranteed to be of
             // string type
-            let data = ffi::lua_tolstring(lua.state, -1, &mut size);
+            let data = ffi::lua_tolstring(ref_thread, self.0.index, &mut size);
 
             slice::from_raw_parts(data as *const u8, size + 1)
         }
     }
+
+    /// Converts the string to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_topointer(ref_thread, self.0.index) }
+    }
 }
 
 impl<'lua> AsRef<[u8]> for String<'lua> {

src/table.rs

@@ -1,10 +1,11 @@
 use std::marker::PhantomData;
+use std::os::raw::c_void;
 
 #[cfg(feature = "serialize")]
 use {
     rustc_hash::FxHashSet,
     serde::ser::{self, Serialize, SerializeMap, SerializeSeq, Serializer},
-    std::{cell::RefCell, os::raw::c_void, result::Result as StdResult},
+    std::{cell::RefCell, result::Result as StdResult},
 };
 
 use crate::error::{Error, Result};
@@ -57,6 +58,11 @@ impl<'lua> Table<'lua> {
     ///
     /// [`raw_set`]: #method.raw_set
     pub fn set<K: ToLua<'lua>, V: ToLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_set(key, value);
+        }
+
         let lua = self.0.lua;
         let key = key.to_lua(lua)?;
         let value = value.to_lua(lua)?;
@@ -97,6 +103,11 @@ impl<'lua> Table<'lua> {
     ///
     /// [`raw_get`]: #method.raw_get
     pub fn get<K: ToLua<'lua>, V: FromLua<'lua>>(&self, key: K) -> Result<V> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_get(key);
+        }
+
         let lua = self.0.lua;
         let key = key.to_lua(lua)?;
 
@@ -115,18 +126,54 @@ impl<'lua> Table<'lua> {
 
     /// Checks whether the table contains a non-nil value for `key`.
     pub fn contains_key<K: ToLua<'lua>>(&self, key: K) -> Result<bool> {
-        let lua = self.0.lua;
-        let key = key.to_lua(lua)?;
+        Ok(self.get::<_, Value>(key)? != Value::Nil)
+    }
 
+    /// Appends a value to the back of the table.
+    pub fn push<V: ToLua<'lua>>(&self, value: V) -> Result<()> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_push(value);
+        }
+
+        let lua = self.0.lua;
+        let value = value.to_lua(lua)?;
         unsafe {
             let _sg = StackGuard::new(lua.state);
             check_stack(lua.state, 4)?;
 
             lua.push_ref(&self.0);
-            lua.push_value(key)?;
-            protect_lua!(lua.state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;
-            Ok(ffi::lua_isnil(lua.state, -1) == 0)
+            lua.push_value(value)?;
+            protect_lua!(lua.state, 2, 0, fn(state) {
+                let len = ffi::luaL_len(state, -2) as Integer;
+                ffi::lua_seti(state, -2, len + 1);
+            })?
         }
+        Ok(())
+    }
+
+    /// Removes the last element from the table and returns it.
+    pub fn pop<V: FromLua<'lua>>(&self) -> Result<V> {
+        // Fast track
+        if !self.has_metatable() {
+            return self.raw_pop();
+        }
+
+        let lua = self.0.lua;
+        let value = unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 4)?;
+
+            lua.push_ref(&self.0);
+            protect_lua!(lua.state, 1, 1, fn(state) {
+                let len = ffi::luaL_len(state, -1) as Integer;
+                ffi::lua_geti(state, -1, len);
+                ffi::lua_pushnil(state);
+                ffi::lua_seti(state, -3, len);
+            })?;
+            lua.pop_value()
+        };
+        V::from_lua(value, lua)
     }
 
     /// Compares two tables for equality.
@@ -187,6 +234,9 @@ impl<'lua> Table<'lua> {
 
     /// Sets a key-value pair without invoking metamethods.
     pub fn raw_set<K: ToLua<'lua>, V: ToLua<'lua>>(&self, key: K, value: V) -> Result<()> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
         let lua = self.0.lua;
         let key = key.to_lua(lua)?;
         let value = value.to_lua(lua)?;
@@ -198,6 +248,7 @@ impl<'lua> Table<'lua> {
             lua.push_ref(&self.0);
             lua.push_value(key)?;
             lua.push_value(value)?;
+
             if lua.unlikely_memory_error() {
                 ffi::lua_rawset(lua.state, -3);
                 ffi::lua_pop(lua.state, 1);
@@ -253,6 +304,56 @@ impl<'lua> Table<'lua> {
         }
     }
 
+    /// Appends a value to the back of the table without invoking metamethods.
+    pub fn raw_push<V: ToLua<'lua>>(&self, value: V) -> Result<()> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
+        let lua = self.0.lua;
+        let value = value.to_lua(lua)?;
+
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 4)?;
+
+            lua.push_ref(&self.0);
+            lua.push_value(value)?;
+
+            unsafe fn callback(state: *mut ffi::lua_State) {
+                let len = ffi::lua_rawlen(state, -2) as Integer;
+                ffi::lua_rawseti(state, -2, len + 1);
+            }
+
+            if lua.unlikely_memory_error() {
+                callback(lua.state);
+            } else {
+                protect_lua!(lua.state, 2, 0, fn(state) callback(state))?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Removes the last element from the table and returns it, without invoking metamethods.
+    pub fn raw_pop<V: FromLua<'lua>>(&self) -> Result<V> {
+        #[cfg(feature = "luau")]
+        self.check_readonly_write()?;
+
+        let lua = self.0.lua;
+        let value = unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 3)?;
+
+            lua.push_ref(&self.0);
+            let len = ffi::lua_rawlen(lua.state, -1) as Integer;
+            ffi::lua_rawgeti(lua.state, -1, len);
+            // Set slot to nil (it must be safe to do)
+            ffi::lua_pushnil(lua.state);
+            ffi::lua_rawseti(lua.state, -3, len);
+            lua.pop_value()
+        };
+        V::from_lua(value, lua)
+    }
+
     /// Removes a key from the table.
     ///
     /// If `key` is an integer, mlua shifts down the elements from `table[key+1]`,
@@ -294,6 +395,11 @@ impl<'lua> Table<'lua> {
     ///
     /// [`raw_len`]: #method.raw_len
     pub fn len(&self) -> Result<Integer> {
+        // Fast track
+        if !self.has_metatable() {
+            return Ok(self.raw_len());
+        }
+
         let lua = self.0.lua;
         unsafe {
             let _sg = StackGuard::new(lua.state);
@@ -306,14 +412,8 @@ impl<'lua> Table<'lua> {
 
     /// Returns the result of the Lua `#` operator, without invoking the `__len` metamethod.
     pub fn raw_len(&self) -> Integer {
-        let lua = self.0.lua;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
-
-            lua.push_ref(&self.0);
-            ffi::lua_rawlen(lua.state, -1) as Integer
-        }
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_rawlen(ref_thread, self.0.index) as Integer }
     }
 
     /// Returns a reference to the metatable of this table, or `None` if no metatable is set.
@@ -339,6 +439,12 @@ impl<'lua> Table<'lua> {
     /// If `metatable` is `None`, the metatable is removed (if no metatable is set, this does
     /// nothing).
     pub fn set_metatable(&self, metatable: Option<Table<'lua>>) {
+        // Workaround to throw readonly error without returning Result
+        #[cfg(feature = "luau")]
+        if self.is_readonly() {
+            panic!("attempt to modify a readonly table");
+        }
+
         let lua = self.0.lua;
         unsafe {
             let _sg = StackGuard::new(lua.state);
@@ -354,21 +460,33 @@ impl<'lua> Table<'lua> {
         }
     }
 
+    /// Returns true if the table has metatable attached.
+    #[doc(hidden)]
+    #[inline]
+    pub fn has_metatable(&self) -> bool {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe {
+            if ffi::lua_getmetatable(ref_thread, self.0.index) != 0 {
+                ffi::lua_pop(ref_thread, 1);
+                return true;
+            }
+        }
+        false
+    }
+
     /// Sets `readonly` attribute on the table.
     ///
     /// Requires `feature = "luau"`
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn set_readonly(&self, enabled: bool) {
-        let lua = self.0.lua;
+        let ref_thread = self.0.lua.ref_thread();
         unsafe {
-            lua.ref_thread_exec(|refthr| {
-                ffi::lua_setreadonly(refthr, self.0.index, enabled as _);
-                if !enabled {
-                    // Reset "safeenv" flag
-                    ffi::lua_setsafeenv(refthr, self.0.index, 0);
-                }
-            });
+            ffi::lua_setreadonly(ref_thread, self.0.index, enabled as _);
+            if !enabled {
+                // Reset "safeenv" flag
+                ffi::lua_setsafeenv(ref_thread, self.0.index, 0);
+            }
         }
     }
 
@@ -378,8 +496,20 @@ impl<'lua> Table<'lua> {
     #[cfg(any(feature = "luau", doc))]
     #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
     pub fn is_readonly(&self) -> bool {
-        let lua = self.0.lua;
-        unsafe { lua.ref_thread_exec(|refthr| ffi::lua_getreadonly(refthr, self.0.index) != 0) }
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_getreadonly(ref_thread, self.0.index) != 0 }
+    }
+
+    /// Converts the table to a generic C pointer.
+    ///
+    /// Different tables will give different pointers.
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        let ref_thread = self.0.lua.ref_thread();
+        unsafe { ffi::lua_topointer(ref_thread, self.0.index) }
     }
 
     /// Consume this table and return an iterator over the pairs of the table.
@@ -519,6 +649,16 @@ impl<'lua> Table<'lua> {
             ffi::lua_rawequal(lua.state, -1, -2) != 0
         }
     }
+
+    #[cfg(feature = "luau")]
+    #[inline(always)]
+    pub(crate) fn check_readonly_write(&self) -> Result<()> {
+        if self.is_readonly() {
+            let err = "attempt to modify a readonly table".to_string();
+            return Err(Error::RuntimeError(err));
+        }
+        Ok(())
+    }
 }
 
 impl<'lua> PartialEq for Table<'lua> {
@@ -699,8 +839,7 @@ impl<'lua> Serialize for Table<'lua> {
             static VISITED: RefCell<FxHashSet<*const c_void>> = RefCell::new(FxHashSet::default());
         }
 
-        let lua = self.0.lua;
-        let ptr = unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) };
+        let ptr = self.to_pointer();
         let res = VISITED.with(|visited| {
             {
                 let mut visited = visited.borrow_mut();

src/thread.rs

@@ -4,7 +4,7 @@ use std::os::raw::c_int;
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{check_stack, error_traceback, pop_error, StackGuard};
+use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
 use crate::value::{FromLuaMulti, ToLuaMulti};
 
 #[cfg(any(
@@ -118,8 +118,7 @@ impl<'lua> Thread<'lua> {
             let _sg = StackGuard::new(lua.state);
             check_stack(lua.state, cmp::max(nargs + 1, 3))?;
 
-            let thread_state =
-                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));
+            let thread_state = ffi::lua_tothread(lua.ref_thread(), self.0.index);
 
             let status = ffi::lua_status(thread_state);
             if status != ffi::LUA_YIELD && ffi::lua_gettop(thread_state) == 0 {
@@ -136,8 +135,12 @@ 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 {
-                protect_lua!(lua.state, 0, 0, |_| error_traceback(thread_state))?;
-                return Err(pop_error(thread_state, ret));
+                check_stack(lua.state, 3)?;
+                protect_lua!(lua.state, 0, 1, |state| error_traceback_thread(
+                    state,
+                    thread_state
+                ))?;
+                return Err(pop_error(lua.state, ret));
             }
 
             let mut results = args; // Reuse MultiValue container
@@ -156,8 +159,7 @@ impl<'lua> Thread<'lua> {
     pub fn status(&self) -> ThreadStatus {
         let lua = self.0.lua;
         unsafe {
-            let thread_state =
-                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));
+            let thread_state = ffi::lua_tothread(lua.ref_thread(), self.0.index);
 
             let status = ffi::lua_status(thread_state);
             if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
@@ -322,7 +324,7 @@ impl<'lua> Thread<'lua> {
     pub fn sandbox(&self) -> Result<()> {
         let lua = self.0.lua;
         unsafe {
-            let thread = lua.ref_thread_exec(|t| ffi::lua_tothread(t, self.0.index));
+            let thread = ffi::lua_tothread(lua.ref_thread(), self.0.index);
             check_stack(thread, 1)?;
             check_stack(lua.state, 3)?;
             // Inherit `LUA_GLOBALSINDEX` from the caller
@@ -357,7 +359,15 @@ impl<'lua, R> Drop for AsyncThread<'lua, R> {
     fn drop(&mut self) {
         if self.recycle {
             unsafe {
-                self.thread.0.lua.recycle_thread(&mut self.thread);
+                let lua = self.thread.0.lua;
+                // For Lua 5.4 this also closes all pending to-be-closed variables
+                if !lua.recycle_thread(&mut self.thread) {
+                    #[cfg(feature = "lua54")]
+                    if self.thread.status() == ThreadStatus::Error {
+                        let thread_state = ffi::lua_tothread(lua.ref_thread(), self.thread.0.index);
+                        ffi::lua_resetthread(thread_state);
+                    }
+                }
             }
         }
     }

src/types.rs

@@ -83,7 +83,7 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}
 
-pub(crate) struct DestructedUserdataMT;
+pub(crate) struct DestructedUserdata;
 
 /// An auto generated key into the Lua registry.
 ///

src/userdata_impl.rs

@@ -622,3 +622,8 @@ lua_userdata_impl!(Arc<RwLock<T>>);
 lua_userdata_impl!(Arc<parking_lot::Mutex<T>>);
 #[cfg(feature = "parking_lot")]
 lua_userdata_impl!(Arc<parking_lot::RwLock<T>>);
+
+// A special proxy object for UserData
+pub(crate) struct UserDataProxy<T>(pub(crate) PhantomData<T>);
+
+lua_userdata_impl!(UserDataProxy<T>);

src/util.rs

@@ -1,6 +1,7 @@
 use std::any::{Any, TypeId};
 use std::ffi::CStr;
 use std::fmt::Write;
+use std::mem::MaybeUninit;
 use std::os::raw::{c_char, c_int, c_void};
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
 use std::sync::Arc;
@@ -136,26 +137,21 @@ where
     F: Fn(*mut ffi::lua_State) -> R,
     R: Copy,
 {
-    union URes<R: Copy> {
-        uninit: (),
-        init: R,
-    }
-
     struct Params<F, R: Copy> {
         function: F,
-        result: URes<R>,
+        result: MaybeUninit<R>,
         nresults: c_int,
     }
 
     unsafe extern "C" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
     where
-        R: Copy,
         F: Fn(*mut ffi::lua_State) -> R,
+        R: Copy,
     {
         let params = ffi::lua_touserdata(state, -1) as *mut Params<F, R>;
         ffi::lua_pop(state, 1);
 
-        (*params).result.init = ((*params).function)(state);
+        (*params).result.write(((*params).function)(state));
 
         if (*params).nresults == ffi::LUA_MULTRET {
             ffi::lua_gettop(state)
@@ -174,7 +170,7 @@ where
 
     let mut params = Params {
         function: f,
-        result: URes { uninit: () },
+        result: MaybeUninit::uninit(),
         nresults,
     };
 
@@ -185,7 +181,7 @@ where
     if ret == ffi::LUA_OK {
         // `LUA_OK` is only returned when the `do_call` function has completed successfully, so
         // `params.result` is definitely initialized.
-        Ok(params.result.init)
+        Ok(params.result.assume_init())
     } else {
         Err(pop_error(state, ret))
     }
@@ -203,7 +199,7 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
         "pop_error called with non-error return code"
     );
 
-    match get_gc_userdata::<WrappedFailure>(state, -1).as_mut() {
+    match get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_mut() {
         Some(WrappedFailure::Error(err)) => {
             ffi::lua_pop(state, 1);
             err.clone()
@@ -246,14 +242,9 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
     }
 }
 
-// Uses 3 stack spaces, does not call checkstack.
-#[inline]
-pub unsafe fn push_string<S: AsRef<[u8]> + ?Sized>(
-    state: *mut ffi::lua_State,
-    s: &S,
-    protect: bool,
-) -> Result<()> {
-    let s = s.as_ref();
+// Uses 3 (or 1 if unprotected) stack spaces, does not call checkstack.
+#[inline(always)]
+pub unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect: bool) -> Result<()> {
     if protect {
         protect_lua!(state, 0, 1, |state| {
             ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
@@ -314,13 +305,10 @@ pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool)
 #[inline]
 pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
     unsafe extern "C" fn destructor<T>(ud: *mut c_void) {
-        let ud = ud as *mut T;
-        if *(ud.offset(1) as *mut u8) == 0 {
-            ptr::drop_in_place(ud);
-        }
+        ptr::drop_in_place(ud as *mut T);
     }
 
-    let size = mem::size_of::<T>() + 1;
+    let size = mem::size_of::<T>();
     let ud = if protect {
         protect_lua!(state, 0, 1, |state| {
             ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
@@ -329,7 +317,6 @@ pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool)
         ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
     };
     ptr::write(ud, t);
-    *(ud.offset(1) as *mut u8) = 0; // Mark as not destructed
 
     Ok(())
 }
@@ -373,10 +360,12 @@ pub unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
     get_destructed_userdata_metatable(state);
     ffi::lua_setmetatable(state, -2);
     let ud = get_userdata::<T>(state, -1);
+
+    // Update userdata tag to disable destructor and mark as destructed
+    #[cfg(feature = "luau")]
+    ffi::lua_setuserdatatag(state, -1, 1);
+
     ffi::lua_pop(state, 1);
-    if cfg!(feature = "luau") {
-        *(ud.offset(1) as *mut u8) = 1; // Mark as destructed
-    }
     ptr::read(ud)
 }
 
@@ -394,16 +383,28 @@ pub unsafe fn push_gc_userdata<T: Any>(
 }
 
 // Uses 2 stack spaces, does not call checkstack
-pub unsafe fn get_gc_userdata<T: Any>(state: *mut ffi::lua_State, index: c_int) -> *mut T {
+pub unsafe fn get_gc_userdata<T: Any>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+    mt_ptr: *const c_void,
+) -> *mut T {
     let ud = ffi::lua_touserdata(state, index) as *mut T;
     if ud.is_null() || ffi::lua_getmetatable(state, index) == 0 {
         return ptr::null_mut();
     }
-    get_gc_metatable::<T>(state);
-    let res = ffi::lua_rawequal(state, -1, -2);
-    ffi::lua_pop(state, 2);
-    if res == 0 {
-        return ptr::null_mut();
+    if !mt_ptr.is_null() {
+        let ud_mt_ptr = ffi::lua_topointer(state, -1);
+        ffi::lua_pop(state, 1);
+        if !ptr::eq(ud_mt_ptr, mt_ptr) {
+            return ptr::null_mut();
+        }
+    } else {
+        get_gc_metatable::<T>(state);
+        let res = ffi::lua_rawequal(state, -1, -2);
+        ffi::lua_pop(state, 2);
+        if res == 0 {
+            return ptr::null_mut();
+        }
     }
     ud
 }
@@ -542,7 +543,7 @@ pub unsafe fn init_userdata_metatable<T>(
         // Push `__index` generator function
         init_userdata_metatable_index(state)?;
 
-        push_string(state, "__index", true)?;
+        push_string(state, b"__index", true)?;
         let index_type = ffi::lua_rawget(state, -3);
         match index_type {
             ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
@@ -567,7 +568,7 @@ pub unsafe fn init_userdata_metatable<T>(
         // Push `__newindex` generator function
         init_userdata_metatable_newindex(state)?;
 
-        push_string(state, "__newindex", true)?;
+        push_string(state, b"__newindex", true)?;
         let newindex_type = ffi::lua_rawget(state, -3);
         match newindex_type {
             ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
@@ -679,7 +680,7 @@ pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
         return 1;
     }
 
-    if get_gc_userdata::<WrappedFailure>(state, -1).is_null() {
+    if get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
         let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
         if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
             ffi::luaL_traceback(state, state, s, 0);
@@ -690,6 +691,20 @@ pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
     1
 }
 
+// A variant of `error_traceback` that can safely inspect another (yielded) thread stack
+pub unsafe fn error_traceback_thread(state: *mut ffi::lua_State, thread: *mut ffi::lua_State) {
+    // Move error object to the main thread to safely call `__tostring` metamethod if present
+    ffi::lua_xmove(thread, state, 1);
+
+    if get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).is_null() {
+        let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
+        if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
+            ffi::luaL_traceback(state, thread, s, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+}
+
 // A variant of `pcall` that does not allow Lua to catch Rust panics from `callback_error`.
 pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
     ffi::luaL_checkstack(state, 2, ptr::null());
@@ -706,7 +721,7 @@ pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
         ffi::lua_gettop(state)
     } else {
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             ffi::lua_error(state);
         }
@@ -722,7 +737,7 @@ pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
         ffi::luaL_checkstack(state, 2, ptr::null());
 
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             1
         } else {
@@ -752,7 +767,7 @@ pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
         ffi::lua_gettop(state) - 1
     } else {
         if let Some(WrappedFailure::Panic(_)) =
-            get_gc_userdata::<WrappedFailure>(state, -1).as_ref()
+            get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref()
         {
             ffi::lua_error(state);
         }
@@ -836,7 +851,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         callback_error(state, |_| {
             check_stack(state, 3)?;
 
-            let err_buf = match get_gc_userdata::<WrappedFailure>(state, -1).as_ref() {
+            let err_buf = match get_gc_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref() {
                 Some(WrappedFailure::Error(error)) => {
                     let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
                     ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
@@ -873,7 +888,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
                 }
             }?;
 
-            push_string(state, &*err_buf, true)?;
+            push_string(state, (*err_buf).as_bytes(), true)?;
             (*err_buf).clear();
 
             Ok(1)
@@ -936,6 +951,8 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
         "__pairs",
         #[cfg(any(feature = "lua53", feature = "lua52", feature = "luajit52"))]
         "__ipairs",
+        #[cfg(feature = "luau")]
+        "__iter",
         #[cfg(feature = "lua54")]
         "__close",
     ] {

src/value.rs

@@ -1,4 +1,5 @@
 use std::iter::{self, FromIterator};
+use std::ops::Index;
 use std::os::raw::c_void;
 use std::{ptr, slice, str, vec};
 
@@ -103,17 +104,18 @@ impl<'lua> Value<'lua> {
     /// There is no way to convert the pointer back to its original value.
     ///
     /// Typically this function is used only for hashing and debug information.
+    #[inline]
     pub fn to_pointer(&self) -> *const c_void {
         unsafe {
             match self {
                 Value::LightUserData(ud) => ud.0,
-                Value::String(String(v))
-                | Value::Table(Table(v))
-                | Value::Function(Function(v))
-                | Value::Thread(Thread(v))
-                | Value::UserData(AnyUserData(v)) => v
-                    .lua
-                    .ref_thread_exec(|refthr| ffi::lua_topointer(refthr, v.index)),
+                Value::Table(t) => t.to_pointer(),
+                Value::String(s) => s.to_pointer(),
+                Value::Function(Function(r))
+                | Value::Thread(Thread(r))
+                | Value::UserData(AnyUserData(r)) => {
+                    ffi::lua_topointer(r.lua.ref_thread(), r.index)
+                }
                 _ => ptr::null(),
             }
         }
@@ -237,7 +239,24 @@ impl<'a, 'lua> IntoIterator for &'a MultiValue<'lua> {
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
-        (&self.0).iter().rev()
+        self.0.iter().rev()
+    }
+}
+
+impl<'lua> Index<usize> for MultiValue<'lua> {
+    type Output = Value<'lua>;
+
+    #[inline]
+    fn index(&self, index: usize) -> &Self::Output {
+        if let Some(result) = self.get(index) {
+            result
+        } else {
+            panic!(
+                "index out of bounds: the len is {} but the index is {}",
+                self.len(),
+                index
+            )
+        }
     }
 }
 
@@ -255,19 +274,24 @@ impl<'lua> MultiValue<'lua> {
         v
     }
 
+    #[inline]
+    pub fn get(&self, index: usize) -> Option<&Value<'lua>> {
+        self.0.get(self.0.len() - index - 1)
+    }
+
     #[inline]
     pub(crate) fn reserve(&mut self, size: usize) {
         self.0.reserve(size);
     }
 
     #[inline]
-    pub(crate) fn push_front(&mut self, value: Value<'lua>) {
-        self.0.push(value);
+    pub fn pop_front(&mut self) -> Option<Value<'lua>> {
+        self.0.pop()
     }
 
     #[inline]
-    pub(crate) fn pop_front(&mut self) -> Option<Value<'lua>> {
-        self.0.pop()
+    pub fn push_front(&mut self, value: Value<'lua>) {
+        self.0.push(value);
     }
 
     #[inline]

tests/async.rs

@@ -174,6 +174,38 @@ async fn test_async_return_async_closure() -> Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "lua54")]
+#[tokio::test]
+async fn test_async_lua54_to_be_closed() -> Result<()> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    globals.set("close_count", 0)?;
+
+    let code = r#"
+        local t <close> = setmetatable({}, {
+            __close = function()
+                close_count = close_count + 1
+            end
+        })
+        error "test"
+    "#;
+    let f = lua.load(code).into_function()?;
+
+    // Test close using call_async
+    let _ = f.call_async::<_, ()>(()).await;
+    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+
+    // Don't close by default when awaiting async threads
+    let co = lua.create_thread(f.clone())?;
+    let _ = co.clone().into_async::<_, ()>(()).await;
+    assert_eq!(globals.get::<_, usize>("close_count")?, 1);
+    let _ = co.reset(f);
+    assert_eq!(globals.get::<_, usize>("close_count")?, 2);
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_thread_stream() -> Result<()> {
     let lua = Lua::new();
@@ -278,6 +310,28 @@ async fn test_async_table() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_async_thread_cache() -> Result<()> {
+    let options = LuaOptions::new().thread_cache_size(4);
+    let lua = Lua::new_with(StdLib::ALL_SAFE, options)?;
+
+    let error_f = lua.create_async_function(|_, ()| async move {
+        Delay::new(Duration::from_millis(10)).await;
+        Err::<(), _>(Error::RuntimeError("test".to_string()))
+    })?;
+
+    let sleep = lua.create_async_function(|_, n| async move {
+        Delay::new(Duration::from_millis(n)).await;
+        Ok(format!("elapsed:{}ms", n))
+    })?;
+
+    assert!(error_f.call_async::<_, ()>(()).await.is_err());
+    // Next call should use cached thread
+    assert_eq!(sleep.call_async::<_, String>(3).await?, "elapsed:3ms");
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_userdata() -> Result<()> {
     #[derive(Clone)]
@@ -372,6 +426,30 @@ async fn test_async_userdata() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_async_thread_error() -> Result<()> {
+    struct MyUserData;
+
+    impl UserData for MyUserData {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_meta_method("__tostring", |_, _this, ()| Ok("myuserdata error"))
+        }
+    }
+
+    let lua = Lua::new();
+    let result = lua
+        .load("function x(...) error(...) end x(...)")
+        .set_name("chunk")?
+        .call_async::<_, ()>(MyUserData)
+        .await;
+    assert!(
+        matches!(result, Err(Error::RuntimeError(cause)) if cause.contains("myuserdata error")),
+        "improper error traceback from dead thread"
+    );
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_async_scope() -> Result<()> {
     let ref lua = Lua::new();

tests/compile/async_nonstatic_userdata.rs

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

tests/compile/async_nonstatic_userdata.stderr

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

tests/compile/function_borrow.stderr

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

tests/compile/lua_norefunwindsafe.stderr

@@ -10,7 +10,11 @@ error[E0277]: the type `UnsafeCell<mlua::lua::LuaInner>` may contain interior mu
     = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::LuaInner>>`
     = note: required because it appears within the type `Lua`
     = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
+note: required because it's used within this closure
+   --> tests/compile/lua_norefunwindsafe.rs:7:18
+    |
+7   |     catch_unwind(|| lua.create_table().unwrap());
+    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `catch_unwind`
    --> $RUST/std/src/panic.rs
     |

tests/compile/non_send.stderr

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

tests/compile/ref_nounwindsafe.stderr

@@ -12,7 +12,11 @@ error[E0277]: the type `UnsafeCell<mlua::lua::LuaInner>` may contain interior mu
     = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
     = note: required because it appears within the type `mlua::types::LuaRef<'_>`
     = note: required because it appears within the type `LuaTable<'_>`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
+note: required because it's used within this closure
+   --> tests/compile/ref_nounwindsafe.rs:8:18
+    |
+8   |     catch_unwind(move || table.set("a", "b").unwrap());
+    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `catch_unwind`
    --> $RUST/std/src/panic.rs
     |

tests/compile/scope_invariance.stderr

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

tests/compile/static_callback_args.stderr

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

tests/function.rs

@@ -42,11 +42,17 @@ fn test_bind() -> Result<()> {
     concat = concat.bind("foo")?;
     concat = concat.bind("bar")?;
     concat = concat.bind(("baz", "baf"))?;
+    assert_eq!(concat.call::<_, String>(())?, "foobarbazbaf");
     assert_eq!(
         concat.call::<_, String>(("hi", "wut"))?,
         "foobarbazbafhiwut"
     );
 
+    let mut concat2 = globals.get::<_, Function>("concat")?;
+    concat2 = concat2.bind(())?;
+    assert_eq!(concat2.call::<_, String>(())?, "");
+    assert_eq!(concat2.call::<_, String>(("ab", "cd"))?, "abcd");
+
     Ok(())
 }
 

tests/luau.rs

@@ -1,7 +1,9 @@
 #![cfg(feature = "luau")]
 
 use std::env;
+use std::fmt::Debug;
 use std::fs;
+use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 
@@ -15,8 +17,11 @@ fn test_require() -> Result<()> {
     fs::write(
         temp_dir.path().join("module.luau"),
         r#"
-        counter = counter or 0
-        return counter + 1
+        counter = (counter or 0) + 1
+        return {
+            counter = counter,
+            error = function() error("test") end,
+        }
     "#,
     )?;
 
@@ -24,9 +29,12 @@ fn test_require() -> Result<()> {
     lua.load(
         r#"
         local module = require("module")
-        assert(module == 1)
+        assert(module.counter == 1)
         module = require("module")
-        assert(module == 1)
+        assert(module.counter == 1)
+
+        local ok, err = pcall(module.error)
+        assert(not ok and string.find(err, "module.luau") ~= nil)
     "#,
     )
     .exec()
@@ -69,18 +77,33 @@ fn test_vectors() -> Result<()> {
 fn test_readonly_table() -> Result<()> {
     let lua = Lua::new();
 
-    let t = lua.create_table()?;
+    let t = lua.create_sequence_from([1])?;
     assert!(!t.is_readonly());
     t.set_readonly(true);
     assert!(t.is_readonly());
 
-    match t.set("key", "value") {
-        Err(Error::RuntimeError(err)) if err.contains("Attempt to modify a readonly table") => {}
-        r => panic!(
-            "expected RuntimeError(...) with a specific message, got {:?}",
-            r
-        ),
-    };
+    #[track_caller]
+    fn check_readonly_error<T: Debug>(res: Result<T>) {
+        match res {
+            Err(Error::RuntimeError(e)) if e.contains("attempt to modify a readonly table") => {}
+            r => panic!("expected RuntimeError(...) with a specific message, got {r:?}"),
+        }
+    }
+
+    check_readonly_error(t.set("key", "value"));
+    check_readonly_error(t.raw_set("key", "value"));
+    check_readonly_error(t.raw_insert(1, "value"));
+    check_readonly_error(t.raw_remove(1));
+    check_readonly_error(t.push("value"));
+    check_readonly_error(t.pop::<Value>());
+    check_readonly_error(t.raw_push("value"));
+    check_readonly_error(t.raw_pop::<Value>());
+
+    // Special case
+    match catch_unwind(AssertUnwindSafe(|| t.set_metatable(None))) {
+        Ok(_) => panic!("expected panic, got nothing"),
+        Err(_) => {}
+    }
 
     Ok(())
 }
@@ -214,7 +237,7 @@ fn test_interrupts() -> Result<()> {
 }
 
 #[test]
-fn test_coverate() -> Result<()> {
+fn test_coverage() -> Result<()> {
     let lua = Lua::new();
 
     lua.set_compiler(Compiler::default().set_coverage_level(1));

tests/table.rs

@@ -109,6 +109,49 @@ fn test_table() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_table_push_pop() -> Result<()> {
+    let lua = Lua::new();
+
+    // Test raw access
+    let table1 = lua.create_sequence_from(vec![123])?;
+    table1.raw_push(321)?;
+    assert_eq!(
+        table1
+            .clone()
+            .raw_sequence_values::<i64>()
+            .collect::<Result<Vec<_>>>()?,
+        vec![123, 321]
+    );
+    assert_eq!(table1.raw_pop::<i64>()?, 321);
+    assert_eq!(table1.raw_pop::<i64>()?, 123);
+    assert_eq!(table1.raw_pop::<Value>()?, Value::Nil); // An extra pop should do nothing
+    assert_eq!(table1.raw_len(), 0);
+
+    // Test access through metamethods
+    let table2 = lua
+        .load(
+            r#"
+        local proxy_table = {234}
+        table2 = setmetatable({}, {
+            __len = function() return #proxy_table end,
+            __index = proxy_table,
+            __newindex = proxy_table,
+        })
+        return table2
+    "#,
+        )
+        .eval::<Table>()?;
+    table2.push(345)?;
+    assert_eq!(table2.len()?, 2);
+    assert_eq!(table2.pop::<i64>()?, 345);
+    assert_eq!(table2.pop::<i64>()?, 234);
+    assert_eq!(table2.pop::<Value>()?, Value::Nil);
+    assert_eq!(table2.len()?, 0);
+
+    Ok(())
+}
+
 #[test]
 fn test_table_sequence_from() -> Result<()> {
     let lua = Lua::new();

tests/tests.rs

@@ -73,6 +73,7 @@ fn test_load() -> Result<()> {
     let result: i32 = func.call(())?;
     assert_eq!(result, 3);
 
+    assert!(lua.load("").exec().is_ok());
     assert!(lua.load("§$%§&$%&").exec().is_err());
 
     Ok(())

tests/userdata.rs

@@ -656,3 +656,44 @@ fn test_userdata_wrapped() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_userdata_proxy() -> Result<()> {
+    struct MyUserData(i64);
+
+    impl UserData for MyUserData {
+        fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+            fields.add_field_function_get("static_field", |_, _| Ok(123));
+            fields.add_field_method_get("n", |_, this| Ok(this.0));
+        }
+
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_function("new", |_, n| Ok(Self(n)));
+
+            methods.add_method("plus", |_, this, n: i64| Ok(this.0 + n));
+        }
+    }
+
+    let lua = Lua::new();
+    let globals = lua.globals();
+    globals.set("MyUserData", lua.create_proxy::<MyUserData>()?)?;
+
+    lua.load(
+        r#"
+        assert(MyUserData.static_field == 123)
+        local data = MyUserData.new(321)
+        assert(data.static_field == 123)
+        assert(data.n == 321)
+        assert(data:plus(1) == 322)
+
+        -- Error when accessing the proxy object fields and methods that require instance
+
+        local ok = pcall(function() return MyUserData.n end)
+        assert(not ok)
+
+        ok = pcall(function() return MyUserData:plus(1) end)
+        assert(not ok)
+    "#,
+    )
+    .exec()
+}