Add wasm32 tests and CI coverage (including wasm32-unknown-unknown)

Author: khvzak

.github/actions/setup-wasm/action.yml

@@ -0,0 +1,54 @@
+name: Setup Wasm dependencies
+description: Install Rust, WASI SDK, and Wasmtime on x86_64 Linux
+inputs:
+  target:
+    description: Rust target (wasm32-unknown-unknown/wasm32-wasipx)
+    required: true
+  c_target:
+    description: C target for wasm32-unknown-unknown (wasm32-wasip1 or wasm32-wasip2)
+    default: wasm32-wasip1
+  toolchain:
+    description: Rust toolchain
+    default: stable
+  wasi_sdk:
+    description: WASI SDK version
+    default: '34'
+  wasmtime:
+    description: Wasmtime version for WASI targets
+    default: v50.0.0
+
+runs:
+  using: composite
+  steps:
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        toolchain: ${{ inputs.toolchain }}
+        target: ${{ inputs.target }}
+    - name: Install WASI SDK
+      shell: bash
+      working-directory: ${{ runner.tool_cache }}
+      env:
+        WASI_SDK_VERSION: ${{ inputs.wasi_sdk }}
+      run: |
+        archive="wasi-sdk-$WASI_SDK_VERSION.0-x86_64-linux"
+        curl -fLO "https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-$WASI_SDK_VERSION/$archive.tar.gz"
+        tar xf "$archive.tar.gz"
+        echo "WASI_SDK_PATH=$PWD/$archive" >> "$GITHUB_ENV"
+    - name: Install Wasmtime
+      shell: bash
+      working-directory: ${{ runner.tool_cache }}
+      env:
+        WASMTIME_VERSION: ${{ inputs.wasmtime }}
+      run: |
+        archive="wasmtime-$WASMTIME_VERSION-x86_64-linux"
+        curl -fLO "https://github.com/bytecodealliance/wasmtime/releases/download/$WASMTIME_VERSION/$archive.tar.xz"
+        tar xf "$archive.tar.xz"
+        echo "$PWD/$archive" >> "$GITHUB_PATH"
+    - name: Configure Wasm build
+      shell: bash
+      env:
+        WASM_TARGET: ${{ inputs.target }}
+        WASM_C_TARGET: ${{ inputs.c_target }}
+      run: |
+        source "$GITHUB_WORKSPACE/tests/wasm/setup.sh" "$WASM_TARGET" "$WASM_C_TARGET"
+        printf '%s\n' "${wasm_env[@]}" >> "$GITHUB_ENV"

.github/workflows/main.yml

@@ -240,37 +240,47 @@ jobs:
           cargo test --tests --features "${{ matrix.lua }},vendored"
           cargo test --tests --features "${{ matrix.lua }},vendored,async,serde,macros,anyhow,userdata-wrappers"
 
-  test_wasm32_wasip2:
-    name: Test on wasm32-wasip2
+  test_wasm32_unknown:
+    name: Test on wasm32-unknown-unknown (${{ matrix.c_target }})
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     needs: build
     strategy:
       matrix:
-        lua: [lua55, lua54, lua53, lua52, lua51]
+        lua: [lua55, lua54, lua53, lua52, lua51, luau]
+        c_target: [wasm32-wasip1, wasm32-wasip2]
     steps:
       - uses: actions/checkout@main
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: ./.github/actions/setup-wasm
         with:
-          toolchain: nightly-2025-10-02
-          target: wasm32-wasip2
-      - name: Install wasi-sdk/Wasmtime
-        working-directory: ${{ runner.tool_cache }}
-        run: |
-          wasi_sdk=29
-          wasmtime=v40.0.1
+          target: wasm32-unknown-unknown
+          c_target: ${{ matrix.c_target }}
+      - name: Run Wasm tests
+        run: bash tests/wasm/run.sh "${{ matrix.lua }}" "${{ matrix.c_target }}"
 
-          curl -LO https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-$wasi_sdk/wasi-sdk-$wasi_sdk.0-x86_64-linux.tar.gz
-          tar xf wasi-sdk-$wasi_sdk.0-x86_64-linux.tar.gz
-          WASI_SDK_PATH=`pwd`/wasi-sdk-$wasi_sdk.0-x86_64-linux
-          echo "WASI_SDK_PATH=$WASI_SDK_PATH" >> $GITHUB_ENV
-          echo "CC_wasm32_wasip2=$WASI_SDK_PATH/bin/clang" >> $GITHUB_ENV
-          echo "CARGO_TARGET_WASM32_WASIP2_LINKER=$WASI_SDK_PATH/bin/clang" >> $GITHUB_ENV
-          echo "CARGO_TARGET_WASM32_WASIP2_RUSTFLAGS=-Clink-arg=-Wl,--export=cabi_realloc" >> $GITHUB_ENV
-
-          curl -LO https://github.com/bytecodealliance/wasmtime/releases/download/$wasmtime/wasmtime-$wasmtime-x86_64-linux.tar.xz
-          tar xf wasmtime-$wasmtime-x86_64-linux.tar.xz
-          echo "CARGO_TARGET_WASM32_WASIP2_RUNNER=`pwd`/wasmtime-$wasmtime-x86_64-linux/wasmtime -W exceptions" >> $GITHUB_ENV
-      - name: Run ${{ matrix.lua }} tests
+  test_wasm32_wasi:
+    name: Test on ${{ matrix.target }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua55, lua54, lua53, lua52, lua51, luau]
+        target: [wasm32-wasip1, wasm32-wasip2, wasm32-wasip3]
+        include:
+          # Stable Rust does not yet distribute the WASIp3 standard library.
+          - target: wasm32-wasip3
+            toolchain: nightly
+    steps:
+      - uses: actions/checkout@main
+      - uses: ./.github/actions/setup-wasm
+        with:
+          target: ${{ matrix.target }}
+          toolchain: ${{ matrix.toolchain || 'stable' }}
+      - name: Run Wasm tests
+        run: cargo test --manifest-path tests/wasm/Cargo.toml --target ${{ matrix.target }} --lib --features "${{ matrix.lua }}"
+      - name: Run full ${{ matrix.lua }} tests
+        if: ${{ matrix.target == 'wasm32-wasip2' && matrix.lua != 'luau' }}
         run: |
           cargo test --target wasm32-wasip2 --tests --features "${{ matrix.lua }},vendored"
           cargo test --target wasm32-wasip2 --tests --features "${{ matrix.lua }},vendored,serde,macros,anyhow,userdata-wrappers"
@@ -283,7 +293,9 @@ jobs:
       - uses: dtolnay/rust-toolchain@nightly
         with:
           components: rustfmt
-      - run: cargo fmt -- --check
+      - run: |
+          cargo fmt -- --check
+          cargo fmt --manifest-path tests/wasm/Cargo.toml -- --check
 
   clippy:
     name: Clippy

tests/wasm/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "mlua-wasm-tests"
+version = "0.0.0"
+edition = "2024"
+publish = false
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[features]
+luau = ["mlua/luau"]
+lua55 = ["mlua/lua55", "mlua/vendored"]
+lua54 = ["mlua/lua54", "mlua/vendored"]
+lua53 = ["mlua/lua53", "mlua/vendored"]
+lua52 = ["mlua/lua52", "mlua/vendored"]
+lua51 = ["mlua/lua51", "mlua/vendored"]
+
+[dependencies]
+mlua = { path = "../.." }

tests/wasm/main.c

@@ -0,0 +1,6 @@
+extern void run_tests(void);
+
+int main(void) {
+    run_tests();
+    return 0;
+}

tests/wasm/run.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+lua="${1:-luau}"
+c_target="${2:-wasm32-wasip1}"
+if [[ $# -gt 2 || ! "$lua" =~ ^(luau|lua5[1-5])$ || ! "$c_target" =~ ^wasm32-wasip[12]$ ]]; then
+    echo "Usage: $0 [lua55|lua54|lua53|lua52|lua51|luau] [wasm32-wasip1|wasm32-wasip2]" >&2
+    exit 2
+fi
+
+cd "$(dirname "$0")/../.."
+source tests/wasm/setup.sh wasm32-unknown-unknown "$c_target"
+export CARGO_TARGET_DIR="$PWD/target/wasm-tests"
+cargo_args=(--manifest-path tests/wasm/Cargo.toml --target wasm32-unknown-unknown --features "$lua")
+wasm_output="$CARGO_TARGET_DIR/wasm32-unknown-unknown/debug/mlua_wasm_tests.wasm"
+if [[ "$c_target" == wasm32-wasip1 ]]; then
+    cargo build "${cargo_args[@]}"
+    "${wasm_runner[@]}" --invoke run_tests "$wasm_output"
+else
+    # The SDK links the bare Rust static library into a WASIp2 command component.
+    wasm_output="${wasm_output%.wasm}.component.wasm"
+    cargo rustc "${cargo_args[@]}" --lib --crate-type staticlib
+    "$WASI_SDK_PATH/bin/clang" --target="$c_target" tests/wasm/main.c \
+        "$CARGO_TARGET_DIR/wasm32-unknown-unknown/debug/libmlua_wasm_tests.a" \
+        -L"$wasm_lib/eh" -lc++ -lsetjmp -o "$wasm_output"
+    "${wasm_runner[@]}" "$wasm_output"
+fi

tests/wasm/setup.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+
+# Source with a Rust target and optional C target for wasm32-unknown-unknown.
+: "${WASI_SDK_PATH:?Set WASI_SDK_PATH}"
+wasm_target="${1:?Pass a Rust target}"
+wasm_c_target="$wasm_target"
+if [[ "$wasm_target" == wasm32-unknown-unknown ]]; then
+    wasm_c_target="${2:-wasm32-wasip1}"
+fi
+wasm_cc_target="${wasm_target//-/_}"
+wasm_cargo_target="CARGO_TARGET_$(printf '%s' "$wasm_cc_target" | tr '[:lower:]' '[:upper:]')"
+wasm_lib="$WASI_SDK_PATH/share/wasi-sysroot/lib/$wasm_c_target"
+wasm_rustflags="-Lnative=$wasm_lib/eh -Lnative=$wasm_lib -lstatic=c++abi -lstatic=unwind -lstatic=wasi-emulated-process-clocks"
+# Match the SDK's standard Wasm exception ABI.
+# https://github.com/WebAssembly/wasi-sdk/blob/wasi-sdk-34/CppExceptions.md
+wasm_cxxflags="-fexceptions -fwasm-exceptions -mllvm -wasm-use-legacy-eh=false"
+wasm_runner=(wasmtime -W exceptions)
+wasm_env=(
+    "CC_$wasm_cc_target=$WASI_SDK_PATH/bin/clang"
+    "CXX_$wasm_cc_target=$WASI_SDK_PATH/bin/clang++"
+    "AR_$wasm_cc_target=$WASI_SDK_PATH/bin/llvm-ar"
+    "CXXSTDLIB_$wasm_cc_target=c++"
+)
+if [[ "$wasm_target" == wasm32-unknown-unknown ]]; then
+    wasm_env+=("CFLAGS_$wasm_cc_target=--target=$wasm_c_target")
+    wasm_cxxflags="--target=$wasm_c_target $wasm_cxxflags"
+    if [[ "$wasm_c_target" == wasm32-wasip1 ]]; then
+        wasm_rustflags+=" -lstatic=c"
+    fi
+else
+    wasm_env+=("${wasm_cargo_target}_LINKER=$WASI_SDK_PATH/bin/clang")
+    wasm_rustflags+=" -Clink-self-contained=no"
+    if [[ "$wasm_target" != wasm32-wasip1 ]]; then
+        wasm_rustflags+=" -Clink-arg=-Wl,--export=cabi_realloc"
+    fi
+fi
+if [[ "$wasm_target" == wasm32-wasip3 ]]; then
+    wasm_runner+=(-S p3)
+fi
+wasm_env+=(
+    "LUAU_CXXFLAGS=$wasm_cxxflags"
+    "${wasm_cargo_target}_RUSTFLAGS=$wasm_rustflags"
+    "${wasm_cargo_target}_RUNNER=${wasm_runner[*]}"
+)
+export "${wasm_env[@]}"

tests/wasm/src/lib.rs

@@ -0,0 +1,96 @@
+use mlua::{Error, Lua};
+
+#[cfg(target_os = "unknown")]
+mod allocator {
+    use std::alloc::{GlobalAlloc, Layout};
+    use std::ffi::c_void;
+
+    // Rust and WASI libc must share an allocator
+    struct WasiAllocator;
+
+    unsafe extern "C" {
+        fn posix_memalign(ptr: *mut *mut c_void, align: usize, size: usize) -> i32;
+        fn free(ptr: *mut c_void);
+    }
+
+    unsafe impl GlobalAlloc for WasiAllocator {
+        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+            let mut ptr = std::ptr::null_mut();
+            if unsafe { posix_memalign(&mut ptr, layout.align().max(size_of::<usize>()), layout.size()) } != 0
+            {
+                return std::ptr::null_mut();
+            }
+            ptr.cast()
+        }
+
+        unsafe fn dealloc(&self, ptr: *mut u8, _: Layout) {
+            unsafe { free(ptr.cast()) };
+        }
+    }
+
+    #[global_allocator]
+    static ALLOCATOR: WasiAllocator = WasiAllocator;
+}
+
+#[cfg(target_os = "unknown")]
+#[unsafe(no_mangle)]
+pub extern "C" fn run_tests() {
+    test_eval();
+    test_errors();
+    test_callbacks();
+    test_coroutines();
+}
+
+#[cfg_attr(target_os = "wasi", test)]
+fn test_eval() {
+    let lua = Lua::new();
+    assert_eq!(lua.load("return 6 * 7").eval::<i32>().unwrap(), 42);
+}
+
+#[cfg_attr(target_os = "wasi", test)]
+fn test_errors() {
+    let lua = Lua::new();
+    assert!(matches!(
+        lua.load("local =").exec(),
+        Err(Error::SyntaxError { .. })
+    ));
+    assert!(matches!(
+        lua.load("error('test error')").exec(),
+        Err(Error::RuntimeError(_))
+    ));
+    assert!(
+        !lua.load("return pcall(function() error('test error') end)")
+            .eval::<bool>()
+            .unwrap()
+    );
+    assert_eq!(lua.load("return 42").eval::<i32>().unwrap(), 42);
+}
+
+#[cfg_attr(target_os = "wasi", test)]
+fn test_callbacks() {
+    let lua = Lua::new();
+    let double = lua.create_function(|_, n: i32| Ok(n * 2)).unwrap();
+    lua.globals().set("double", double).unwrap();
+    assert_eq!(lua.load("return double(21)").eval::<i32>().unwrap(), 42);
+    let fail = lua
+        .create_function(|_, ()| Err::<(), _>(Error::runtime("callback error")))
+        .unwrap();
+    lua.globals().set("fail", fail).unwrap();
+    assert!(matches!(
+        lua.load("fail()").exec(),
+        Err(Error::CallbackError { .. })
+    ));
+    assert!(!lua.load("return pcall(fail)").eval::<bool>().unwrap());
+}
+
+#[cfg_attr(target_os = "wasi", test)]
+fn test_coroutines() {
+    let lua = Lua::new();
+    let function = lua
+        .load("local n = ...; coroutine.yield(n); return n * 2")
+        .into_function()
+        .unwrap();
+    let thread = lua.create_thread(function).unwrap();
+    assert_eq!(thread.resume::<i32>(21).unwrap(), 21);
+    assert_eq!(thread.resume::<i32>(()).unwrap(), 42);
+}