Add luajit v,p,dump command support

.cargo/config.toml

@@ -0,0 +1,3 @@
+[build]
+rustflags = ["--cfg", "tokio_unstable"]
+rustdocflags = ["--cfg", "tokio_unstable"]

Cargo.lock

@@ -250,6 +250,12 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
+[[package]]
+name = "camino"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0da45bc31171d8d6960122e222a67740df867c1dd53b4d51caa297084c185cab"
+
 [[package]]
 name = "cc"
 version = "1.2.27"
@@ -370,6 +376,15 @@ dependencies = [
  "tracing-subscriber",
 ]
 
+[[package]]
+name = "convert_case"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.4.2"
@@ -429,6 +444,28 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "derive_more"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "unicode-xid",
+]
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -758,9 +795,12 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 name = "lb"
 version = "0.1.0"
 dependencies = [
+ "camino",
+ "derive_more",
  "luaffi",
  "luaify",
  "luajit",
+ "sysexits",
  "tokio",
 ]
 
@@ -872,6 +912,7 @@ dependencies = [
  "luajit",
  "mimalloc",
  "owo-colors",
+ "sysexits",
  "tokio",
  "tracing",
  "tracing-subscriber",
@@ -1364,6 +1405,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
 
+[[package]]
+name = "sysexits"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "198f60d1f7f003f168507691e42d082df109ef0f05c6fd006e22528371a5f1b4"
+
 [[package]]
 name = "thiserror"
 version = "2.0.12"
@@ -1596,6 +1643,18 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"

Cargo.toml

@@ -24,6 +24,7 @@ lb = { version = "0.1.0", path = "crates/lb" }
 luajit = { version = "0.1.0", path = "crates/luajit", features = ["runtime"] }
 mimalloc = "0.1.47"
 owo-colors = "4.2.1"
+sysexits = "0.9.0"
 tokio = { version = "1.45.1", features = ["full", "tracing"] }
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"

bacon.toml

@@ -1,10 +1,10 @@
 [jobs.test]
-command = ["cargo", "test", "--all"]
+command = ["cargo", "test", "--workspace"]
 need_stdout = true
 
 [jobs.doc]
-command = ["cargo", "doc", "--all", "--no-deps"]
+command = ["cargo", "doc", "--workspace"]
 
 [jobs.doc-open]
-command = ["cargo", "doc", "--all", "--no-deps", "--open"]
+command = ["cargo", "doc", "--workspace", "--open"]
 on_success = "back"

crates/lb/Cargo.toml

@@ -4,9 +4,12 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+camino = "1.1.10"
+derive_more = { version = "2.0.1", features = ["full"] }
 luaffi = { version = "0.1.0", path = "../luaffi" }
 luajit = { version = "0.1.0", path = "../luajit" }
-tokio = { version = "1.45.1", features = ["rt", "time", "fs"] }
+sysexits = "0.9.0"
+tokio = { version = "1.45.1", features = ["rt", "time", "fs", "net", "process", "signal"] }
 
 [dev-dependencies]
 luaify = { path = "../luaify" }

crates/lb/src/channel.rs

@@ -0,0 +1,64 @@
+// use flume::{Receiver, Sender};
+use luaffi::{cdef, metatype};
+
+#[cdef]
+pub struct lb_libchannel;
+
+#[metatype]
+impl lb_libchannel {
+    #[new]
+    extern "Lua-C" fn new() -> Self {
+        Self
+    }
+
+    extern "Lua" fn unbounded(self) {
+        let (send, recv) = (__new(__ct.lb_sender), __new(__ct.lb_receiver));
+        self.__unbounded(send, recv);
+        (send, recv)
+    }
+
+    extern "Lua" fn bounded(self, cap: number) {
+        assert(cap >= 0, "channel capacity must be nonnegative");
+        let (send, recv) = (__new(__ct.lb_sender), __new(__ct.lb_receiver));
+        self.__bounded(cap, send, recv);
+        (send, recv)
+    }
+
+    // extern "Lua-C" fn __unbounded(&self, s: *mut lb_sender, r: *mut lb_receiver) {
+    //     let (send, recv) = flume::unbounded();
+    //     unsafe {
+    //         ptr::write(s, lb_sender { send });
+    //         ptr::write(r, lb_receiver { recv });
+    //     }
+    // }
+
+    // extern "Lua-C" fn __bounded(&self, cap: usize, s: *mut lb_sender, r: *mut lb_receiver) {
+    //     let (send, recv) = flume::bounded(cap);
+    //     unsafe {
+    //         ptr::write(s, lb_sender { send });
+    //         ptr::write(r, lb_receiver { recv });
+    //     }
+    // }
+}
+
+// #[cdef]
+// pub struct lb_sender {
+//     #[opaque]
+//     send: Sender<c_int>,
+// }
+
+// #[metatype]
+// impl lb_sender {
+//     extern "Lua" fn send(self, value: _) {
+//         let key = __ref(value);
+//     }
+// }
+
+// #[cdef]
+// pub struct lb_receiver {
+//     #[opaque]
+//     recv: Receiver<c_int>,
+// }
+
+// #[metatype]
+// impl lb_receiver {}

crates/lb/src/fs.rs

@@ -0,0 +1,32 @@
+//! The `lb:fs` module provides utilities for interacting with the file system asynchronously.
+//!
+//! See [`lb_libfs`] for items exported by this module.
+use luaffi::{cdef, metatype};
+use std::io;
+use tokio::fs;
+
+/// Items exported by the `lb:fs` module.
+///
+/// This module can be obtained by calling `require` in Lua.
+///
+/// ```lua
+/// local fs = require("lb:fs");
+/// ```
+#[cdef]
+pub struct lb_libfs;
+
+#[metatype]
+impl lb_libfs {
+    #[new]
+    extern "Lua-C" fn new() -> Self {
+        Self
+    }
+
+    pub extern "Lua" fn read(&self, path: string) -> string {
+        self.__read(path)
+    }
+
+    async extern "Lua-C" fn __read(&self, path: &str) -> io::Result<Vec<u8>> {
+        fs::read(path).await
+    }
+}

crates/lb/src/lib.rs

@@ -1,2 +1,5 @@
-pub mod rt;
+pub mod channel;
+pub mod fs;
+pub mod net;
+pub mod runtime;
 pub mod task;

crates/lb/src/net.rs

@@ -0,0 +1,345 @@
+//! The `lb:net` module provides an asynchronous network API for creating TCP or UDP servers and
+//! clients.
+//!
+//! See [`lb_libnet`] for items exported by this module.
+use derive_more::{From, FromStr};
+use luaffi::{cdef, metatype};
+use std::{
+    io,
+    net::{AddrParseError, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+};
+use tokio::net::{TcpListener, TcpSocket, TcpStream};
+
+/// Items exported by the `lb:net` module.
+///
+/// This module can be obtained by calling `require` in Lua.
+///
+/// ```lua
+/// local net = require("lb:net");
+/// ```
+#[cdef]
+pub struct lb_libnet;
+
+#[metatype]
+impl lb_libnet {
+    #[new]
+    extern "Lua-C" fn new() -> Self {
+        Self
+    }
+
+    /// See [`Ipv4Addr::LOCALHOST`].
+    pub extern "Lua-C" fn localhost_v4(&self) -> lb_ipaddr {
+        lb_ipaddr(Ipv4Addr::LOCALHOST.into())
+    }
+
+    /// See [`Ipv6Addr::LOCALHOST`].
+    pub extern "Lua-C" fn localhost_v6(&self) -> lb_ipaddr {
+        lb_ipaddr(Ipv6Addr::LOCALHOST.into())
+    }
+
+    /// See [`Ipv4Addr::UNSPECIFIED`].
+    pub extern "Lua-C" fn unspecified_v4(&self) -> lb_ipaddr {
+        lb_ipaddr(Ipv4Addr::UNSPECIFIED.into())
+    }
+
+    /// See [`Ipv6Addr::UNSPECIFIED`].
+    pub extern "Lua-C" fn unspecified_v6(&self) -> lb_ipaddr {
+        lb_ipaddr(Ipv6Addr::UNSPECIFIED.into())
+    }
+
+    /// See [`Ipv4Addr::BROADCAST`].
+    pub extern "Lua-C" fn broadcast_v4(&self) -> lb_ipaddr {
+        lb_ipaddr(Ipv4Addr::BROADCAST.into())
+    }
+
+    /// Creates an [`lb_ipaddr`] from the given input.
+    ///
+    /// If `s` is an [`lb_ipaddr`], a copy of that value is returned. If `s` is an
+    /// [`lb_socketaddr`], the IP address part of the socket address is returned. Otherwise, parses
+    /// `s` as an IP address string. Both IPv4 or IPv6 addresses are supported.
+    ///
+    /// # Errors
+    ///
+    /// Throws if `s` cannot be parsed as an IP address.
+    pub extern "Lua" fn ipaddr(&self, s: any) -> lb_ipaddr {
+        if __istype(__ct.lb_ipaddr, s) {
+            __new(__ct.lb_ipaddr, s) // copy constructor
+        } else if __istype(__ct.lb_socketaddr, s) {
+            s.ip()
+        } else {
+            self.__parse_ipaddr(s)
+        }
+    }
+
+    extern "Lua-C" fn __parse_ipaddr(&self, s: &str) -> Result<lb_ipaddr, AddrParseError> {
+        s.parse()
+    }
+
+    /// Creates an [`lb_socketaddr`] from the given input.
+    ///
+    /// A socket address is an IP address with a port number.
+    ///
+    /// If `s` is an [`lb_socketaddr`], a copy of that value is returned. If `s` is an
+    /// [`lb_ipaddr`], a socket address with that IP address is returned. Otherwise, parses `s` as a
+    /// socket address string. Both IPv4 and IPv6 addresses are supported.
+    ///
+    /// If `port` is not specified, `0` is used as the default.
+    ///
+    /// # Errors
+    ///
+    /// Throws if `s` cannot be parsed as an IP or socket address.
+    pub extern "Lua" fn socketaddr(&self, s: any, port: any) -> lb_socketaddr {
+        if port != () {
+            self.__new_socketaddr(self.ipaddr(s), port)
+        } else {
+            if __istype(__ct.lb_socketaddr, s) {
+                __new(__ct.lb_socketaddr, s) // copy constructor
+            } else if __istype(__ct.lb_ipaddr, s) {
+                self.__new_socketaddr(s, 0) // default port 0
+            } else {
+                self.__parse_socketaddr(s)
+            }
+        }
+    }
+
+    extern "Lua-C" fn __new_socketaddr(&self, ip: &lb_ipaddr, port: u16) -> lb_socketaddr {
+        SocketAddr::new(ip.0, port).into()
+    }
+
+    extern "Lua-C" fn __parse_socketaddr(&self, s: &str) -> Result<lb_socketaddr, AddrParseError> {
+        s.parse()
+    }
+
+    /// Creates a new TCP socket configured for IPv4.
+    ///
+    /// See [`TcpSocket::new_v4`].
+    ///
+    /// # Errors
+    ///
+    /// Throws if an error was encountered during the socket creation.
+    pub extern "Lua" fn tcp_v4(&self) -> lb_tcpsocket {
+        self.__new_tcp_v4()
+    }
+
+    /// Creates a new TCP socket configured for IPv6.
+    ///
+    /// See [`TcpSocket::new_v6`].
+    ///
+    /// # Errors
+    ///
+    /// Throws if an error was encountered during the socket creation.
+    pub extern "Lua" fn tcp_v6(&self) -> lb_tcpsocket {
+        self.__new_tcp_v6()
+    }
+
+    extern "Lua-C" fn __new_tcp_v4(&self) -> io::Result<lb_tcpsocket> {
+        TcpSocket::new_v4().map(lb_tcpsocket)
+    }
+
+    extern "Lua-C" fn __new_tcp_v6(&self) -> io::Result<lb_tcpsocket> {
+        TcpSocket::new_v6().map(lb_tcpsocket)
+    }
+}
+
+/// An IP address, either IPv4 or IPv6.
+///
+/// # Example
+///
+/// This example creates an [`lb_ipaddr`] by parsing an IP address string.
+///
+/// ```lua
+/// local net = require("lb:net");
+/// local addr = net:ipaddr("127.0.0.1"); -- ipv4 loopback address
+///
+/// assert(addr:is_v4());
+/// assert(addr:is_loopback());
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq, From, FromStr)]
+#[cdef]
+pub struct lb_ipaddr(#[opaque] IpAddr);
+
+#[metatype]
+impl lb_ipaddr {
+    /// See [`IpAddr::is_unspecified`].
+    pub extern "Lua-C" fn is_unspecified(&self) -> bool {
+        self.0.is_unspecified()
+    }
+
+    /// See [`IpAddr::is_loopback`].
+    pub extern "Lua-C" fn is_loopback(&self) -> bool {
+        self.0.is_loopback()
+    }
+
+    /// See [`IpAddr::is_multicast`].
+    pub extern "Lua-C" fn is_multicast(&self) -> bool {
+        self.0.is_multicast()
+    }
+
+    /// Returns the string `"v4"` if this is an IPv4 address or `"v6"` if this is an IPv6 address.
+    pub extern "Lua" fn family(&self) -> string {
+        if self.is_v6() { "v6" } else { "v4" }
+    }
+
+    /// Returns `true` if this is an IPv4 address.
+    pub extern "Lua-C" fn is_v4(&self) -> bool {
+        self.0.is_ipv4()
+    }
+
+    /// See [`Ipv4Addr::is_private`].
+    pub extern "Lua-C" fn is_v4_private(&self) -> bool {
+        match self.0 {
+            IpAddr::V4(v4) => v4.is_private(),
+            IpAddr::V6(_) => false,
+        }
+    }
+
+    /// See [`Ipv4Addr::is_link_local`].
+    pub extern "Lua-C" fn is_v4_link_local(&self) -> bool {
+        match self.0 {
+            IpAddr::V4(v4) => v4.is_link_local(),
+            IpAddr::V6(_) => false,
+        }
+    }
+
+    /// See [`Ipv4Addr::is_broadcast`].
+    pub extern "Lua-C" fn is_v4_broadcast(&self) -> bool {
+        match self.0 {
+            IpAddr::V4(v4) => v4.is_broadcast(),
+            IpAddr::V6(_) => false,
+        }
+    }
+
+    /// See [`Ipv4Addr::is_documentation`].
+    pub extern "Lua-C" fn is_v4_documentation(&self) -> bool {
+        match self.0 {
+            IpAddr::V4(v4) => v4.is_documentation(),
+            IpAddr::V6(_) => false,
+        }
+    }
+
+    /// Returns `true` if this is an IPv6 address.
+    pub extern "Lua-C" fn is_v6(&self) -> bool {
+        self.0.is_ipv6()
+    }
+
+    /// See [`Ipv6Addr::is_unique_local`].
+    pub extern "Lua-C" fn is_v6_unique_local(&self) -> bool {
+        match self.0 {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => v6.is_unique_local(),
+        }
+    }
+
+    /// See [`Ipv6Addr::is_unicast_link_local`].
+    pub extern "Lua-C" fn is_v6_unicast_link_local(&self) -> bool {
+        match self.0 {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => v6.is_unicast_link_local(),
+        }
+    }
+
+    /// See [`Ipv4Addr::to_ipv6_compatible`].
+    pub extern "Lua-C" fn to_v6_compat(&self) -> Self {
+        match self.0 {
+            IpAddr::V4(v4) => Self(v4.to_ipv6_compatible().into()),
+            IpAddr::V6(_) => *self,
+        }
+    }
+
+    /// See [`Ipv4Addr::to_ipv6_mapped`].
+    pub extern "Lua-C" fn to_v6_mapped(&self) -> Self {
+        match self.0 {
+            IpAddr::V4(v4) => Self(v4.to_ipv6_mapped().into()),
+            IpAddr::V6(_) => *self,
+        }
+    }
+
+    /// See [`IpAddr::to_canonical`].
+    pub extern "Lua-C" fn canonical(&self) -> Self {
+        self.0.to_canonical().into()
+    }
+
+    /// Returns the string representation of this address.
+    #[tostring]
+    pub extern "Lua-C" fn tostring(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+/// A socket address, which is an IP address with a port number.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, From, FromStr)]
+#[cdef]
+pub struct lb_socketaddr(#[opaque] SocketAddr);
+
+#[metatype]
+impl lb_socketaddr {
+    /// Returns the IP part of this address.
+    pub extern "Lua-C" fn ip(&self) -> lb_ipaddr {
+        self.0.ip().into()
+    }
+
+    /// Sets the IP part of this address.
+    ///
+    /// This function accepts the same arguments as [`ipaddr`](lb_libnet::ipaddr).
+    pub extern "Lua" fn set_ip(&mut self, s: any) -> &mut Self {
+        if __istype(__ct.lb_ipaddr, s) {
+            self.__set_ip(s);
+        } else if __istype(__ct.lb_socketaddr, s) {
+            self.__set_ip(s.ip());
+        } else {
+            self.__set_ip_parse(s);
+        }
+        self
+    }
+
+    extern "Lua-C" fn __set_ip(&mut self, ip: &lb_ipaddr) {
+        self.0.set_ip(ip.0);
+    }
+
+    extern "Lua-C" fn __set_ip_parse(&mut self, s: &str) -> Result<(), AddrParseError> {
+        s.parse().map(|ip| self.0.set_ip(ip))
+    }
+
+    /// Returns the port part of this address.
+    pub extern "Lua-C" fn port(&self) -> u16 {
+        self.0.port()
+    }
+
+    /// Sets the port part of this address.
+    pub extern "Lua" fn set_port(&mut self, port: number) -> &mut Self {
+        self.__set_port(port);
+        self
+    }
+
+    extern "Lua-C" fn __set_port(&mut self, port: u16) {
+        self.0.set_port(port)
+    }
+
+    /// Returns the string representation of this address.
+    #[tostring]
+    pub extern "Lua-C" fn tostring(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+/// A TCP socket which has not yet been converted to a [`lb_tcpstream`] or [`lb_tcplistener`].
+#[derive(Debug, From)]
+#[cdef]
+pub struct lb_tcpsocket(#[opaque] TcpSocket);
+
+#[metatype]
+impl lb_tcpsocket {}
+
+#[derive(Debug, From)]
+#[cdef]
+pub struct lb_tcpstream(#[opaque] TcpStream);
+
+#[metatype]
+impl lb_tcpstream {}
+
+#[derive(Debug, From)]
+#[cdef]
+pub struct lb_tcplistener(#[opaque] TcpListener);
+
+#[metatype]
+impl lb_tcplistener {}

crates/lb/src/runtime.lua

@@ -0,0 +1,5 @@
+local task = require("lb:task")
+
+function spawn(f, ...)
+  return task:spawn(f, ...)
+end

crates/lb/src/runtime.rs

@@ -0,0 +1,85 @@
+use crate::{channel::lb_libchannel, fs::lb_libfs, net::lb_libnet, task::lb_libtask};
+use derive_more::{Deref, DerefMut};
+use luaffi::{Registry, Type};
+use luajit::{Chunk, State};
+use std::fmt::Display;
+use tokio::{
+    task::{JoinHandle, LocalSet, futures::TaskLocalFuture, spawn_local},
+    task_local,
+};
+
+#[derive(Debug, Default)]
+pub struct Builder {
+    registry: Registry,
+}
+
+impl Builder {
+    pub fn new() -> Self {
+        let mut registry = Registry::new();
+
+        registry
+            .preload::<lb_libtask>("lb:task")
+            .preload::<lb_libchannel>("lb:channel")
+            .preload::<lb_libfs>("lb:fs")
+            .preload::<lb_libnet>("lb:net");
+
+        Self { registry }
+    }
+
+    pub fn module<T: Type>(&mut self, name: impl Display) -> &mut Self {
+        self.registry.preload::<T>(name);
+        self
+    }
+
+    pub fn registry(&self) -> &Registry {
+        &self.registry
+    }
+
+    pub fn build(&self) -> luajit::Result<Runtime> {
+        Ok(Runtime {
+            state: {
+                let mut s = State::new()?;
+                let mut chunk = Chunk::new(self.registry.done());
+                chunk.extend(include_bytes!("./runtime.lua"));
+                s.eval(chunk.path("[luby]"), 0, 0)?;
+                s
+            },
+            tasks: LocalSet::new(),
+        })
+    }
+}
+
+#[derive(Debug, Deref, DerefMut)]
+pub struct Runtime {
+    #[deref]
+    #[deref_mut]
+    state: State,
+    tasks: LocalSet,
+}
+
+task_local! {
+    static STATE: State;
+}
+
+impl Runtime {
+    pub fn spawn<T: 'static>(
+        &self,
+        f: impl AsyncFnOnce(&mut State) -> T + 'static,
+    ) -> JoinHandle<T> {
+        self.tasks
+            .spawn_local(async move { f(&mut STATE.with(|s| s.new_thread())).await })
+    }
+}
+
+pub fn spawn<T: 'static>(f: impl AsyncFnOnce(&mut State) -> T + 'static) -> JoinHandle<T> {
+    spawn_local(async move { f(&mut STATE.with(|s| s.new_thread())).await })
+}
+
+impl IntoFuture for Runtime {
+    type Output = ();
+    type IntoFuture = TaskLocalFuture<State, LocalSet>;
+
+    fn into_future(self) -> Self::IntoFuture {
+        STATE.scope(self.state, self.tasks)
+    }
+}

crates/lb/src/task.rs

@@ -0,0 +1,46 @@
+use crate::runtime::spawn;
+use luaffi::{cdef, metatype};
+use std::{ffi::c_int, process};
+use tokio::task::JoinHandle;
+
+#[cdef]
+pub struct lb_libtask;
+
+#[metatype]
+impl lb_libtask {
+    #[new]
+    extern "Lua-C" fn new() -> Self {
+        Self
+    }
+
+    pub extern "Lua" fn spawn(self, f: function, ...) {
+        // pack the function and its arguments into a table and pass its ref to rust
+        self.__spawn(__ref(__tpack(f, variadic!())))
+    }
+
+    extern "Lua-C" fn __spawn(&self, key: c_int) -> lb_task {
+        let handle = spawn(async move |s| {
+            // SAFETY: key is always unique, created by __ref above
+            let arg = unsafe { s.new_ref_unchecked(key) };
+            s.resize(0);
+            s.push(arg);
+            let narg = s.unpack(1, 1, None) - 1;
+            println!("{s:?}");
+            if let Err(_err) = s.call_async(narg, 0).await {
+                process::exit(1)
+            }
+            println!("{s:?}");
+        });
+
+        lb_task { handle }
+    }
+}
+
+#[cdef]
+pub struct lb_task {
+    #[opaque]
+    handle: JoinHandle<()>,
+}
+
+#[metatype]
+impl lb_task {}

crates/lb/tests/net.rs

@@ -0,0 +1,32 @@
+use lb::runtime;
+use luaify::luaify;
+use luajit::{Chunk, LoadMode};
+use tokio::test;
+
+async fn run_lua(s: &'static str) {
+    let rt = runtime::Builder::new().build().unwrap();
+    let task = rt.spawn(async move |state| {
+        println!("executing test chunk: {s}");
+
+        state
+            .load(Chunk::new(s).mode(LoadMode::TEXT))
+            .unwrap_or_else(|err| panic!("{err}"));
+
+        state
+            .call_async(0, 0)
+            .await
+            .unwrap_or_else(|err| panic!("{err}"));
+    });
+
+    rt.await;
+    task.await.unwrap_or_else(|err| panic!("{err}"));
+}
+
+#[test]
+async fn ipaddr() {
+    run_lua(luaify!({
+        let net = require("lb:net");
+        print(net.ipaddr("127.0.0.1"));
+    }))
+    .await
+}

crates/lb/tests/task.rs

@@ -0,0 +1,35 @@
+use lb::runtime;
+use luaify::luaify;
+use luajit::{Chunk, LoadMode};
+use tokio::test;
+
+async fn run_lua(s: &'static str) {
+    let rt = runtime::Builder::new().build().unwrap();
+    let task = rt.spawn(async move |state| {
+        println!("executing test chunk: {s}");
+
+        state
+            .load(Chunk::new(s).mode(LoadMode::TEXT))
+            .unwrap_or_else(|err| panic!("{err}"));
+
+        state
+            .call_async(0, 0)
+            .await
+            .unwrap_or_else(|err| panic!("{err}"));
+    });
+
+    rt.await;
+    task.await.unwrap_or_else(|err| panic!("{err}"));
+}
+
+#[test]
+async fn task_test() {
+    run_lua(luaify!({
+        let thing = spawn(|| {
+            print("spawn callback!!!!!!!!!!!!!");
+        });
+        print("thing is", thing);
+        //
+    }))
+    .await
+}

crates/luaffi/src/future.rs

@@ -1,7 +1,7 @@
 use crate::{
     __internal::{display, type_id},
-    Cdef, CdefBuilder, FfiReturnConvention, Metatype, MetatypeBuilder, ToFfi, Type, TypeBuilder,
-    UnsafeExternCFn,
+    Cdef, CdefBuilder, FfiReturnConvention, IntoFfi, Metatype, MetatypeBuilder, Type, TypeBuilder,
+    TypeType, UnsafeExternCFn,
 };
 use luaify::luaify;
 use std::{
@@ -21,7 +21,7 @@ const SIGNATURE: Signature = Signature::from_ne_bytes(*b"\x00lb_poll");
 
 #[repr(C)]
 #[allow(non_camel_case_types)]
-pub struct lua_future<F: Future<Output: ToFfi>> {
+pub struct lua_future<F: Future<Output: IntoFfi>> {
     //
     // SAFETY: LuaJIT guarantees that cdata payloads, which are GC-managed, are never relocated
     // (i.e. pinned). We can safely assume that we are pinned and poll the future inside this
@@ -43,7 +43,7 @@ pub struct lua_future<F: Future<Output: ToFfi>> {
     sig: Signature,
     poll: fn(Pin<&mut Self>, cx: &mut Context) -> Poll<()>,
     state: State<F>,
-    take: unsafe extern "C" fn(&mut Self) -> <F::Output as ToFfi>::To,
+    take: unsafe extern "C" fn(&mut Self) -> <F::Output as IntoFfi>::Into,
     drop: unsafe extern "C" fn(&mut Self),
 }
 
@@ -70,7 +70,7 @@ enum State<F: Future> {
     Complete,
 }
 
-impl<F: Future<Output: ToFfi>> lua_future<F> {
+impl<F: Future<Output: IntoFfi>> lua_future<F> {
     pub fn new(fut: F) -> Self {
         Self {
             sig: SIGNATURE,
@@ -94,7 +94,7 @@ impl<F: Future<Output: ToFfi>> lua_future<F> {
         }
     }
 
-    unsafe extern "C" fn take(&mut self) -> <F::Output as ToFfi>::To {
+    unsafe extern "C" fn take(&mut self) -> <F::Output as IntoFfi>::Into {
         // `fut:__take()` returns the fulfilled value by-value (not by out-param) because if we
         // preallocate a cdata for the out-param and the thread for some reason gets dropped and
         // never resumed, the GC could call the destructor on an uninitialised cdata.
@@ -131,13 +131,17 @@ impl Future for lua_pollable {
     }
 }
 
-unsafe impl<F: Future<Output: ToFfi> + 'static> Type for lua_future<F> {
+unsafe impl<F: Future<Output: IntoFfi> + 'static> Type for lua_future<F> {
     fn name() -> impl Display {
         display!("future__{:x}", type_id::<F>())
     }
 
+    fn ty() -> TypeType {
+        TypeType::Aggregate
+    }
+
     fn cdecl(name: impl Display) -> impl Display {
-        display!("struct future__{:x} {name}", type_id::<F>())
+        display!("struct {} {name}", Self::name())
     }
 
     fn build(s: &mut TypeBuilder) {
@@ -145,15 +149,15 @@ unsafe impl<F: Future<Output: ToFfi> + 'static> Type for lua_future<F> {
     }
 }
 
-unsafe impl<F: Future<Output: ToFfi> + 'static> Cdef for lua_future<F> {
+unsafe impl<F: Future<Output: IntoFfi> + 'static> Cdef for lua_future<F> {
     fn build(s: &mut CdefBuilder) {
         s.field_opaque(mem::offset_of!(Self, take)) // opaque .sig, .poll and .state
-            .field::<UnsafeExternCFn<(&mut Self,), <F::Output as ToFfi>::To>>("__take")
+            .field::<UnsafeExternCFn<(&mut Self,), <F::Output as IntoFfi>::Into>>("__take")
             .field::<UnsafeExternCFn<(&mut Self,), ()>>("__drop");
     }
 }
 
-unsafe impl<F: Future<Output: ToFfi> + 'static> Metatype for lua_future<F> {
+unsafe impl<F: Future<Output: IntoFfi> + 'static> Metatype for lua_future<F> {
     type Target = Self;
 
     fn build(s: &mut MetatypeBuilder) {
@@ -161,30 +165,36 @@ unsafe impl<F: Future<Output: ToFfi> + 'static> Metatype for lua_future<F> {
     }
 }
 
-unsafe impl<F: Future<Output: ToFfi> + 'static> ToFfi for lua_future<F> {
-    type To = lua_future<F>;
+unsafe impl<F: Future<Output: IntoFfi> + 'static> IntoFfi for lua_future<F> {
+    type Into = lua_future<F>;
 
-    fn convert(self) -> Self::To {
+    fn convention() -> FfiReturnConvention {
+        // futures are always returned by-value due to rust type inference limitations
+        FfiReturnConvention::ByValue
+    }
+
+    fn convert(self) -> Self::Into {
         self
     }
 
-    fn postlude(ret: &str, _conv: FfiReturnConvention) -> impl Display {
+    fn postlude(ret: &str) -> impl Display {
         // When returning a future from Rust to Lua, yield it immediately to the runtime which will
         // poll it to completion in the background, then take the fulfilled value once the thread
         // gets resumed. Lua user code should never to worry about awaiting futures.
         //
         // Once the current thread gets resumed and we take the future's fulfilled value, we clear
-        // the finaliser on the future and forget it (there is nothing to call drop on).
+        // the finaliser on the future and forget it (there is nothing to drop once the value is
+        // taken).
         //
-        // `coroutine.yield` is cached as `yield` and `ffi.gc` as `gc` in locals (see lib.rs)
+        // `coroutine.yield` is cached as `__yield` and `ffi.gc` as `__gc` in locals (see lib.rs)
         display!(
-            "yield({ret}); {ret} = gc({ret}, nil):__take(); {}",
-            <F::Output as ToFfi>::postlude(ret, FfiReturnConvention::ByValue)
+            "__yield({ret}); {ret} = __gc({ret}, nil):__take(); {}",
+            <F::Output as IntoFfi>::postlude(ret)
         )
     }
 }
 
-impl<F: IntoFuture<Output: ToFfi>> From<F> for lua_future<F::IntoFuture> {
+impl<F: IntoFuture<Output: IntoFfi>> From<F> for lua_future<F::IntoFuture> {
     fn from(value: F) -> Self {
         Self::new(value.into_future())
     }

crates/luaffi/src/internal.rs

@@ -6,6 +6,23 @@ use std::{
     hash::{Hash, Hasher},
 };
 
+#[allow(non_camel_case_types)]
+pub mod stub_types {
+    pub struct any;
+    pub struct nil;
+    pub struct boolean;
+    pub struct lightuserdata;
+    pub struct number;
+    pub struct integer;
+    pub struct string;
+    pub struct table;
+    pub struct function;
+    pub struct userdata;
+    pub struct thread;
+    pub struct cdata;
+    pub struct variadic;
+}
+
 pub fn type_id<T: 'static>() -> u64 {
     let mut hash = FxHasher::default();
     TypeId::of::<T>().hash(&mut hash);

crates/luaffi/src/lib.rs

@@ -1,38 +1,34 @@
-use crate::__internal::{disp, display, export, write_sep};
+use crate::{
+    __internal::{disp, display, export, write_sep},
+    string::{DROP_BUFFER_FN, IS_UTF8_FN, lua_buffer},
+};
 pub use luaffi_impl::*;
 use std::{
     collections::HashSet,
     ffi::{c_double, c_float, c_void},
     fmt::{self, Display, Formatter, Write},
     marker::PhantomData,
-    mem, slice,
+    mem,
 };
 
 pub mod future;
-// pub mod option;
 pub mod string;
 
 #[doc(hidden)]
 #[path = "./internal.rs"]
 pub mod __internal;
-
-const KEEP_FN: &str = "luaffi_keep";
-const IS_UTF8_FN: &str = "luaffi_is_utf8";
+pub mod result;
 
 // Dummy function to ensure that strings passed to Rust via wrapper objects will not be
-// garbage-collected until the end of the function. This shall exist until LuaJIT one day implements
-// something like `ffi.keep(obj)`.
+// garbage-collected until the end of the function (used in string.rs when string marshalling is
+// going through the slow-path). This shall exist until LuaJIT one day implements something like
+// `ffi.keep(obj)`.
 //
 // https://github.com/LuaJIT/LuaJIT/issues/1167
+pub(crate) const KEEP_FN: &str = "luaffi_keep";
 #[unsafe(export_name = "luaffi_keep")]
 extern "C" fn __keep(_ptr: *const c_void) {}
-
-#[unsafe(export_name = "luaffi_is_utf8")]
-unsafe extern "C" fn __is_utf8(ptr: *const u8, len: usize) -> bool {
-    simdutf8::basic::from_utf8(unsafe { slice::from_raw_parts(ptr, len) }).is_ok()
-}
-
-export![__keep, __is_utf8];
+export![__keep];
 
 const CACHE_LIBS: &[(&str, &str)] = &[
     ("table", "table"),
@@ -82,20 +78,20 @@ const CACHE_LOCALS: &[(&str, &str)] = &[
     ("__tunpack", "table.unpack"),
     // string
     ("__slen", "string.len"),
-    ("__sformat", "string.format"),
+    ("__sprintf", "string.format"),
     ("__ssub", "string.sub"),
     ("__sgsub", "string.gsub"),
     ("__sgmatch", "string.gmatch"),
     ("__sdump", "string.dump"),
-    // math
+    // math (used in luaify! macro)
     ("__fmod", "math.fmod"),
-    // coroutine
+    // coroutine (used in future.rs)
     ("__yield", "coroutine.yield"),
     // package
     ("__preload", "package.preload"),
     // debug
     ("__traceback", "debug.traceback"),
-    ("__registry", "debug.getregistry()"),
+    ("__registry", "debug.getregistry()"), // (used in lib.lua)
     // ffi
     ("__C", "ffi.C"),
     ("__ct", "{}"),
@@ -108,8 +104,8 @@ const CACHE_LOCALS: &[(&str, &str)] = &[
     ("__gc", "ffi.gc"),
     ("__sizeof", "ffi.sizeof"),
     ("__alignof", "ffi.alignof"),
-    ("__intern", "ffi.string"),
-    // bit
+    ("__intern", "ffi.string"), // (used in string.rs)
+    // bit (used in luaify! macro)
     ("__bnot", "bit.bnot"),
     ("__band", "bit.band"),
     ("__bor", "bit.bor"),
@@ -143,6 +139,7 @@ impl Registry {
         let mut s = Self::default();
         s.declare::<UnsafeExternCFn<(*const c_void,), ()>>(KEEP_FN);
         s.declare::<UnsafeExternCFn<(*const u8, usize), bool>>(IS_UTF8_FN);
+        s.declare::<UnsafeExternCFn<(*mut lua_buffer,), ()>>(DROP_BUFFER_FN);
         s
     }
 
@@ -154,6 +151,7 @@ impl Registry {
     }
 
     pub fn declare<T: Type>(&mut self, name: impl Display) -> &mut Self {
+        assert!(T::ty() != TypeType::Void, "cannot declare void type");
         self.include::<T>()
             .funcs
             .insert(name.to_string())
@@ -162,11 +160,12 @@ impl Registry {
     }
 
     pub fn preload<T: Type>(&mut self, name: impl Display) -> &mut Self {
+        assert!(T::ty() != TypeType::Void, "cannot declare void type");
         self.include::<T>();
+        let ct = T::name();
         writeln!(
             self.lua,
-            r#"__preload["{name}"] = function(...) return __ct.{}(...); end;"#,
-            T::name()
+            r#"__preload["{name}"] = function(...) return __ct.{ct}(...); end;"#,
         )
         .unwrap();
         self
@@ -192,6 +191,8 @@ impl Display for Registry {
 
 pub unsafe trait Type {
     fn name() -> impl Display;
+    fn ty() -> TypeType;
+
     fn cdecl(name: impl Display) -> impl Display;
     fn extern_cdecl(name: impl Display) -> impl Display {
         Self::cdecl(name)
@@ -200,6 +201,13 @@ pub unsafe trait Type {
     fn build(b: &mut TypeBuilder);
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum TypeType {
+    Void,
+    Primitive,
+    Aggregate,
+}
+
 #[derive(Debug)]
 pub struct TypeBuilder<'r> {
     registry: &'r mut Registry,
@@ -256,6 +264,7 @@ impl<'r> CdefBuilder<'r> {
     }
 
     pub fn field<T: Type>(&mut self, name: impl Display) -> &mut Self {
+        assert!(T::ty() != TypeType::Void, "cannot declare void field");
         self.registry.include::<T>();
         self.field_raw(T::cdecl(name))
     }
@@ -309,7 +318,7 @@ pub unsafe trait Metatype {
 #[derive(Debug)]
 pub struct MetatypeBuilder<'r> {
     registry: &'r mut Registry,
-    name: String,
+    ct: String,
     cdef: String,
     lua: String,
 }
@@ -318,7 +327,7 @@ impl<'r> MetatypeBuilder<'r> {
     fn new<T: Metatype>(registry: &'r mut Registry) -> Self {
         Self {
             registry,
-            name: T::Target::name().to_string(),
+            ct: T::Target::name().to_string(),
             cdef: String::new(),
             lua: r#"do local __mt, __idx = {}, {}; __mt.__index = __idx; "#.into(),
         }
@@ -366,7 +375,7 @@ impl<'r> Drop for MetatypeBuilder<'r> {
     fn drop(&mut self) {
         let Self {
             registry,
-            name,
+            ct,
             cdef,
             lua,
             ..
@@ -374,13 +383,18 @@ impl<'r> Drop for MetatypeBuilder<'r> {
 
         registry.cdef.push_str(cdef);
         registry.lua.push_str(lua);
-        writeln!(registry.lua, r#"__metatype(__ct.{name}, __mt); end;"#).unwrap();
+        writeln!(registry.lua, r#"__metatype(__ct.{ct}, __mt); end;"#).unwrap();
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum FfiReturnConvention {
+    ByValue,
+    ByOutParam,
+}
+
 pub unsafe trait FromFfi: Sized {
     type From: Type + Sized;
-    type FromArg: Type + Sized;
 
     fn require_keepalive() -> bool {
         false
@@ -391,32 +405,31 @@ pub unsafe trait FromFfi: Sized {
     }
 
     fn convert(from: Self::From) -> Self;
-    fn convert_arg(from: Self::FromArg) -> Self;
 }
 
-pub unsafe trait ToFfi: Sized {
-    type To: Type + Sized;
+pub unsafe trait IntoFfi: Sized {
+    type Into: Type + Sized;
 
-    fn postlude(_ret: &str, _conv: FfiReturnConvention) -> impl Display {
+    fn convention() -> FfiReturnConvention {
+        match Self::Into::ty() {
+            TypeType::Void | TypeType::Primitive => FfiReturnConvention::ByValue,
+            TypeType::Aggregate => FfiReturnConvention::ByOutParam,
+        }
+    }
+
+    fn postlude(_ret: &str) -> impl Display {
         ""
     }
 
-    fn convert(self) -> Self::To;
-}
-
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum FfiReturnConvention {
-    Void,
-    #[default]
-    ByValue,
-    ByOutParam,
+    fn convert(self) -> Self::Into;
 }
 
 #[derive(Debug)]
 pub struct MetatypeMethodBuilder<'r, 'm> {
     metatype: &'m mut MetatypeBuilder<'r>,
-    params: String,   // parameters to the lua function
-    args: String,     // arguments to the C call
+    lparams: String,  // parameters to the lua function
+    cparams: String,  // parameters to the lua function
+    cargs: String,    // arguments to the C call
     prelude: String,  // function body prelude
     postlude: String, // function body postlude
 }
@@ -425,26 +438,46 @@ impl<'r, 'm> MetatypeMethodBuilder<'r, 'm> {
     pub fn new(metatype: &'m mut MetatypeBuilder<'r>) -> Self {
         Self {
             metatype,
-            params: String::new(),
-            args: String::new(),
+            lparams: String::new(),
+            cparams: String::new(),
+            cargs: String::new(),
             prelude: String::new(),
             postlude: String::new(),
         }
     }
 
     pub fn param<T: FromFfi>(&mut self, name: impl Display) -> &mut Self {
-        (!self.params.is_empty()).then(|| self.params.push_str(", "));
-        (!self.args.is_empty()).then(|| self.args.push_str(", "));
-        write!(self.params, "{name}").unwrap();
-        write!(self.args, "{name}").unwrap();
+        assert!(
+            T::From::ty() != TypeType::Void,
+            "cannot declare void parameter"
+        );
+
+        let Self {
+            metatype: MetatypeBuilder { registry, .. },
+            lparams,
+            cparams,
+            cargs,
+            prelude,
+            postlude,
+            ..
+        } = self;
+
+        registry.include::<T::From>();
+
+        (!lparams.is_empty()).then(|| lparams.push_str(", "));
+        (!cparams.is_empty()).then(|| cparams.push_str(", "));
+        (!cargs.is_empty()).then(|| cargs.push_str(", "));
+
+        write!(lparams, "{name}").unwrap();
+        write!(cparams, "{}", T::From::cdecl(&name)).unwrap();
+        write!(cargs, "{name}").unwrap();
 
         if T::require_keepalive() {
-            write!(self.prelude, "local __keep_{name} = {name}; ").unwrap();
-            write!(self.postlude, "__C.{KEEP_FN}(__keep_{name}); ").unwrap();
+            write!(prelude, "local __keep_{name} = {name}; ").unwrap();
+            write!(postlude, "__C.{KEEP_FN}(__keep_{name}); ").unwrap();
         }
 
-        let name = name.to_string();
-        write!(self.prelude, "{}", T::prelude(&name)).unwrap();
+        write!(prelude, "{}", T::prelude(&name.to_string())).unwrap();
         self
     }
 
@@ -454,13 +487,27 @@ impl<'r, 'm> MetatypeMethodBuilder<'r, 'm> {
         // this passes one lua `string` argument as two C `const uint8_t *ptr` and `uintptr_t len`
         // arguments, bypassing the slower generic `&[u8]: FromFfi` path which constructs a
         // temporary cdata to pass the string and its length in one argument
-        (!self.params.is_empty()).then(|| self.params.push_str(", "));
-        (!self.args.is_empty()).then(|| self.args.push_str(", "));
-        write!(self.params, "{name}").unwrap();
-        write!(self.args, "{name}, __{name}_len").unwrap();
-        write!(self.prelude, "local __{name}_len = 0; ").unwrap();
+        let Self {
+            lparams,
+            cparams,
+            cargs,
+            prelude,
+            ..
+        } = self;
+
+        let param_ptr = <*const u8>::cdecl("ptr");
+        let param_len = usize::cdecl("len");
+
+        (!lparams.is_empty()).then(|| lparams.push_str(", "));
+        (!cparams.is_empty()).then(|| cparams.push_str(", "));
+        (!cargs.is_empty()).then(|| cargs.push_str(", "));
+
+        write!(lparams, "{name}").unwrap();
+        write!(cparams, "{param_ptr}, {param_len}",).unwrap();
+        write!(cargs, "{name}, __{name}_len").unwrap();
+        write!(prelude, "local __{name}_len = 0; ").unwrap();
         write!(
-            self.prelude,
+            prelude,
             r#"if {name} ~= nil then assert(type({name}) == "string", "string expected in argument '{name}', got " .. type({name})); __{name}_len = #{name}; end; "#
         )
         .unwrap();
@@ -468,57 +515,110 @@ impl<'r, 'm> MetatypeMethodBuilder<'r, 'm> {
     }
 
     pub fn param_ignored(&mut self) -> &mut Self {
-        (!self.params.is_empty()).then(|| self.params.push_str(", "));
-        write!(self.params, "_").unwrap();
+        (!self.lparams.is_empty()).then(|| self.lparams.push_str(", "));
+        write!(self.lparams, "_").unwrap();
         self
     }
 
-    pub fn call<T: ToFfi>(&mut self, func: impl Display, ret: FfiReturnConvention) {
+    pub fn call<T: IntoFfi>(&mut self, func: impl Display) {
         let Self {
-            metatype,
-            params,
-            args,
+            metatype:
+                MetatypeBuilder {
+                    registry,
+                    cdef,
+                    lua,
+                    ..
+                },
+            lparams,
+            cparams,
+            cargs,
             prelude,
             postlude,
+            ..
         } = self;
 
-        let lua = &mut metatype.lua;
-        write!(lua, "function({params}) {prelude}").unwrap();
+        registry.include::<T::Into>();
+        write!(lua, "function({lparams}) {prelude}").unwrap();
 
-        match ret {
-            FfiReturnConvention::Void => {
-                write!(lua, "__C.{func}({args}); {postlude}end").unwrap();
-            }
+        match T::convention() {
             FfiReturnConvention::ByValue => {
-                let check = T::postlude("__res", ret);
-                write!(
-                    lua,
-                    "local __res = __C.{func}({args}); {check}{postlude}return __res; end"
-                )
-                .unwrap();
+                if T::Into::ty() == TypeType::Void {
+                    write!(lua, "__C.{func}({cargs}); {postlude}end").unwrap();
+                } else {
+                    let check = T::postlude("__res");
+                    write!(lua, "local __res = __C.{func}({cargs}); ").unwrap();
+                    write!(lua, "{check}{postlude}return __res; end").unwrap();
+                }
+
+                writeln!(cdef, "{};", T::Into::cdecl(display!("{func}({cparams})"))).unwrap();
             }
             FfiReturnConvention::ByOutParam => {
-                let ct = T::To::name();
-                let check = T::postlude("__res", ret);
+                let ct = T::Into::name();
+                let check = T::postlude("__res");
                 write!(lua, "local __res = __new(__ct.{ct}); __C.{func}(__res").unwrap();
-                if !args.is_empty() {
-                    write!(lua, ", {args}").unwrap();
+                if !cargs.is_empty() {
+                    write!(lua, ", {cargs}").unwrap();
                 }
-                write!(lua, "); {check}{postlude}return __res; end").unwrap()
+                write!(lua, "); {check}{postlude}return __res; end").unwrap();
+                write!(cdef, "void {func}({}", <*mut T::Into>::cdecl("out")).unwrap();
+                if !cparams.is_empty() {
+                    write!(cdef, ", {cparams}").unwrap();
                 }
+                writeln!(cdef, ");").unwrap();
             }
         }
     }
 
-macro_rules! impl_primitive {
-    ($rtype:ty, $ctype:expr) => {
-        unsafe impl Type for $rtype {
+    pub fn call_inferred<T: IntoFfi>(&mut self, func: impl Display, _infer: impl FnOnce() -> T) {
+        self.call::<T>(func)
+    }
+}
+
+//
+// SAFETY: Unit type return maps to a C void return, which is a nil return in lua. There is no
+// equivalent to passing a unit type as an argument in C.
+//
+macro_rules! impl_void {
+    ($rty:ty) => {
+        unsafe impl Type for $rty {
             fn name() -> impl Display {
-                $ctype
+                "void"
+            }
+
+            fn ty() -> TypeType {
+                TypeType::Void
             }
 
             fn cdecl(name: impl Display) -> impl Display {
-                display!("{} {name}", $ctype)
+                display!("void {name}")
+            }
+
+            fn build(_b: &mut TypeBuilder) {}
+        }
+
+        unsafe impl IntoFfi for $rty {
+            type Into = ();
+            fn convert(self) -> Self::Into {}
+        }
+    };
+}
+
+impl_void!(());
+impl_void!(c_void);
+
+macro_rules! impl_primitive {
+    ($rty:ty, $cty:expr) => {
+        unsafe impl Type for $rty {
+            fn name() -> impl Display {
+                $cty
+            }
+
+            fn ty() -> TypeType {
+                TypeType::Primitive
+            }
+
+            fn cdecl(name: impl Display) -> impl Display {
+                display!("{} {name}", $cty)
             }
 
             fn build(_b: &mut TypeBuilder) {}
@@ -526,87 +626,122 @@ macro_rules! impl_primitive {
     };
 }
 
-impl_primitive!((), "void");
-impl_primitive!(c_void, "void");
+impl_primitive!(bool, "bool");
+impl_primitive!(u8, "uint8_t");
+impl_primitive!(u16, "uint16_t");
+impl_primitive!(u32, "uint32_t");
+impl_primitive!(u64, "uint64_t");
+impl_primitive!(usize, "uintptr_t");
+impl_primitive!(i8, "int8_t");
+impl_primitive!(i16, "int16_t");
+impl_primitive!(i32, "int32_t");
+impl_primitive!(i64, "int64_t");
+impl_primitive!(isize, "intptr_t");
+impl_primitive!(c_float, "float");
+impl_primitive!(c_double, "double");
 
-unsafe impl ToFfi for () {
-    //
-    // SAFETY: Unit type return maps to a C void return, which is a nil return in lua. There is no
-    // equivalent to passing a unit type as an argument in C. `c_void` cannot be returned from rust
-    // so it should return the unit type instead.
-    //
-    type To = ();
-    fn convert(self) -> Self::To {}
-
-    fn postlude(_ret: &str, conv: FfiReturnConvention) -> impl Display {
-        assert!(
-            conv == FfiReturnConvention::Void,
-            "void type cannot be instantiated"
-        );
-        ""
-    }
-}
-
-macro_rules! impl_primitive_abi {
-    ($rtype:ty, $ctype:expr, $ltype:expr $(, $unwrap:expr)?) => {
-        impl_primitive!($rtype, $ctype);
-
-        //
-        // SAFETY: Primitive types are always copyable so we can pass and return them by value.
-        //
-        unsafe impl FromFfi for $rtype {
-            type From = Self;
-            type FromArg = Self;
+unsafe impl FromFfi for bool {
+    type From = bool;
 
     fn prelude(arg: &str) -> impl Display {
-                display!(r#"assert(type({arg}) == "{0}", "{0} expected in argument '{arg}', got " .. type({arg})); "#, $ltype)
+        display!(
+            r#"assert(type({arg}) == "boolean", "boolean expected in argument '{arg}', got " .. type({arg})); "#
+        )
     }
 
     fn convert(from: Self::From) -> Self {
         from
     }
-
-            fn convert_arg(from: Self::FromArg) -> Self {
-                from
-            }
 }
 
-        unsafe impl ToFfi for $rtype {
-            type To = Self;
+unsafe impl IntoFfi for bool {
+    type Into = bool;
 
-            fn convert(self) -> Self::To {
+    fn convert(self) -> Self::Into {
         self
     }
-
-            #[allow(unused)]
-            fn postlude(ret: &str, conv: FfiReturnConvention) -> impl Display {
-                disp(move |f| Ok({
-                    match conv {
-                        FfiReturnConvention::Void => unreachable!(),
-                        FfiReturnConvention::ByValue => {},
-                        // if a primitive type for some reason gets returned by out-param, unwrap
-                        // the cdata containing the value to convert it to the equivalent lua value
-                        FfiReturnConvention::ByOutParam => { $(write!(f, "{ret} = {}; ", $unwrap(ret))?;)? },
 }
-                }))
+
+macro_rules! impl_number_fromabi {
+    ($rty:ty) => {
+        unsafe impl FromFfi for $rty {
+            type From = Self;
+
+            fn prelude(arg: &str) -> impl Display {
+                display!(r#"do local __{arg} = {arg}; {arg} = tonumber({arg}); assert(type({arg}) == "number", "number expected in argument '{arg}', got " .. type(__{arg})); end; "#)
+            }
+
+            fn convert(from: Self::From) -> Self {
+                from
             }
         }
     };
 }
 
-impl_primitive_abi!(bool, "bool", "boolean", |n| display!("{n} ~= 0"));
-impl_primitive_abi!(u8, "uint8_t", "number", |n| display!("tonumber({n})"));
-impl_primitive_abi!(u16, "uint16_t", "number", |n| display!("tonumber({n})"));
-impl_primitive_abi!(u32, "uint32_t", "number", |n| display!("tonumber({n})"));
-impl_primitive_abi!(u64, "uint64_t", "number");
-impl_primitive_abi!(usize, "uintptr_t", "number");
-impl_primitive_abi!(i8, "int8_t", "number", |n| display!("tonumber({n})"));
-impl_primitive_abi!(i16, "int16_t", "number", |n| display!("tonumber({n})"));
-impl_primitive_abi!(i32, "int32_t", "number", |n| display!("tonumber({n})"));
-impl_primitive_abi!(i64, "int64_t", "number");
-impl_primitive_abi!(isize, "intptr_t", "number");
-impl_primitive_abi!(c_float, "float", "number", |n| display!("tonumber({n})"));
-impl_primitive_abi!(c_double, "double", "number", |n| display!("tonumber({n})"));
+impl_number_fromabi!(u8);
+impl_number_fromabi!(u16);
+impl_number_fromabi!(u32);
+impl_number_fromabi!(u64);
+impl_number_fromabi!(usize);
+impl_number_fromabi!(i8);
+impl_number_fromabi!(i16);
+impl_number_fromabi!(i32);
+impl_number_fromabi!(i64);
+impl_number_fromabi!(isize);
+impl_number_fromabi!(f32);
+impl_number_fromabi!(f64);
+
+macro_rules! impl_number_intoabi {
+    ($rty:ty) => {
+        unsafe impl IntoFfi for $rty {
+            type Into = Self;
+
+            fn convert(self) -> Self::Into {
+                self
+            }
+        }
+    };
+}
+
+impl_number_intoabi!(u8);
+impl_number_intoabi!(u16);
+impl_number_intoabi!(u32);
+impl_number_intoabi!(i8);
+impl_number_intoabi!(i16);
+impl_number_intoabi!(i32);
+#[cfg(target_pointer_width = "32")]
+impl_number_intoabi!(usize);
+#[cfg(target_pointer_width = "32")]
+impl_number_intoabi!(isize);
+impl_number_intoabi!(c_float);
+impl_number_intoabi!(c_double);
+
+macro_rules! impl_bigint_intoabi {
+    ($rty:ty) => {
+        unsafe impl IntoFfi for $rty {
+            type Into = Self;
+
+            fn convert(self) -> Self::Into {
+                self
+            }
+
+            fn postlude(ret: &str) -> impl Display {
+                // this isn't "correct" per se, but it's much more ergonomic to work with numbers in
+                // lua than with long longs wrapped in cdata. we gracefully accept the loss of
+                // precision here and that 53 bits of precision for big integers are enough. (the
+                // vain of Lua 5.3 integer subtype ;D )
+                display!("{ret} = tonumber({ret}); ")
+            }
+        }
+    };
+}
+
+impl_bigint_intoabi!(u64);
+impl_bigint_intoabi!(i64);
+#[cfg(target_pointer_width = "64")]
+impl_bigint_intoabi!(usize);
+#[cfg(target_pointer_width = "64")]
+impl_bigint_intoabi!(isize);
 
 macro_rules! impl_const_ptr {
     ($ty:ty) => {
@@ -615,6 +750,10 @@ macro_rules! impl_const_ptr {
                 display!("const_{}_ptr", T::name())
             }
 
+            fn ty() -> TypeType {
+                TypeType::Primitive
+            }
+
             fn cdecl(name: impl Display) -> impl Display {
                 T::cdecl(display!("const *{name}"))
             }
@@ -637,6 +776,10 @@ macro_rules! impl_mut_ptr {
                 display!("{}_ptr", T::name())
             }
 
+            fn ty() -> TypeType {
+                TypeType::Primitive
+            }
+
             fn cdecl(name: impl Display) -> impl Display {
                 T::cdecl(display!("*{name}"))
             }
@@ -665,15 +808,10 @@ macro_rules! impl_ptr_fromabi {
     ($ty:ty) => {
         unsafe impl<T: Type> FromFfi for $ty {
             type From = Self;
-            type FromArg = Self;
 
             fn convert(from: Self::From) -> Self {
                 from
             }
-
-            fn convert_arg(from: Self::FromArg) -> Self {
-                from
-            }
         }
     };
 }
@@ -683,99 +821,97 @@ impl_ptr_fromabi!(*mut T);
 impl_ptr_fromabi!(Option<&T>);
 impl_ptr_fromabi!(Option<&mut T>);
 
-unsafe impl<'s, T: Type> FromFfi for &'s T {
-    type From = Option<&'s T>;
-    type FromArg = Option<&'s T>;
-
-    fn prelude(arg: &str) -> impl Display {
-        display!(r#"assert({arg} ~= nil, "argument '{arg}' cannot be nil"); "#)
-    }
-
-    fn convert(from: Self::From) -> Self {
-        debug_assert!(
-            from.is_some(),
-            "<&T>::convert() called on a null reference when it was checked to be non-null"
-        );
-
-        unsafe { from.unwrap_unchecked() }
-    }
-
-    fn convert_arg(from: Self::FromArg) -> Self {
-        FromFfi::convert(from)
-    }
-}
-
-unsafe impl<'s, T: Type> FromFfi for &'s mut T {
-    //
-    // SAFETY: `FromFfi` for *mutable* references is safe because it is guaranteed that no two Rust
-    // code called via FFI can be running at the same time on the same OS thread (no Lua
-    // reentrancy).
-    //
-    // i.e. The call stack will always look something like this:
-    //
-    // * Runtime (LuaJIT/Rust) -> Lua (via C) -> Rust (via FFI): This is SAFE and the only use case
-    //     we support. All references (mutable or not) to Rust user objects will be dropped before
-    //     returning to Lua.
-    //
-    // * Runtime (LuaJIT/Rust) -> Lua (via C) -> Rust (via FFI) -> Lua (via callback): This is
-    //     UNSAFE because we cannot prevent the Lua callback from calling back into Rust code via
-    //     FFI which could violate exclusive borrow semantics. This is prevented by not implementing
-    //     `FromFfi` for function pointers (see below).
-    //
-    // The runtime does not keep any references to Rust user objects boxed in cdata (futures are
-    // the only exception; their ownership is transferred to the runtime via yield).
-    //
-    type From = Option<&'s mut T>;
-    type FromArg = Option<&'s mut T>;
-
-    fn prelude(arg: &str) -> impl Display {
-        display!(r#"assert({arg} ~= nil, "argument '{arg}' cannot be nil"); "#)
-    }
-
-    fn convert(from: Self::From) -> Self {
-        debug_assert!(
-            from.is_some(),
-            "<&mut T>::convert() called on a null reference when it was checked to be non-null"
-        );
-
-        unsafe { from.unwrap_unchecked() }
-    }
-
-    fn convert_arg(from: Self::FromArg) -> Self {
-        FromFfi::convert(from)
-    }
-}
-
 //
 // SAFETY: Return by value for pointers, which maps to a `cdata` return in lua containing the
 // pointer (`T *`). We also map null pointers to `nil` for convenience (otherwise it's still a cdata
 // value containing a null pointer)
 //
-macro_rules! impl_ptr_toabi {
+macro_rules! impl_ptr_intoabi {
     ($ty:ty) => {
-        unsafe impl<T: Type> ToFfi for $ty {
-            type To = Self;
+        unsafe impl<T: Type> IntoFfi for $ty {
+            type Into = Self;
 
-            fn convert(self) -> Self::To {
+            fn convert(self) -> Self::Into {
                 self
             }
 
-            fn postlude(ret: &str, _conv: FfiReturnConvention) -> impl Display {
+            fn postlude(ret: &str) -> impl Display {
                 display!("if {ret} == nil then {ret} = nil; end; ")
             }
         }
     };
 }
 
-impl_ptr_toabi!(*const T);
-impl_ptr_toabi!(*mut T);
-impl_ptr_toabi!(&'static T);
-impl_ptr_toabi!(&'static mut T);
-impl_ptr_toabi!(Option<&'static T>);
-impl_ptr_toabi!(Option<&'static mut T>);
+impl_ptr_intoabi!(*const T);
+impl_ptr_intoabi!(*mut T);
+impl_ptr_intoabi!(Option<&'static T>);
+impl_ptr_intoabi!(Option<&'static mut T>);
 
 //
-// SAFETY: No `FromFfi` and `ToFfi` for arrays because passing or returning them by value is not a
+// SAFETY: `FromFfi` for *mutable* references is safe because it is guaranteed that no two Rust code
+// called via FFI can be running at the same time on the same OS thread (no Lua reentrancy).
+//
+// i.e. The call stack will always look something like this:
+//
+// * Runtime (LuaJIT/Rust) -> Lua (via C) -> Rust (via FFI): This is SAFE and the only use case we
+//     support. All references (mutable or not) to Rust user objects will be dropped before
+//     returning to Lua.
+//
+// * Runtime (LuaJIT/Rust) -> Lua (via C) -> Rust (via FFI) -> Lua (via callback): This is UNSAFE
+//     because we cannot prevent the Lua callback from calling back into Rust code via FFI which
+//     could violate exclusive borrow semantics. This is prevented by not implementing `FromFfi` for
+//     function pointers (see below).
+//
+// The runtime does not keep any references to Rust user objects boxed in cdata (futures are the
+// only exception; their ownership is transferred to the runtime via yield).
+//
+macro_rules! impl_ref_fromabi {
+    ($ty:ty) => {
+        unsafe impl<'s, T: Type> FromFfi for $ty {
+            type From = Option<$ty>;
+
+            fn prelude(arg: &str) -> impl Display {
+                display!(r#"assert({arg} ~= nil, "argument '{arg}' cannot be nil"); "#)
+            }
+
+            fn convert(from: Self::From) -> Self {
+                // SAFETY: we already checked that the reference is nonnull from the lua side
+                debug_assert!(
+                    from.is_some(),
+                    "<{}>::convert() called on a null reference when it was checked to be nonnull",
+                    stringify!($ty),
+                );
+
+                unsafe { from.unwrap_unchecked() }
+            }
+        }
+    };
+}
+
+impl_ref_fromabi!(&'s T);
+impl_ref_fromabi!(&'s mut T);
+
+//
+// SAFETY: `IntoFfi` only for 'static references because we cannot guarantee that the pointer will
+// not outlive the pointee otherwise.
+//
+macro_rules! impl_ref_intoabi {
+    ($ty:ty) => {
+        unsafe impl<T: Type> IntoFfi for $ty {
+            type Into = Self;
+
+            fn convert(self) -> Self::Into {
+                self
+            }
+        }
+    };
+}
+
+impl_ref_intoabi!(&'static T);
+impl_ref_intoabi!(&'static mut T);
+
+//
+// SAFETY: No `FromFfi` and `IntoFfi` for arrays because passing or returning them by value is not a
 // thing in C (they are just pointers).
 //
 // TODO: we could automatically convert them to tables and vice-versa
@@ -785,6 +921,10 @@ unsafe impl<T: Type> Type for [T] {
         display!("{}_arr", T::name())
     }
 
+    fn ty() -> TypeType {
+        TypeType::Aggregate
+    }
+
     fn cdecl(name: impl Display) -> impl Display {
         display!("{name}[]")
     }
@@ -799,6 +939,10 @@ unsafe impl<T: Type, const N: usize> Type for [T; N] {
         display!("{}_arr{N}", T::name())
     }
 
+    fn ty() -> TypeType {
+        TypeType::Aggregate
+    }
+
     fn cdecl(name: impl Display) -> impl Display {
         display!("{name}[{N}]")
     }
@@ -820,17 +964,21 @@ macro_rules! impl_function {
         // SAFETY: No `FromFfi` for function pointers because of borrow safety invariants (see above
         // in `&mut T`).
         //
-        // We also can't implement `ToFfi` because we can't call `FromFfi` and `ToFfi` for the
+        // We also can't implement `IntoFfi` because we can't call `FromFfi` and `IntoFfi` for the
         // function's respective argument and return values.
         //
         unsafe impl<$($arg: Type,)* $ret: Type> Type for $ty<($($arg,)*), $ret> {
             fn name() -> impl Display {
                 disp(|f| Ok({
                     write!(f, "fn_{}", $ret::name())?;
-                    $(write!(f, "_{}", $arg::name())?;)*
+                    $(write!(f, "__{}", $arg::name())?;)*
                 }))
             }
 
+            fn ty() -> TypeType {
+                TypeType::Primitive
+            }
+
             fn cdecl(name: impl Display) -> impl Display {
                 $ret::cdecl(disp(move |f| Ok({
                     let mut _n = 0;

crates/luaffi/src/option.rs

@@ -1,78 +0,0 @@
-use crate::{Cdef, CdefBuilder, FfiReturnConvention, FromFfi, ToFfi, Type, TypeBuilder, display};
-use std::{ffi::c_int, fmt::Display, ptr};
-
-#[repr(C)]
-#[allow(non_camel_case_types)]
-pub enum lua_option<T> {
-    None,    // __tag = 0
-    Some(T), // __tag = 1
-}
-
-unsafe impl<T: Type> Type for lua_option<T> {
-    fn name() -> impl Display {
-        display!("option__{}", T::name())
-    }
-
-    fn cdecl(name: impl Display) -> impl Display {
-        display!("struct option__{} {name}", T::name())
-    }
-
-    fn build(b: &mut TypeBuilder) {
-        b.include::<T>().cdef::<Self>();
-    }
-}
-
-unsafe impl<T: Type> Cdef for lua_option<T> {
-    fn build(b: &mut CdefBuilder) {
-        b.field::<c_int>("__tag").field::<T>("__value");
-    }
-}
-
-unsafe impl<T: FromFfi> FromFfi for Option<T> {
-    type From = lua_option<T::From>;
-    type FromArg = *mut Self::From; // pass by-ref
-
-    fn require_keepalive() -> bool {
-        T::require_keepalive()
-    }
-
-    fn prelude(arg: &str) -> impl Display {
-        let ct = Self::From::name();
-        display!(
-            "if {arg} == nil then {arg} = __new(__ct.{ct}); else {}{arg} = __new(__ct.{ct}, 1, {arg}); end; ",
-            T::prelude(arg)
-        )
-    }
-
-    fn convert(from: Self::From) -> Self {
-        match from {
-            lua_option::Some(value) => Some(T::convert(value)),
-            lua_option::None => None,
-        }
-    }
-
-    fn convert_arg(from: Self::FromArg) -> Self {
-        debug_assert!(!from.is_null());
-        Self::convert(unsafe { ptr::replace(from, lua_option::None) })
-    }
-}
-
-unsafe impl<T: ToFfi> ToFfi for Option<T> {
-    type To = lua_option<T::To>;
-
-    fn convert(self) -> Self::To {
-        match self {
-            Some(value) => lua_option::Some(value.convert()),
-            None => lua_option::None,
-        }
-    }
-
-    fn postlude(ret: &str, _conv: FfiReturnConvention) -> impl Display {
-        // if we don't have a value, return nil. otherwise copy out the inner value immediately,
-        // forget the option cdata, then call postlude on the inner value.
-        display!(
-            "if {ret}.__tag == 0 then {ret} = nil; else {ret} = {ret}.__value; {}end; ",
-            T::postlude(ret, FfiReturnConvention::ByValue)
-        )
-    }
-}

crates/luaffi/src/result.rs

@@ -0,0 +1,72 @@
+use crate::{
+    __internal::{disp, display},
+    Cdef, CdefBuilder, IntoFfi, Type, TypeBuilder, TypeType,
+    string::{DROP_BUFFER_FN, lua_buffer},
+};
+use std::{ffi::c_int, fmt::Display};
+
+#[repr(C)]
+#[allow(non_camel_case_types)]
+pub enum lua_result<T> {
+    Err(lua_buffer), // __tag = 0
+    Ok(T),           // __tag = 1
+}
+
+unsafe impl<T: Type> Type for lua_result<T> {
+    fn name() -> impl Display {
+        display!("result__{}", T::name())
+    }
+
+    fn ty() -> TypeType {
+        TypeType::Aggregate
+    }
+
+    fn cdecl(name: impl Display) -> impl Display {
+        display!("struct {} {name}", Self::name())
+    }
+
+    fn build(b: &mut TypeBuilder) {
+        b.cdef::<Self>();
+    }
+}
+
+unsafe impl<T: Type> Cdef for lua_result<T> {
+    fn build(b: &mut CdefBuilder) {
+        b.field::<c_int>("__tag").inner_union(|b| {
+            (T::ty() != TypeType::Void).then(|| b.field::<T>("__value"));
+            b.field::<lua_buffer>("__err");
+        });
+    }
+}
+
+unsafe impl<T: IntoFfi, E: Display> IntoFfi for Result<T, E> {
+    type Into = lua_result<T::Into>;
+
+    fn convert(self) -> Self::Into {
+        match self {
+            Ok(value) => lua_result::Ok(T::convert(value)),
+            Err(err) => lua_result::Err(lua_buffer::new(err.to_string())),
+        }
+    }
+
+    fn postlude(ret: &str) -> impl Display {
+        disp(move |f| {
+            let ct = T::Into::name();
+            write!(f, "if {ret}.__tag ~= 0 then ")?;
+            match T::Into::ty() {
+                TypeType::Void => write!(f, "{ret} = nil; "), // for void results, we don't have a __value
+                TypeType::Primitive => write!(f, "{ret} = {ret}.__value; "),
+                TypeType::Aggregate => write!(f, "{ret} = __new(__ct.{ct}, {ret}.__value); "),
+            }?;
+            write!(f, "{}", T::postlude(ret))?;
+            write!(
+                f,
+                "else \
+                    local __{ret}_msg = __intern({ret}.__err.__ptr, {ret}.__err.__len); \
+                    __C.{DROP_BUFFER_FN}({ret}.__err); \
+                    return error(__{ret}_msg); \
+                 end; "
+            )
+        })
+    }
+}

crates/luaffi/src/string.rs

@@ -1,6 +1,28 @@
-use crate::{__internal::disp, FromFfi, IS_UTF8_FN, Type};
+use crate::{
+    __internal::{disp, display, export},
+    FromFfi, IntoFfi,
+};
+use bstr::{BStr, BString};
 use luaffi_impl::{cdef, metatype};
-use std::{fmt, ptr, slice};
+use std::{fmt::Display, mem::ManuallyDrop, ptr, slice};
+
+pub(crate) const IS_UTF8_FN: &str = "luaffi_is_utf8";
+pub(crate) const DROP_BUFFER_FN: &str = "luaffi_drop_buffer";
+
+#[unsafe(export_name = "luaffi_is_utf8")]
+unsafe extern "C" fn __is_utf8(ptr: *const u8, len: usize) -> bool {
+    debug_assert!(!ptr.is_null());
+    simdutf8::basic::from_utf8(unsafe { slice::from_raw_parts(ptr, len) }).is_ok()
+}
+
+#[unsafe(export_name = "luaffi_drop_buffer")]
+unsafe extern "C" fn __drop_buffer(buf: *mut lua_buffer) {
+    debug_assert!(!buf.is_null());
+    debug_assert!(!unsafe { (*buf).__ptr.is_null() });
+    drop(unsafe { Vec::from_raw_parts((*buf).__ptr, (*buf).__len, (*buf).__cap) })
+}
+
+export![__is_utf8, __drop_buffer];
 
 #[derive(Debug, Clone, Copy)]
 #[cdef]
@@ -10,52 +32,94 @@ pub struct lua_buf {
 }
 
 #[metatype]
-impl lua_buf {}
+impl lua_buf {
+    // this takes a slice and decomposes it into its raw parts. caller should ensure the result is
+    // used only as long as the original buffer is still alive.
+    pub(crate) fn new(s: &[u8]) -> Self {
+        Self {
+            __ptr: s.as_ptr(),
+            __len: s.len(),
+        }
+    }
 
-unsafe impl FromFfi for *const [u8] {
-    type From = lua_buf;
-    type FromArg = *const Self::From;
+    pub(crate) fn null() -> Self {
+        Self {
+            __ptr: ptr::null(),
+            __len: 0,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+#[cdef]
+pub struct lua_buffer {
+    __ptr: *mut u8,
+    __len: usize,
+    __cap: usize,
+}
+
+#[metatype]
+impl lua_buffer {
+    // this takes ownership of the Vec and decomposes it into its raw parts. the result must be
+    // dropped by `__drop_buffer` (see [`DROP_BUFFER_FN`]).
+    pub(crate) fn new(s: impl Into<Vec<u8>>) -> Self {
+        let s = s.into();
+        Self {
+            __cap: s.capacity(),
+            __len: s.len(),
+            __ptr: ManuallyDrop::new(s).as_mut_ptr(),
+        }
+    }
+
+    pub(crate) fn null() -> Self {
+        Self {
+            __ptr: ptr::null_mut(),
+            __len: 0,
+            __cap: 0,
+        }
+    }
+}
+
+unsafe impl<'s> FromFfi for &'s [u8] {
+    type From = Option<&'s lua_buf>;
 
     fn require_keepalive() -> bool {
         true
     }
 
-    fn prelude(arg: &str) -> impl fmt::Display {
+    fn prelude(arg: &str) -> impl Display {
         // this converts string arguments to a `lua_buf` with a pointer to the string and its length
         disp(move |f| {
-            let ct = Self::From::name();
             write!(
                 f,
-                r#"if {arg} ~= nil then assert(type({arg}) == "string", "string expected in argument '{arg}', got " .. type({arg})); "#
+                r#"assert(type({arg}) == "string", "string expected in argument '{arg}', got " .. type({arg})); "#
             )?;
-            write!(f, "{arg} = __new(__ct.{ct}, {arg}, #{arg}); end; ")
+            // SAFETY: the lua_buf is only valid for as long as the string is alive. we've ensured
+            // that it is alive for at least the duration of the ffi call via `require_keepalive()`.
+            write!(f, "{arg} = __new(__ct.lua_buf, {arg}, #{arg}); end; ")
         })
     }
 
     fn convert(from: Self::From) -> Self {
-        ptr::slice_from_raw_parts(from.__ptr, from.__len)
-    }
-
-    fn convert_arg(from: Self::FromArg) -> Self {
-        if from.is_null() {
-            ptr::slice_from_raw_parts(ptr::null(), 0)
-        } else {
-            Self::convert(unsafe { *from })
-        }
+        // SAFETY: we already checked that the string is nonnull from the lua side
+        debug_assert!(from.is_some());
+        let from = unsafe { from.unwrap_unchecked() };
+        debug_assert!(!from.__ptr.is_null());
+        unsafe { slice::from_raw_parts(from.__ptr, from.__len) }
     }
 }
 
-unsafe impl FromFfi for &str {
-    type From = lua_buf;
-    type FromArg = *const Self::From;
+unsafe impl<'s> FromFfi for &'s str {
+    type From = Option<&'s lua_buf>;
 
     fn require_keepalive() -> bool {
         true
     }
 
-    fn prelude(arg: &str) -> impl fmt::Display {
+    fn prelude(arg: &str) -> impl Display {
+        // this converts string arguments to a `lua_buf` with a pointer to the string and its length
+        // and ensures that the string is valid utf8
         disp(move |f| {
-            let ct = Self::From::name();
             write!(
                 f,
                 r#"assert(type({arg}) == "string", "string expected in argument '{arg}', got " .. type({arg})); "#
@@ -64,25 +128,144 @@ unsafe impl FromFfi for &str {
                 f,
                 r#"assert(__C.{IS_UTF8_FN}({arg}, #{arg}), "argument '{arg}' must be a valid utf-8 string"); "#
             )?;
-            write!(f, "{arg} = __new(__ct.{ct}, {arg}, #{arg}); ")
+            write!(f, "{arg} = __new(__ct.lua_buf, {arg}, #{arg}); ")
         })
     }
 
     fn convert(from: Self::From) -> Self {
         // SAFETY: we already checked that the string is nonnull and valid utf8 from the lua side
+        debug_assert!(from.is_some());
+        let from = unsafe { from.unwrap_unchecked() };
         debug_assert!(!from.__ptr.is_null());
-        let s = unsafe { slice::from_raw_parts(from.__ptr, from.__len) };
-
+        let from = unsafe { slice::from_raw_parts(from.__ptr, from.__len) };
         debug_assert!(
-            std::str::from_utf8(s).is_ok(),
+            std::str::from_utf8(from).is_ok(),
             "<&str>::convert() called on an invalid utf8 string when it was checked to be valid"
         );
-
-        unsafe { std::str::from_utf8_unchecked(s) }
+        unsafe { std::str::from_utf8_unchecked(from) }
+    }
 }
 
-    fn convert_arg(from: Self::FromArg) -> Self {
-        debug_assert!(!from.is_null());
-        unsafe { Self::convert(*from) }
+unsafe impl IntoFfi for &'static [u8] {
+    type Into = lua_buf;
+
+    fn convert(self) -> Self::Into {
+        // SAFETY: the slice is 'static so the resulting lua_buf is always valid
+        lua_buf::new(self)
+    }
+
+    fn postlude(ret: &str) -> impl Display {
+        display!("{ret} = __intern({ret}.__ptr, {ret}.__len)")
     }
 }
+
+unsafe impl IntoFfi for Vec<u8> {
+    type Into = lua_buffer;
+
+    fn convert(self) -> Self::Into {
+        lua_buffer::new(self)
+    }
+
+    fn postlude(ret: &str) -> impl Display {
+        display!(
+            "do local __{ret} = {ret}; {ret} = __intern({ret}.__ptr, {ret}.__len); __C.{DROP_BUFFER_FN}(__{ret}); end; "
+        )
+    }
+}
+
+macro_rules! impl_from_via {
+    ($ty:ty, $via:ty) => {
+        unsafe impl<'s> FromFfi for $ty {
+            type From = <$via as FromFfi>::From;
+
+            fn require_keepalive() -> bool {
+                <$via as FromFfi>::require_keepalive()
+            }
+
+            fn prelude(arg: &str) -> impl Display {
+                <$via as FromFfi>::prelude(arg)
+            }
+
+            fn convert(from: Self::From) -> Self {
+                <$via as FromFfi>::convert(from).into()
+            }
+        }
+    };
+}
+
+impl_from_via!(&'s BStr, &'s [u8]);
+
+macro_rules! impl_into_via {
+    ($ty:ty, $via:ty) => {
+        unsafe impl IntoFfi for $ty {
+            type Into = <$via as IntoFfi>::Into;
+
+            fn convert(self) -> Self::Into {
+                <$via as IntoFfi>::convert(self.into())
+            }
+
+            fn postlude(ret: &str) -> impl Display {
+                <$via as IntoFfi>::postlude(ret)
+            }
+        }
+    };
+}
+
+impl_into_via!(&'static BStr, &'static [u8]);
+impl_into_via!(&'static str, &'static BStr);
+impl_into_via!(BString, Vec<u8>);
+impl_into_via!(String, BString);
+
+macro_rules! impl_optional_from {
+    ($ty:ty) => {
+        unsafe impl<'s> FromFfi for Option<$ty> {
+            type From = <$ty as FromFfi>::From;
+
+            fn require_keepalive() -> bool {
+                <$ty as FromFfi>::require_keepalive()
+            }
+
+            fn prelude(arg: &str) -> impl Display {
+                // just pass a null pointer if argument is nil
+                display!(
+                    "if {arg} ~= nil then {}end; ",
+                    <$ty as FromFfi>::prelude(arg)
+                )
+            }
+
+            fn convert(from: Self::From) -> Self {
+                from.map(|s| <$ty as FromFfi>::convert(Some(s)))
+            }
+        }
+    };
+}
+
+impl_optional_from!(&'s [u8]);
+impl_optional_from!(&'s BStr);
+impl_optional_from!(&'s str);
+
+macro_rules! impl_optional_into {
+    ($ty:ty, $null:expr) => {
+        unsafe impl IntoFfi for Option<$ty> {
+            type Into = <$ty as IntoFfi>::Into;
+
+            fn convert(self) -> Self::Into {
+                self.map_or($null, <$ty as IntoFfi>::convert)
+            }
+
+            fn postlude(ret: &str) -> impl Display {
+                display!(
+                    "if {ret}.__ptr == nil then {ret} = nil; else {}end; ",
+                    <$ty as IntoFfi>::postlude(ret)
+                )
+            }
+        }
+    };
+}
+
+impl_optional_into!(&'static [u8], lua_buf::null());
+impl_optional_into!(&'static BStr, lua_buf::null());
+impl_optional_into!(&'static str, lua_buf::null());
+impl_optional_into!(Vec<u8>, lua_buffer::null());
+impl_optional_into!(BString, lua_buffer::null());
+impl_optional_into!(String, lua_buffer::null());

crates/luaffi_impl/src/cdef.rs

@@ -1,8 +1,8 @@
 use crate::utils::{ffi_crate, syn_assert, syn_error};
 use darling::FromMeta;
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-use syn::{ext::IdentExt, *};
+use quote::{format_ident, quote, quote_spanned};
+use syn::{ext::IdentExt, spanned::Spanned, *};
 
 #[derive(Debug, FromMeta)]
 pub struct Args {}
@@ -24,35 +24,39 @@ pub fn transform(_args: Args, mut item: Item) -> Result<TokenStream> {
 
     let mod_name = format_ident!("__{name}_cdef");
 
-    Ok(quote! {
+    Ok(quote!(
         #[repr(C)]
         #[allow(non_camel_case_types)]
         #item
 
         #[doc(hidden)]
         #[allow(unused, non_snake_case)]
+        /// Automatically generated by luaffi.
         mod #mod_name {
             use super::*;
             #impl_type
             #impl_cdef
         }
-    })
+    ))
 }
 
 fn generate_type(ty: &Ident) -> Result<TokenStream> {
     let ffi = ffi_crate();
-    let fmt = quote!(::std::format!);
-    let name = LitStr::new(&format!("{}", ty.unraw()), ty.span());
-    let cdecl_fmt = LitStr::new(&format!("struct {} {{}}", ty.unraw()), ty.span());
+    let span = ty.span();
+    let name = LitStr::new(&ty.unraw().to_string(), span);
 
-    Ok(quote! {
+    Ok(quote_spanned!(span =>
         unsafe impl #ffi::Type for #ty {
             fn name() -> impl ::std::fmt::Display {
                 #name
             }
 
+            fn ty() -> #ffi::TypeType {
+                #ffi::TypeType::Aggregate
+            }
+
             fn cdecl(name: impl ::std::fmt::Display) -> impl ::std::fmt::Display {
-                #fmt(#cdecl_fmt, name)
+                ::std::format!("struct {} {name}", #name)
             }
 
             fn build(b: &mut #ffi::TypeBuilder) {
@@ -60,11 +64,12 @@ fn generate_type(ty: &Ident) -> Result<TokenStream> {
             }
         }
 
-        unsafe impl #ffi::ToFfi for #ty {
-            type To = Self;
-            fn convert(self) -> Self::To { self }
+        // SAFETY: we can always implement `IntoFfi` because it transfers ownership from Rust to Lua
+        unsafe impl #ffi::IntoFfi for #ty {
+            type Into = Self;
+            fn convert(self) -> Self::Into { self }
         }
-    })
+    ))
 }
 
 fn generate_cdef_structure(str: &mut ItemStruct) -> Result<TokenStream> {
@@ -76,13 +81,14 @@ fn generate_cdef_structure(str: &mut ItemStruct) -> Result<TokenStream> {
 
     let ffi = ffi_crate();
     let ty = &str.ident;
-    let build = generate_build_cdef(&to_cfields(&mut str.fields)?)?;
+    let span = ty.span();
+    let build = generate_cdef_build(&get_cfields(&mut str.fields)?)?;
 
-    Ok(quote! {
+    Ok(quote_spanned!(span =>
         unsafe impl #ffi::Cdef for #ty {
             fn build(b: &mut #ffi::CdefBuilder) { #build }
         }
-    })
+    ))
 }
 
 fn generate_cdef_enum(enu: &mut ItemEnum) -> Result<TokenStream> {
@@ -94,22 +100,24 @@ fn generate_cdef_enum(enu: &mut ItemEnum) -> Result<TokenStream> {
 
     let ffi = ffi_crate();
     let ty = &enu.ident;
+    let span = ty.span();
     let build = enu
         .variants
         .iter_mut()
         .map(|variant| {
-            let build = generate_build_cdef(&to_cfields(&mut variant.fields)?)?;
-            Ok(quote! { b.inner_struct(|b| { #build }); })
+            let span = variant.span();
+            let build = generate_cdef_build(&get_cfields(&mut variant.fields)?)?;
+            Ok(quote_spanned!(span => b.inner_struct(|b| { #build })))
         })
         .collect::<Result<Vec<_>>>()?;
 
-    Ok(quote! {
+    Ok(quote_spanned!(span =>
         unsafe impl #ffi::Cdef for #ty {
             fn build(b: &mut #ffi::CdefBuilder) {
-                b.field::<::std::ffi::c_int>("__tag").inner_union(|b| { #(#build)* });
+                b.field::<::std::ffi::c_int>("__tag").inner_union(|b| { #(#build;)* });
             }
         }
-    })
+    ))
 }
 
 struct CField {
@@ -123,7 +131,7 @@ struct CFieldAttrs {
     opaque: bool,
 }
 
-fn to_cfields(fields: &mut Fields) -> Result<Vec<CField>> {
+fn get_cfields(fields: &mut Fields) -> Result<Vec<CField>> {
     match fields {
         Fields::Named(fields) => fields.named.iter_mut(),
         Fields::Unnamed(fields) => fields.unnamed.iter_mut(),
@@ -133,17 +141,17 @@ fn to_cfields(fields: &mut Fields) -> Result<Vec<CField>> {
     .map(|(i, field)| {
         Ok(CField {
             name: match field.ident {
-                Some(ref name) => format!("{}", name.unraw()),
+                Some(ref name) => name.unraw().to_string(),
                 None => format!("__{i}"),
             },
             ty: field.ty.clone(),
-            attrs: parse_attrs(&mut field.attrs)?,
+            attrs: parse_cfield_attrs(&mut field.attrs)?,
         })
     })
     .collect()
 }
 
-fn parse_attrs(attrs: &mut Vec<Attribute>) -> Result<CFieldAttrs> {
+fn parse_cfield_attrs(attrs: &mut Vec<Attribute>) -> Result<CFieldAttrs> {
     let mut parsed = CFieldAttrs::default();
     let mut i = 0;
     while let Some(attr) = attrs.get(i) {
@@ -160,11 +168,11 @@ fn parse_attrs(attrs: &mut Vec<Attribute>) -> Result<CFieldAttrs> {
     Ok(parsed)
 }
 
-fn generate_build_cdef(fields: &[CField]) -> Result<TokenStream> {
-    let mut body = vec![quote! {
+fn generate_cdef_build(fields: &[CField]) -> Result<TokenStream> {
+    let mut body = vec![quote!(
         let mut offset = 0;
         let mut align = 1;
-    }];
+    )];
 
     fn offset(i: usize) -> Ident {
         format_ident!("offset{i}")
@@ -173,40 +181,41 @@ fn generate_build_cdef(fields: &[CField]) -> Result<TokenStream> {
     let max = quote!(::std::cmp::Ord::max);
     let size_of = quote!(::std::mem::size_of);
     let align_of = quote!(::std::mem::align_of);
+
     for (i, field) in fields.iter().enumerate() {
         let ty = &field.ty;
         let offset = offset(i);
-        body.push(quote! {
+        body.push(quote_spanned!(ty.span() =>
             // round up current offset to the alignment of field type for field offset
             offset = (offset + #align_of::<#ty>() - 1) & !(#align_of::<#ty>() - 1);
             align = #max(align, #align_of::<#ty>());
             let #offset = offset;
             offset += #size_of::<#ty>();
-        });
+        ));
     }
 
-    body.push(quote! {
+    body.push(quote!(
         // round up final offset to the total alignment of struct for struct size
         let size = (offset + align - 1) & !(align - 1);
-    });
+    ));
 
     let len = fields.len();
     for (i, field) in fields.iter().enumerate() {
         let name = &field.name;
         let ty = &field.ty;
-        if field.attrs.opaque {
-            body.push(if i == len - 1 {
+        body.push(if field.attrs.opaque {
+            if i == len - 1 {
                 let a = offset(i);
-                quote! { b.field_opaque(size - #a); } // last field
+                quote_spanned!(ty.span() => b.field_opaque(size - #a);) // last field
             } else {
                 let a = offset(i);
                 let b = offset(i + 1);
-                quote! { b.field_opaque(#b - #a); }
-            });
-        } else {
-            body.push(quote! { b.field::<#ty>(#name); });
+                quote_spanned!(ty.span() => b.field_opaque(#b - #a);)
             }
+        } else {
+            quote_spanned!(ty.span() => b.field::<#ty>(#name);)
+        });
     }
 
-    Ok(quote! { #(#body)* })
+    Ok(quote!(#(#body)*))
 }

crates/luaffi_impl/src/metatype.rs

@@ -1,7 +1,10 @@
-use crate::utils::{ffi_crate, is_primitive, is_unit, pat_ident, syn_assert, ty_name};
+use crate::utils::{
+    ffi_crate, is_primitivelike, is_unit, pat_ident, syn_assert, syn_error, ty_name,
+};
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-use syn::{ext::IdentExt, *};
+use quote::{ToTokens, format_ident, quote, quote_spanned};
+use std::{collections::HashSet, fmt, iter};
+use syn::{ext::IdentExt, spanned::Spanned, *};
 
 pub fn transform(mut imp: ItemImpl) -> Result<TokenStream> {
     syn_assert!(
@@ -13,94 +16,76 @@ pub fn transform(mut imp: ItemImpl) -> Result<TokenStream> {
     let impls = generate_impls(&mut imp)?;
     let mod_name = format_ident!("__{}_metatype", ty_name(&imp.self_ty)?);
 
-    Ok(quote! {
+    Ok(quote!(
         #imp
 
         #[doc(hidden)]
         #[allow(unused, non_snake_case)]
+        /// Automatically generated by luaffi.
         mod #mod_name {
             use super::*;
             #impls
         }
-    })
+    ))
 }
 
 fn generate_impls(imp: &mut ItemImpl) -> Result<TokenStream> {
+    let ffi = ffi_crate();
     let ty = imp.self_ty.clone();
     let ty_name = ty_name(&ty)?;
+    let mut ffi_funcs = FfiRegistry::new(ty_name.clone());
+    let mut lua_funcs = LuaRegistry::new(ty_name.clone());
+    let mut mms = HashSet::new();
+    let mut lua_drop = None;
 
-    let ffi = ffi_crate();
-    let ffi_funcs = get_ffi_functions(imp)?;
-
-    // wrapper extern "C" functions that call the actual implementation
-    let ffi_wrappers: Vec<_> = ffi_funcs
-        .iter()
-        .map(generate_ffi_wrapper)
-        .collect::<Result<_>>()?;
-
-    // ffi function registration code
-    let ffi_register: Vec<_> = ffi_funcs
-        .iter()
-        .map(generate_ffi_register)
-        .collect::<Result<_>>()?;
-
-    let ffi_register_new = match ffi_funcs
-        .iter()
-        .find(|f| f.attrs.metatable.as_deref() == Some("new"))
-    {
-        Some(_) => None,
-        None => Some({
-            // fallback error constructor to prevent creating uninitialised ctypes
-            let err = format!(r#"function() error("type '{ty_name}' has no constructor"); end"#);
-            quote! { b.metatable_raw("new", #err); }
-        }),
-    };
-
-    let ffi_drop_rname = format_ident!("__ffi_drop");
-    let ffi_drop_cname = format!("{ty_name}_drop");
-    let ffi_wrapper_drop = quote! {
-        #[unsafe(export_name = #ffi_drop_cname)]
-        unsafe extern "C" fn #ffi_drop_rname(ptr: *mut Self) {
-            unsafe { ::std::ptr::drop_in_place(ptr) }
+    for func in get_ffi_functions(imp)? {
+        if let Some(mm) = func.attrs.metamethod {
+            syn_assert!(
+                mms.insert(mm),
+                func.name,
+                "metamethod `{mm}` already defined"
+            );
         }
-    };
 
-    let ffi_register_drop = quote! {
-        if ::std::mem::needs_drop::<Self>() {
-            b.declare::<#ffi::UnsafeExternCFn<(*mut Self,), ()>>(#ffi_drop_cname);
-            b.metatable_raw("gc", ::std::format_args!("__C.{}", #ffi_drop_cname));
+        add_ffi_function(&mut ffi_funcs, &func)?;
     }
-    };
 
-    // ffi function symbol export code
-    let ffi_exports = {
-        let mut names = vec![&ffi_drop_rname];
-        names.extend(ffi_funcs.iter().map(|f| &f.rust_name));
-        generate_ffi_exports(&ty, names.into_iter())?
-    };
+    for func in get_lua_functions(imp)? {
+        if let Some(mm) = func.attrs.metamethod {
+            syn_assert!(
+                mms.insert(mm),
+                func.name,
+                "metamethod `{mm}` already defined"
+            );
+        }
 
-    // lua function registration code
-    let lua_funcs = get_lua_functions(imp)?;
-    let lua_register: Vec<_> = lua_funcs
-        .iter()
-        .map(generate_lua_register)
-        .collect::<Result<_>>()?;
+        if func.attrs.metamethod == Some(Metamethod::Gc) {
+            lua_drop = Some(func);
+        } else {
+            add_lua_function(&mut lua_funcs, &func)?;
+        }
+    }
+
+    if !mms.contains(&Metamethod::New) {
+        inject_fallback_new(&mut lua_funcs)?;
+    }
+
+    inject_merged_drop(&mut ffi_funcs, lua_drop.as_ref())?;
+
+    let ffi_shims = &ffi_funcs.shims;
+    let ffi_build = &ffi_funcs.build;
+    let lua_build = &lua_funcs.build;
+    let ffi_exports = generate_ffi_exports(&ffi_funcs)?;
 
     Ok(quote! {
-        impl #ty {
-            #(#ffi_wrappers)*
-            #ffi_wrapper_drop
-        }
+        impl #ty { #(#ffi_shims)* }
 
         unsafe impl #ffi::Metatype for #ty {
             type Target = Self;
 
             fn build(b: &mut #ffi::MetatypeBuilder) {
-                #(#ffi_register)*
-                #(#lua_register)*
-
-                #ffi_register_new
-                #ffi_register_drop
+                #(#ffi_build)*
+                #(#lua_build)*
             }
         }
 
@@ -108,20 +93,103 @@ fn generate_impls(imp: &mut ItemImpl) -> Result<TokenStream> {
     })
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum Metamethod {
+    // known luajit metamethods (see lj_obj.h)
+    // index, newindex, mode and metatable are not included
+    Gc,
+    Eq,
+    Len,
+    Lt,
+    Le,
+    Concat,
+    Call,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    Pow,
+    Unm,
+    ToString,
+    New,
+    Pairs,
+    Ipairs,
+}
+
+impl TryFrom<&Ident> for Metamethod {
+    type Error = Error;
+
+    fn try_from(value: &Ident) -> Result<Self> {
+        Ok(match value.to_string().as_str() {
+            "gc" => Self::Gc,
+            "eq" => Self::Eq,
+            "len" => Self::Len,
+            "lt" => Self::Lt,
+            "le" => Self::Le,
+            "concat" => Self::Concat,
+            "call" => Self::Call,
+            "add" => Self::Add,
+            "sub" => Self::Sub,
+            "mul" => Self::Mul,
+            "div" => Self::Div,
+            "mod" => Self::Mod,
+            "pow" => Self::Pow,
+            "unm" => Self::Unm,
+            "tostring" => Self::ToString,
+            "new" => Self::New,
+            "pairs" => Self::Pairs,
+            "ipairs" => Self::Ipairs,
+            _ => syn_error!(value, "unknown metamethod"),
+        })
+    }
+}
+
+impl fmt::Display for Metamethod {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let name = match self {
+            Self::Gc => "gc",
+            Self::Eq => "eq",
+            Self::Len => "len",
+            Self::Lt => "lt",
+            Self::Le => "le",
+            Self::Concat => "concat",
+            Self::Call => "call",
+            Self::Add => "add",
+            Self::Sub => "sub",
+            Self::Mul => "mul",
+            Self::Div => "div",
+            Self::Mod => "mod",
+            Self::Pow => "pow",
+            Self::Unm => "unm",
+            Self::ToString => "tostring",
+            Self::New => "new",
+            Self::Pairs => "pairs",
+            Self::Ipairs => "ipairs",
+        };
+
+        write!(f, "{name}")
+    }
+}
+
+impl ToTokens for Metamethod {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let name = self.to_string();
+        tokens.extend(quote!(#name));
+    }
+}
+
 struct FfiFunction {
     name: Ident,
-    rust_name: Ident,
-    lua_name: String,
-    c_name: String,
+    is_async: bool,
     params: Vec<PatType>,
     ret: Type,
-    ret_by_out: bool,
     attrs: FfiFunctionAttrs,
 }
 
 #[derive(Default)]
 struct FfiFunctionAttrs {
-    metatable: Option<String>,
+    metamethod: Option<Metamethod>,
 }
 
 fn get_ffi_functions(imp: &mut ItemImpl) -> Result<Vec<FfiFunction>> {
@@ -135,40 +203,33 @@ fn get_ffi_functions(imp: &mut ItemImpl) -> Result<Vec<FfiFunction>> {
         {
             func.sig.abi = None;
 
-            // normalise inputs to PatType
             let params = func
                 .sig
                 .inputs
                 .iter()
-                .map(|arg| {
-                    Ok(match arg {
+                .map(|arg| match arg {
                     FnArg::Receiver(recv) => {
                         let ty = &recv.ty;
-                            parse_quote! { self: #ty }
+                        parse_quote_spanned!(ty.span() => self: #ty)
                     }
                     FnArg::Typed(ty) => ty.clone(),
                 })
-                })
-                .collect::<Result<_>>()?;
+                .collect();
 
-            // normalise output to Type
             let ret = match func.sig.output {
                 ReturnType::Default => parse_quote!(()),
                 ReturnType::Type(_, ref ty) => (**ty).clone(),
             };
 
-            // whether to use out-param for return values
-            let ret_by_out = !is_primitive(&ret);
+            let attrs = parse_ffi_function_attrs(&mut func.attrs)?;
+            attrs.metamethod.map(|mm| document_metamethod(func, mm));
 
             funcs.push(FfiFunction {
                 name: func.sig.ident.clone(),
-                rust_name: format_ident!("__ffi_{}", func.sig.ident.unraw()),
-                lua_name: format!("{}", func.sig.ident.unraw()),
-                c_name: format!("{}_{}", ty_name(&imp.self_ty)?, func.sig.ident.unraw()),
+                is_async: func.sig.asyncness.is_some(),
                 params,
                 ret,
-                ret_by_out,
-                attrs: parse_ffi_function_attrs(&mut func.attrs)?,
+                attrs,
             });
         }
     }
@@ -180,209 +241,473 @@ fn parse_ffi_function_attrs(attrs: &mut Vec<Attribute>) -> Result<FfiFunctionAtt
     let mut parsed = FfiFunctionAttrs::default();
     let mut i = 0;
     while let Some(attr) = attrs.get(i) {
-        if let Some(name) = attr.path().get_ident() {
-            if name == "metatable" {
-                parsed.metatable = Some(attr.parse_args::<LitStr>()?.value());
-                attrs.remove(i);
-                continue;
-            } else if name == "new" {
-                parsed.metatable = Some("new".into());
-                attrs.remove(i);
-                continue;
-            }
+        if let Some(name) = attr.path().get_ident()
+            && let Ok(method) = Metamethod::try_from(name)
+        {
+            match method {
+                Metamethod::Gc => syn_error!(attr, "implement `Drop` instead"),
+                _ => {}
             }
+
+            parsed.metamethod = Some(method);
+            attrs.remove(i);
+        } else {
             i += 1;
         }
+    }
 
     Ok(parsed)
 }
 
-#[derive(Debug)]
-enum FfiArgType {
+enum FfiParameterType {
     Default,
 }
 
-fn get_ffi_arg_type(_ty: &Type) -> FfiArgType {
-    FfiArgType::Default
+fn get_ffi_param_type(_ty: &Type) -> FfiParameterType {
+    FfiParameterType::Default
 }
 
-fn generate_ffi_wrapper(func: &FfiFunction) -> Result<TokenStream> {
-    let ffi = ffi_crate();
-    let name = &func.name;
-    let rust_name = &func.rust_name;
-    let c_name = &func.c_name;
-    let mut params = vec![];
-    let mut args = vec![];
-
-    for (i, param) in func.params.iter().enumerate() {
-        let name = format_ident!("arg{i}");
-        let ty = &param.ty;
-
-        match get_ffi_arg_type(ty) {
-            FfiArgType::Default => {
-                params.push(quote! { #name: <#ty as #ffi::FromFfi>::FromArg });
-                args.push(quote! { <#ty as #ffi::FromFfi>::convert_arg(#name) });
-            }
-        }
+enum FfiReturnType {
+    Void,
+    ByValue,
+    ByOutParam,
 }
 
-    let (ret, call) = if func.ret_by_out {
-        // make return by out-param the first parameter
-        let ret = &func.ret;
-        params.insert(0, quote! { out: *mut #ret });
-        (
-            quote!(()),
-            quote! { ::std::ptr::write(out, Self::#name(#(#args),*)) },
-        )
+fn get_ffi_ret_type(ty: &Type) -> FfiReturnType {
+    // aggregate type returns use an out-param instead of return by-value.
+    //
+    // out-param isn't strictly necessary (luajit can handle them fine), but luajit doesn't jit
+    // compile aggregate returns yet, so this is more of a performance optimisation.
+    // https://luajit.org/ext_ffi_semantics.html#status
+    //
+    // right now this just heuristically looks for common primitive identifiers like `i32` and
+    // `usize` which has its limitations when it comes to type aliases (proc-macro can't see them),
+    // but the worst thing that can happen with a false detection is an unnecessarily boxed
+    // primitive that gets just unwrapped, or an aggregate suboptimally returned by-value. it should
+    // be correct for 99% of rust code that isn't doing anything weird.
+    //
+    // the builder below has additional assertions to confirm whether our detection was correct.
+    if is_unit(ty) {
+        FfiReturnType::Void
+    } else if is_primitivelike(ty) {
+        FfiReturnType::ByValue
     } else {
-        let ret = &func.ret;
-        (quote! { #ret }, quote! { Self::#name(#(#args),*) })
+        FfiReturnType::ByOutParam
+    }
+}
+
+struct FfiRegistry {
+    ty: Ident,
+    shims: Vec<ImplItemFn>,
+    build: Vec<TokenStream>,
+}
+
+impl FfiRegistry {
+    fn new(ty: Ident) -> Self {
+        Self {
+            ty,
+            shims: vec![],
+            build: vec![],
+        }
+    }
+}
+
+fn add_ffi_function(registry: &mut FfiRegistry, func: &FfiFunction) -> Result<()> {
+    let ffi = ffi_crate();
+    let ty = &registry.ty;
+    let func_name = &func.name;
+    let shim_name = format_ident!("__ffi_{}", func_name.unraw());
+    let lua_name = format!("{}", func_name.unraw());
+    let c_name = if let Some(priv_name) = lua_name.strip_prefix("__") {
+        format!("__{}_{priv_name}", ty.unraw())
+    } else {
+        format!("{}_{lua_name}", ty.unraw())
     };
 
-    Ok(quote! {
+    let func_params = &func.params; // target function parameters
+    let func_ret = &func.ret; // target function return type
+    let mut func_args = vec![]; // target function arguments
+
+    let mut shim_params = vec![]; // shim function parameters
+    let mut shim_ret = if func.is_async {
+        // shim function return type
+        quote_spanned!(func_ret.span() => #ffi::future::lua_future<impl ::std::future::Future<Output = #func_ret>>)
+    } else {
+        quote_spanned!(func_ret.span() => <#func_ret as #ffi::IntoFfi>::Into)
+    };
+
+    let mut asserts = vec![]; // compile-time builder asserts
+    let mut build = vec![]; // ffi builder body
+
+    // for __new metamethods, ignore the first argument (ctype of self, for which there is no
+    // equivalent in C)
+    if func.attrs.metamethod == Some(Metamethod::New) {
+        build.push(quote!(
+            b.param_ignored();
+        ));
+    }
+
+    for (i, param) in func_params.iter().enumerate() {
+        let func_param = &param.ty;
+        let shim_param = format_ident!("arg{i}");
+        let name = pat_ident(&param.pat)?.unraw().to_string();
+
+        match get_ffi_param_type(func_param) {
+            FfiParameterType::Default => {
+                shim_params.push(quote_spanned!(func_param.span() =>
+                    #shim_param: <#func_param as #ffi::FromFfi>::From
+                ));
+                func_args.push(quote_spanned!(param.pat.span() =>
+                    <#func_param as #ffi::FromFfi>::convert(#shim_param)
+                ));
+                build.push(quote_spanned!(param.pat.span() =>
+                    b.param::<#func_param>(#name);
+                ));
+            }
+        }
+    }
+
+    // shim function body
+    let mut shim_body = if func.is_async {
+        // for async functions, wrapped the returned future in lua_future
+        quote_spanned!(func_name.span() => #ffi::future::lua_future::new(Self::#func_name(#(#func_args),*)))
+    } else {
+        quote_spanned!(func_name.span() => <#func_ret as #ffi::IntoFfi>::convert(Self::#func_name(#(#func_args),*)))
+    };
+
+    if !func.is_async {
+        match get_ffi_ret_type(&func_ret) {
+            FfiReturnType::Void => {
+                asserts.push(quote_spanned!(func_ret.span() =>
+                    <<#func_ret as #ffi::IntoFfi>::Into as #ffi::Type>::ty() == #ffi::TypeType::Void
+                ));
+            }
+            FfiReturnType::ByValue => {
+                asserts.push(quote_spanned!(func_ret.span() =>
+                    <#func_ret as #ffi::IntoFfi>::convention() == #ffi::FfiReturnConvention::ByValue
+                ));
+            }
+            FfiReturnType::ByOutParam => {
+                asserts.push(quote_spanned!(func_ret.span() =>
+                    <#func_ret as #ffi::IntoFfi>::convention() == #ffi::FfiReturnConvention::ByOutParam
+                ));
+
+                shim_params.insert(0, quote!(out: *mut #shim_ret));
+                (shim_body, shim_ret) = (quote!(::std::ptr::write(out, #shim_body)), quote!(()));
+            }
+        };
+    }
+
+    // build.push(quote_spanned!(func_name.span() =>
+    //     b.call_inferred(#c_name, Self::#func_name);
+    // ));
+
+    build.push({
+        let infer_args = iter::repeat_n(quote!(::std::unreachable!()), func_params.len());
+        let infer = if func.is_async {
+            quote!(|| #ffi::future::lua_future::new(Self::#func_name(#(#infer_args),*)))
+        } else {
+            quote!(|| Self::#func_name(#(#infer_args),*))
+        };
+        quote_spanned!(func_name.span() => b.call_inferred(#c_name, #infer);)
+    });
+
+    registry.build.push(quote_spanned!(func_name.span() =>
+        #(::std::assert!(#asserts);)*
+    ));
+
+    registry.build.push(match func.attrs.metamethod {
+        Some(ref mm) => quote!(b.metatable(#mm, |b| { #(#build)* });),
+        None => quote!(b.index(#lua_name, |b| { #(#build)* });),
+    });
+
+    registry.shims.push(parse_quote_spanned!(func_name.span() =>
         #[unsafe(export_name = #c_name)]
-        unsafe extern "C" fn #rust_name(#(#params),*) -> #ret { unsafe { #call } }
-    })
+        unsafe extern "C" fn #shim_name(#(#shim_params),*) -> #shim_ret { #shim_body }
+    ));
+
+    Ok(())
 }
 
-fn generate_ffi_register(func: &FfiFunction) -> Result<TokenStream> {
-    let ffi = ffi_crate();
-    let lua_name = &func.lua_name;
-    let c_name = &func.c_name;
+fn generate_ffi_exports(registry: &FfiRegistry) -> Result<TokenStream> {
+    let ty = &registry.ty;
+    let names = registry.shims.iter().map(|f| &f.sig.ident);
 
-    let mut params = vec![];
-    let mut register = vec![];
-
-    // for __new metamethods, ignore the first argument (ctype of self)
-    if func.attrs.metatable.as_deref() == Some("new") {
-        register.push(quote! { b.param_ignored(); });
-    }
-
-    for param in func.params.iter() {
-        let name = format!("{}", pat_ident(&param.pat)?);
-        let ty = &param.ty;
-
-        match get_ffi_arg_type(ty) {
-            FfiArgType::Default => {
-                params.push(quote! { <#ty as #ffi::FromFfi>::FromArg });
-                register.push(quote! { b.param::<#ty>(#name); })
-            }
-        };
-    }
-
-    let ret = &func.ret;
-    let ret_conv = if is_unit(ret) {
-        quote! { #ffi::FfiReturnConvention::Void }
-    } else if func.ret_by_out {
-        quote! { #ffi::FfiReturnConvention::ByOutParam }
-    } else {
-        quote! { #ffi::FfiReturnConvention::ByValue }
-    };
-
-    let declare = if func.ret_by_out {
-        quote! { b.declare::<#ffi::UnsafeExternCFn<(*mut #ret, #(#params,)*), ()>>(#c_name); }
-    } else {
-        quote! { b.declare::<#ffi::UnsafeExternCFn<(#(#params,)*), #ret>>(#c_name); }
-    };
-
-    let register = match func.attrs.metatable {
-        Some(ref mt) => quote! {
-            b.metatable(#mt, |b| {
-                #(#register)*
-                b.call::<#ret>(#c_name, #ret_conv);
-            });
-        },
-        None => quote! {
-            b.index(#lua_name, |b| {
-                #(#register)*
-                b.call::<#ret>(#c_name, #ret_conv);
-            });
-        },
-    };
-
-    Ok(quote! { #declare #register })
-}
-
-fn generate_ffi_exports<'a>(
-    ty: &Type,
-    names: impl Iterator<Item = &'a Ident>,
-) -> Result<TokenStream> {
-    Ok(quote! {
+    Ok(quote_spanned!(ty.span() =>
         // this ensures ffi function symbol exports are actually present in the resulting binary,
         // otherwise they may get dead code-eliminated before it reaches the linker
         #[used]
         static __FFI_EXPORTS: &[fn()] = unsafe {
             &[#(::std::mem::transmute(#ty::#names as *const ())),*]
         };
-    })
+    ))
 }
 
 struct LuaFunction {
-    name: String,
+    name: Ident,
     params: Vec<Pat>,
     body: Block,
+    attrs: LuaFunctionAttrs,
+}
+
+#[derive(Default)]
+struct LuaFunctionAttrs {
+    metamethod: Option<Metamethod>,
 }
 
 fn get_lua_functions(imp: &mut ItemImpl) -> Result<Vec<LuaFunction>> {
     let mut funcs = vec![];
-    let mut i = 0;
 
-    while i < imp.items.len() {
-        if let ImplItem::Fn(ref mut func) = imp.items[i]
+    for item in imp.items.iter_mut() {
+        if let ImplItem::Fn(func) = item
             && let Some(ref abi) = func.sig.abi
             && let Some(ref abi) = abi.name
             && abi.value() == "Lua"
         {
-            // normalise inputs to Pat
             let mut params: Vec<_> = func
                 .sig
                 .inputs
                 .iter()
                 .map(|arg| {
                     Ok(match arg {
-                        FnArg::Receiver(recv) => {
-                            syn_assert!(ty_name(&recv.ty)? == "Self", recv, "must be `self`");
-                            syn_assert!(recv.mutability.is_none(), recv, "cannot be mut");
-                            Pat::Type(parse_quote! { self: cdata })
-                        }
+                        FnArg::Receiver(recv) => Pat::Type(parse_quote_spanned!(recv.span() =>
+                            self: cdata
+                        )),
                         FnArg::Typed(ty) => Pat::Type(ty.clone()),
                     })
                 })
                 .collect::<Result<_>>()?;
 
-            if let Some(_) = func.sig.variadic {
-                params.push(parse_quote!(variadic!()));
+            if let Some(ref variadic) = func.sig.variadic {
+                params.push(parse_quote_spanned!(variadic.span() => variadic!()));
             }
 
-            // shouldn't specify an output type
-            syn_assert!(
-                matches!(func.sig.output, ReturnType::Default),
-                func.sig.output,
-                "cannot have return type"
-            );
+            let attrs = parse_lua_function_attrs(&mut func.attrs)?;
+            attrs.metamethod.map(|mm| document_metamethod(func, mm));
 
             funcs.push(LuaFunction {
-                name: format!("{}", func.sig.ident.unraw()),
-                body: func.block.clone(),
+                name: func.sig.ident.clone(),
                 params,
+                body: func.block.clone(),
+                attrs,
             });
 
-            imp.items.remove(i);
-        } else {
-            i += 1;
+            stub_lua_function(func)?;
         }
     }
 
     Ok(funcs)
 }
 
-fn generate_lua_register(func: &LuaFunction) -> Result<TokenStream> {
+fn stub_lua_function(func: &mut ImplItemFn) -> Result<()> {
     let ffi = ffi_crate();
-    let name = &func.name;
+
+    // converts an extern "Lua" function into a regular function with no body to allow for
+    // documentation generation
+    func.sig.abi = None;
+    func.attrs.push(parse_quote!(#[allow(unused)]));
+    func.block = parse_quote!({
+        ::std::unreachable!("cannot call lua function from rust");
+    });
+
+    let inputs = &mut func.sig.inputs;
+    let output = &mut func.sig.output;
+
+    for input in inputs.iter_mut() {
+        if let FnArg::Typed(pat) = input
+            && let Ok(stub) = stub_lua_type(&pat.ty)
+        {
+            pat.ty = stub.into();
+        }
+    }
+
+    if let ReturnType::Type(_, ty) = output
+        && let Ok(stub) = stub_lua_type(ty)
+    {
+        *ty = stub.into();
+    }
+
+    if let Some(ref variadic) = func.sig.variadic {
+        let ty = quote_spanned!(variadic.span() => variadic);
+        inputs.push(parse_quote!(rest: #ffi::__internal::stub_types::#ty));
+        func.sig.variadic = None;
+    }
+
+    Ok(())
+}
+
+fn stub_lua_type(ty: &Type) -> Result<Type> {
+    let ffi = ffi_crate();
+    let span = ty.span();
+    let ty = if let Type::Infer(_) = ty {
+        quote_spanned!(span => any)
+    } else {
+        match ty_name(ty)?.to_string().as_str() {
+            "any" => quote_spanned!(span => any),
+            "nil" => quote_spanned!(span => nil),
+            "boolean" => quote_spanned!(span => boolean),
+            "lightuserdata" => quote_spanned!(span => lightuserdata),
+            "number" => quote_spanned!(span => number),
+            "integer" => quote_spanned!(span => integer),
+            "string" => quote_spanned!(span => string),
+            "table" => quote_spanned!(span => table),
+            "function" => quote_spanned!(span => function),
+            "userdata" => quote_spanned!(span => userdata),
+            "thread" => quote_spanned!(span => thread),
+            "cdata" => quote_spanned!(span => cdata),
+            _ => syn_error!(ty, "unknown lua type"),
+        }
+    };
+
+    Ok(parse_quote!(#ffi::__internal::stub_types::#ty))
+}
+
+fn parse_lua_function_attrs(attrs: &mut Vec<Attribute>) -> Result<LuaFunctionAttrs> {
+    let mut parsed = LuaFunctionAttrs::default();
+    let mut i = 0;
+    while let Some(attr) = attrs.get(i) {
+        if let Some(name) = attr.path().get_ident()
+            && let Ok(method) = Metamethod::try_from(name)
+        {
+            match method {
+                Metamethod::New => syn_error!(attr, r#"cannot be applied to a lua function"#),
+                _ => {}
+            }
+
+            parsed.metamethod = Some(method);
+            attrs.remove(i);
+        } else {
+            i += 1;
+        }
+    }
+
+    Ok(parsed)
+}
+
+struct LuaRegistry {
+    ty: Ident,
+    build: Vec<TokenStream>,
+}
+
+impl LuaRegistry {
+    fn new(ty: Ident) -> Self {
+        Self { ty, build: vec![] }
+    }
+}
+
+fn add_lua_function(registry: &mut LuaRegistry, func: &LuaFunction) -> Result<()> {
+    let ffi = ffi_crate();
+    let luaify = quote!(#ffi::__internal::luaify!);
+    let name = func.name.unraw().to_string();
     let params = &func.params;
     let body = &func.body;
 
-    Ok(quote! {
-        b.index_raw(#name, #ffi::__internal::luaify!(|#(#params),*| #body));
-    })
+    registry.build.push(match func.attrs.metamethod {
+        Some(ref mm) => quote!(b.metatable_raw(#mm, #luaify(|#(#params),*| #body));),
+        None => quote!(b.index_raw(#name, #luaify(|#(#params),*| #body));),
+    });
+
+    Ok(())
+}
+
+fn document_metamethod(func: &mut ImplItemFn, method: Metamethod) {
+    let s = match method {
+        Metamethod::Eq => "This is a metamethod which is called by the `==` operator.".into(),
+        Metamethod::Len => "This is a metamethod which is called by the `#` operator.".into(),
+        Metamethod::Lt => "This is a metamethod which is called by the `<` operator.".into(),
+        Metamethod::Le => "This is a metamethod which is called by the `<=` operator.".into(),
+        Metamethod::Concat => "This is a metamethod which is called by the `..` operator.".into(),
+        Metamethod::Add => "This is a metamethod which is called by the `+` operator.".into(),
+        Metamethod::Sub => "This is a metamethod which is called by the `-` operator.".into(),
+        Metamethod::Mul => "This is a metamethod which is called by the `*` operator.".into(),
+        Metamethod::Div => "This is a metamethod which is called by the `/` operator.".into(),
+        Metamethod::Mod => "This is a metamethod which is called by the `%` operator.".into(),
+        Metamethod::Pow => "This is a metamethod which is called by the `^` operator.".into(),
+        Metamethod::Unm => "This is a metamethod which is called by the `-` operator.".into(),
+        Metamethod::ToString => {
+            "This is a metamethod which can be called by the `tostring` built-in function.".into()
+        }
+        Metamethod::Pairs => {
+            "This is a metamethod which can be called by the `pairs` built-in function.".into()
+        }
+        Metamethod::Ipairs => {
+            "This is a metamethod which can be called by the `ipairs` built-in function.".into()
+        }
+        _ => format!("This is a metamethod and cannot be called directly."),
+    };
+
+    func.attrs.push(parse_quote!(#[doc = ""]));
+    func.attrs.push(parse_quote!(#[doc = #s]));
+}
+
+fn inject_fallback_new(registry: &mut LuaRegistry) -> Result<()> {
+    let ty = &registry.ty;
+    let lua = format!(
+        r#"function() error("type '{}' has no constructor"); end"#,
+        ty.unraw(),
+    );
+
+    registry.build.push(quote!(
+        b.metatable_raw("new", #lua);
+    ));
+
+    Ok(())
+}
+
+fn inject_merged_drop(registry: &mut FfiRegistry, lua: Option<&LuaFunction>) -> Result<()> {
+    let ffi = ffi_crate();
+    let luaify = quote!(#ffi::__internal::luaify!);
+    let ty = &registry.ty;
+    let shim_name = format_ident!("__ffi_drop");
+    let c_name = format_ident!("{}_drop", ty.unraw());
+    let c_name_str = c_name.to_string();
+
+    if let Some(lua) = lua {
+        syn_assert!(
+            lua.params.len() == 1,
+            lua.name,
+            "finaliser must take exactly one parameter"
+        );
+
+        syn_assert!(
+            pat_ident(&lua.params[0])? == "self",
+            lua.params[0],
+            "finaliser parameter must be `self`"
+        );
+
+        let params = &lua.params;
+        let body = &lua.body;
+
+        registry.build.push(quote_spanned!(ty.span() =>
+            if ::std::mem::needs_drop::<Self>() {
+                // if we have both a lua-side finaliser and a rust drop, then merge the finalisers
+                // by doing the lua part first then drop rust
+                b.declare::<#ffi::UnsafeExternCFn<(*mut Self,), ()>>(#c_name_str);
+                b.metatable_raw("gc", #luaify(|self| {
+                    raw!(#luaify(#body)); // embed the lua part inside a do block
+                    __C::#c_name(self);
+                }));
+            } else {
+                // we only have a lua-side finaliser
+                b.metatable_raw("gc", #luaify(|#(#params),*| #body));
+            }
+        ));
+    } else {
+        registry.build.push(quote_spanned!(ty.span() =>
+            if ::std::mem::needs_drop::<Self>() {
+                // we only have a rust drop
+                b.declare::<#ffi::UnsafeExternCFn<(*mut Self,), ()>>(#c_name_str);
+                b.metatable_raw("gc", ::std::format_args!("__C.{}", #c_name_str));
+            }
+        ));
+    }
+
+    registry.shims.push(parse_quote_spanned!(ty.span() =>
+        #[unsafe(export_name = #c_name_str)]
+        unsafe extern "C" fn #shim_name(ptr: *mut Self) {
+            unsafe { ::std::ptr::drop_in_place(ptr) }
+        }
+    ));
+
+    Ok(())
 }

crates/luaffi_impl/src/utils.rs

@@ -3,7 +3,6 @@ use syn::{spanned::Spanned, *};
 
 macro_rules! syn_error {
     ($src:expr, $($fmt:expr),+) => {{
-        use syn::spanned::*;
         return Err(syn::Error::new($src.span(), format!($($fmt),*)));
     }};
 }
@@ -56,11 +55,11 @@ pub fn is_unit(ty: &Type) -> bool {
     }
 }
 
-pub fn is_primitive(ty: &Type) -> bool {
+pub fn is_primitivelike(ty: &Type) -> bool {
     match ty {
         Type::Tuple(tuple) if tuple.elems.is_empty() => true, // unit type
         Type::Reference(_) | Type::Ptr(_) => true,
-        Type::Paren(paren) => is_primitive(&paren.elem),
+        Type::Paren(paren) => is_primitivelike(&paren.elem),
         Type::Path(path) => {
             if let Some(name) = path.path.get_ident() {
                 matches!(

crates/luaify/src/generate.rs

@@ -523,7 +523,7 @@ fn generate_expr_tuple(f: &mut Formatter, tuple: &ExprTuple, cx: Context) -> Res
             f.write("nil");
             Ok(())
         }
-        _ if cx.is_multi_expr() => generate_punctuated_expr(f, &tuple.elems),
+        _ if cx.is_ret() || cx.is_multi_expr() => generate_punctuated_expr(f, &tuple.elems),
         _ => syn_error!(tuple, "expected single-valued expression"),
     }
 }

crates/luaify/src/transform.rs

@@ -158,7 +158,7 @@ impl Visitor {
                 }
             };
 
-            let tmp = format_ident!("_{ident}");
+            let tmp = format_ident!("__{ident}");
             let span = cast.span();
             *expr = match ty {
                 LuaType::Any => parse_quote_spanned!(span => {}),

crates/luaify/tests/test.rs

@@ -81,7 +81,7 @@ fn local_fn() {
             fn check(self: string, arg: number) {}
             inner
         }),
-        r#"function()local function check(self,arg)do if type(self)=="number"then self=tostring(self);else assert(type(self)=="string","string expected in \'self\', got "..type(self));end;end;do local _arg=arg;arg=tonumber(arg);assert(arg~=nil,"number expected in \'arg\', got "..type(_arg));end;end;return inner;end"#
+        r#"function()local function check(self,arg)do if type(self)=="number"then self=tostring(self);else assert(type(self)=="string","string expected in \'self\', got "..type(self));end;end;do local __arg=arg;arg=tonumber(arg);assert(arg~=nil,"number expected in \'arg\', got "..type(__arg));end;end;return inner;end"#
     );
 }
 
@@ -220,7 +220,7 @@ fn type_checks() {
     );
     assert_eq!(
         luaify!(|s| { s as number }),
-        r#"function(s)do local _s=s;s=tonumber(s);assert(s~=nil,"number expected in \'s\', got "..type(_s));end;end"#
+        r#"function(s)do local __s=s;s=tonumber(s);assert(s~=nil,"number expected in \'s\', got "..type(__s));end;end"#
     );
     assert_eq!(
         luaify!(|s| { s as nil }),

crates/luajit-sys/build.rs

@@ -214,6 +214,11 @@ fn build_runtime(src_path: &Path) {
     let status = panic_err!(make.status(), "failed to execute make");
     (!status.success()).then(|| panic!("failed to compile luajit: {status}: {make:?}"));
 
+    println!(
+        "cargo::rustc-env=LUAJIT_SYS_JITLIB={}",
+        src_path.join("jit").display(),
+    );
+
     if feature!("runtime") {
         println!("cargo::rustc-link-search=native={}", src_path.display());
         println!("cargo::rustc-link-lib=static=luajit");

crates/luajit-sys/lib.rs

@@ -1,14 +1,53 @@
 #![allow(nonstandard_style)]
 use std::{ffi::*, ptr};
 
-include!(env!("LUAJIT_SYS_BINDGEN"));
-
 // #[cfg(all(panic = "abort", feature = "unwind"))]
 // compile_error!(r#"feature "unwind" cannot be enabled if panic = "abort""#);
 
 // #[cfg(all(panic = "unwind", not(feature = "unwind")))]
 // compile_error!(r#"feature "unwind" must be enabled if panic = "unwind""#);
 
+include!(env!("LUAJIT_SYS_BINDGEN"));
+
+pub unsafe extern "C" fn luaJIT_openlibs(L: *mut lua_State) {
+    unsafe {
+        lua_getglobal(L, c"package".as_ptr());
+        lua_getfield(L, -1, c"preload".as_ptr());
+        lua_replace(L, -2);
+        macro_rules! load {
+            ($n:literal, $f:literal) => {{
+                let n: &'static CStr = $n;
+                let f = include_bytes!(concat!(env!("LUAJIT_SYS_JITLIB"), "/", $f));
+                if luaL_loadbuffer(L, f.as_ptr().cast(), f.len(), n.as_ptr()) == 0 {
+                    lua_setfield(L, -2, n.as_ptr());
+                } else {
+                    lua_error(L);
+                }
+            }};
+        }
+        load!(c"jit.vmdef", "vmdef.lua");
+        load!(c"jit.dis_x86", "dis_x86.lua");
+        load!(c"jit.dis_x64", "dis_x64.lua");
+        load!(c"jit.dis_arm", "dis_arm.lua");
+        load!(c"jit.dis_arm64", "dis_arm64.lua");
+        load!(c"jit.dis_arm64be", "dis_arm64be.lua");
+        load!(c"jit.dis_ppc", "dis_ppc.lua");
+        load!(c"jit.dis_mips", "dis_mips.lua");
+        load!(c"jit.dis_mipsel", "dis_mipsel.lua");
+        load!(c"jit.dis_mips64", "dis_mips64.lua");
+        load!(c"jit.dis_mips64el", "dis_mips64el.lua");
+        load!(c"jit.dis_mips64r6", "dis_mips64r6.lua");
+        load!(c"jit.dis_mips64r6el", "dis_mips64r6el.lua");
+        load!(c"jit.bc", "bc.lua");
+        load!(c"jit.bcsave", "bcsave.lua");
+        load!(c"jit.v", "v.lua");
+        load!(c"jit.p", "p.lua");
+        load!(c"jit.dump", "dump.lua");
+        load!(c"jit.zone", "zone.lua");
+        lua_pop(L, 1);
+    }
+}
+
 // constants not exposed by lua.h
 pub const LUA_TPROTO: c_int = LUA_TTHREAD + 1;
 pub const LUA_TCDATA: c_int = LUA_TTHREAD + 2;

crates/luajit/src/lib.rs

@@ -505,10 +505,12 @@ impl State {
     }
 
     unsafe extern "C" fn open_cb(L: *mut lua_State) -> c_int {
-        // SAFETY: we wrap luaL_openlibs so we can potentially catch any library open errors
-        unsafe { luaL_openlibs(L) }
+        unsafe {
+            luaL_openlibs(L);
+            luaJIT_openlibs(L); // luajit-sys extension to open jitlibs
             0
         }
+    }
 
     /// Creates a new empty thread (coroutine) associated with this state.
     pub fn new_thread(&self) -> Self {
@@ -613,7 +615,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_settop`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if `n` is negative.
     pub fn resize(&mut self, n: c_int) {
@@ -632,7 +634,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_checkstack`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if `n` is negative or reallocation fails.
     pub fn ensure(&self, n: c_int) {
@@ -645,7 +647,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_pop`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if there are less than `n` values on the stack.
     pub fn pop(&mut self, n: c_int) {
@@ -660,7 +662,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_insert`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the stack is empty or the index `idx` is invalid.
     pub fn pop_insert(&mut self, idx: c_int) {
@@ -677,7 +679,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_replace`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the stack is empty or the index `idx` is invalid.
     pub fn pop_replace(&mut self, idx: c_int) {
@@ -720,7 +722,7 @@ impl Stack {
 
     /// Handle for the value at index `idx`.
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the index `idx` is invalid.
     pub fn slot<'s>(&'s self, idx: c_int) -> Slot<'s> {
@@ -758,7 +760,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_pushcclosure`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the given function pointer is null.
     pub fn push_function_raw(&mut self, f: lua_CFunction, upvals: c_int) {
@@ -774,7 +776,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_rawget`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the value at index `idx` is not a table.
     pub fn get(&mut self, idx: c_int) {
@@ -794,7 +796,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_rawgeti`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the value at index `idx` is not a table.
     pub fn geti(&mut self, idx: c_int, n: c_int) {
@@ -816,7 +818,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_rawset`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the value at index `idx` is not a table.
     pub fn set(&mut self, idx: c_int) {
@@ -838,7 +840,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_rawseti`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the value at index `idx` is not a table.
     pub fn seti(&mut self, idx: c_int, n: c_int) {
@@ -863,7 +865,7 @@ impl Stack {
     ///
     /// Equivalent to `table.pack(...)`.
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if `n` is negative, there are not enough values on the stack, or the value at index
     /// `idx` is not a table.
@@ -899,7 +901,7 @@ impl Stack {
     ///
     /// Equivalent to `table.unpack(list, i, j)`.
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the value at index `idx` is not a table.
     pub fn unpack(&mut self, idx: c_int, i: c_int, j: Option<c_int>) -> c_int {
@@ -930,6 +932,21 @@ impl Stack {
         n
     }
 
+    /// Pushes the result of a Lua `require(...)` call onto the stack.
+    ///
+    /// Any return values from the library `name` are pushed. Lua libraries are allowed to return
+    /// multiple values. If `nret` is not [`LUA_MULTRET`], then the number of return values pushed
+    /// will be exactly `nret`, filling with nils if necessary. The number values pushed to the
+    /// stack is returned.
+    ///
+    /// Equivalent to `require(name)`.
+    pub fn require(&mut self, name: impl AsRef<[u8]>, nret: c_int) -> Result<c_int> {
+        self.push("require");
+        self.get(LUA_GLOBALSINDEX);
+        self.push(name.as_ref());
+        self.call(1, nret)
+    }
+
     /// Pushes the given chunk as a function at the top of the stack.
     ///
     /// Equivalent to [`lua_loadx`].
@@ -990,7 +1007,7 @@ impl Stack {
     ///
     /// Equivalent to `string.dump(f, mode)`.
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if the value at index `idx` is not a function.
     pub fn dump(&self, idx: c_int, mode: DumpMode) -> Result<BString> {
@@ -1020,7 +1037,7 @@ impl Stack {
     /// Equivalent to calling [`load`](Self::load) on the chunk and then [`call`](Self::call) on the
     /// loaded function.
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if there are not enough values on the stack or thread status is invalid.
     pub fn eval(&mut self, chunk: &Chunk, narg: c_int, nret: c_int) -> Result<c_int> {
@@ -1039,14 +1056,14 @@ impl Stack {
     /// the index `top - narg` (i.e. the function is pushed first and then `narg` values as
     /// arguments). All arguments and the function are popped from the stack and then any return
     /// values are pushed. If `nret` is not [`LUA_MULTRET`], then the number of return values pushed
-    /// will be exactly `nret`, filling with nils if necessary. Finally, the number of returned
-    /// values pushed to the stack is returned.
+    /// will be exactly `nret`, filling with nils if necessary. Finally, the number of values pushed
+    /// to the stack is returned.
     ///
     /// The current thread status must not be suspended or dead.
     ///
     /// Equivalent to [`lua_pcall`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if there are not enough values on the stack, the function to call is not on the
     /// stack, or thread status is invalid.
@@ -1096,8 +1113,8 @@ impl Stack {
     /// the index `top - narg` (i.e. the function is pushed first and then `narg` values as
     /// arguments). All arguments and the function are popped from the stack and then any return
     /// values are pushed. If `nret` is not [`LUA_MULTRET`], then the number of return values pushed
-    /// will be exactly `nret`, filling with nils if necessary. Finally, the number of returned
-    /// values pushed to the stack is returned.
+    /// will be exactly `nret`, filling with nils if necessary. Finally, the number values pushed to
+    /// the stack is returned.
     ///
     /// If the thread yields a Rust [`Future`] value, then it will be polled to completion before
     /// the thread is resumed with the output of the [`Future`] as the argument. If the thread
@@ -1108,7 +1125,7 @@ impl Stack {
     /// Equivalent to multiple calls to [`lua_resume`] until the thread completes with a normal
     /// result.
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if there are not enough values on the stack, the function to call is not on the
     /// stack, or thread status is invalid.
@@ -1172,7 +1189,7 @@ impl Stack {
     ///
     /// Equivalent to [`lua_resume`].
     ///
-    /// # Panic
+    /// # Panics
     ///
     /// Panics if there are not enough values on the stack, the function to call is not on the
     /// stack, or thread status is invalid.

src/lib.rs

@@ -0,0 +1,2 @@
+pub use lb::fs;
+pub use lb::net;

src/main.rs

@@ -1,9 +1,8 @@
 use clap::Parser;
-use lb_core::{GlobalState, PrettyError};
 use mimalloc::MiMalloc;
 use owo_colors::OwoColorize;
-use std::{backtrace::Backtrace, net::SocketAddr, num::NonZero, panic, thread};
-use tokio::{runtime, task::LocalSet};
+use std::{backtrace::Backtrace, fmt::Display, net::SocketAddr, num::NonZero, panic, thread};
+use sysexits::ExitCode;
 
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
@@ -21,13 +20,18 @@ fn panic_cb(panic: &panic::PanicHookInfo) {
     };
 
     eprint!(
-        "{}",
-        PrettyError::new(msg)
-            .with_trace(trace)
-            .prepend(format_args!(
-                "thread '{}' panicked at {location}",
+        "{}:\n{trace}",
+        format_args!(
+            "thread '{}' panicked at {location}: {msg}",
             thread::current().name().unwrap_or("<unnamed>")
-            ))
+        )
+        .red()
+    );
+
+    eprintln!(
+        "{}",
+        "This is a bug in luby. Please kindly report this at https://git.lua.re/luaneko/luby."
+            .yellow()
     );
 }
 
@@ -35,25 +39,29 @@ fn panic_cb(panic: &panic::PanicHookInfo) {
 struct Args {
     /// Paths to scripts to execute.
     #[clap(value_name = "SCRIPTS")]
-    paths: Vec<String>,
+    path: Vec<String>,
 
     /// Strings to execute.
     #[clap(long, short = 'e', value_name = "CHUNK")]
-    evals: Vec<String>,
+    eval: Vec<String>,
 
     /// Libraries to require on startup.
     #[clap(long, short = 'l', value_name = "NAME")]
-    libs: Vec<String>,
+    lib: Vec<String>,
 
     /// Console log level.
     #[clap(long, value_name = "LEVEL", default_value = "debug")]
-    log_level: tracing::Level,
+    log: tracing::Level,
 
-    /// Number of runtime worker threads.
+    /// LuaJIT control commands.
+    #[clap(long, short = 'j', value_name = "CMD=FLAGS")]
+    jit: Vec<String>,
+
+    /// Number of tokio worker threads.
     #[clap(long, value_name = "THREADS", default_value_t = Self::threads())]
     threads: NonZero<usize>,
 
-    /// Number of runtime blocking threads.
+    /// Number of tokio blocking threads.
     #[clap(long, value_name = "THREADS", default_value_t = Self::blocking_threads())]
     blocking_threads: NonZero<usize>,
 
@@ -62,7 +70,12 @@ struct Args {
     enable_console: bool,
 
     /// tokio-console publish address.
-    #[clap(long, value_name = "ADDRESS", default_value = "127.0.0.1:6669")]
+    #[clap(
+        long,
+        value_name = "ADDRESS",
+        default_value = "127.0.0.1:6669",
+        requires = "enable_console"
+    )]
     console_addr: SocketAddr,
 }
 
@@ -76,28 +89,38 @@ impl Args {
     }
 }
 
-fn main() {
+fn exit_err<T, E: Display>(code: ExitCode) -> impl FnOnce(E) -> T {
+    move |err| {
+        eprintln!("{}", err.red());
+        code.exit()
+    }
+}
+
+fn main() -> Result<(), ExitCode> {
     panic::set_hook(Box::new(panic_cb));
 
     let args = Args::parse();
     init_logger(&args);
-    let runtime = init_runtime(&args);
-    GlobalState::set(init_vm(&args));
 
-    let main = LocalSet::new();
-    main.spawn_local(run(args));
-    runtime.block_on(main);
+    let tokio = init_tokio(&args);
+    let lua = init_lua(&args);
+    let main = lua.spawn(async |s| main_async(args, s).await);
+
+    tokio.block_on(async {
+        lua.await;
+        main.await.unwrap()
+    })
 }
 
 fn init_logger(args: &Args) {
     use tracing::level_filters::LevelFilter;
     use tracing_subscriber::{Layer, util::*};
 
-    let console = tracing_subscriber::fmt()
+    let log = tracing_subscriber::fmt()
         .compact()
         .with_env_filter(
             tracing_subscriber::EnvFilter::builder()
-                .with_default_directive(LevelFilter::from(args.log_level).into())
+                .with_default_directive(LevelFilter::from(args.log).into())
                 .from_env_lossy(),
         )
         .with_file(false)
@@ -110,59 +133,93 @@ fn init_logger(args: &Args) {
             .with_default_env()
             .server_addr(args.console_addr)
             .spawn()
-            .with_subscriber(console)
+            .with_subscriber(log)
             .init()
     } else {
-        console.init()
+        log.init()
     }
 }
 
-fn init_runtime(args: &Args) -> runtime::Runtime {
-    if args.threads.get() == 1 {
-        runtime::Builder::new_current_thread()
-    } else {
-        runtime::Builder::new_multi_thread()
+fn init_tokio(args: &Args) -> tokio::runtime::Runtime {
+    let mut rt = match args.threads.get() {
+        1 => tokio::runtime::Builder::new_current_thread(),
+        n => {
+            let mut rt = tokio::runtime::Builder::new_multi_thread();
+            rt.worker_threads(n - 1);
+            rt
         }
-    .enable_all()
-    .thread_name("lb")
-    .worker_threads(args.threads.get() - 1)
-    .max_blocking_threads(args.blocking_threads.get())
-    .build()
-    .unwrap_or_else(|err| panic!("failed to initialise runtime: {err}"))
-}
-
-fn init_vm(_args: &Args) -> luajit::State {
-    let mut state =
-        luajit::State::new().unwrap_or_else(|err| panic!("failed to initialise runtime: {err}"));
-
-    let mut registry = luaffi::Registry::new();
-    registry.preload::<lb_core::lb_core>("lb:core");
-
-    println!("{registry}");
-
-    state
-        .load(&luajit::Chunk::new(registry.done()).name("@[luby]"))
-        .and_then(|()| state.call(0, 0))
-        .unwrap_or_else(|err| panic!("failed to load modules: {err}"));
-
-    state
-}
-
-async fn run(args: Args) {
-    let mut state = GlobalState::new_thread();
-    for ref path in args.paths {
-        let chunk = match std::fs::read(path) {
-            Ok(chunk) => chunk,
-            Err(err) => return eprintln!("{}", format!("{path}: {err}").red()),
     };
 
-        if let Err(err) = state.load(&luajit::Chunk::new(chunk).path(path)) {
-            return eprintln!("{}", err.red());
+    rt.enable_all()
+        .thread_name("luby")
+        .max_blocking_threads(args.blocking_threads.get())
+        .build()
+        .unwrap_or_else(exit_err(ExitCode::OsErr))
 }
 
-        match state.call_async(0, 0).await {
-            Ok(_) => {}
-            Err(err) => GlobalState::uncaught_error(err),
+fn init_lua(args: &Args) -> lb::runtime::Runtime {
+    let rt = lb::runtime::Builder::new();
+    let mut rt = rt.build().unwrap_or_else(exit_err(ExitCode::Software));
+
+    for arg in args.jit.iter() {
+        let mut s = rt.guard();
+        if let Some((cmd, flags)) = parse_jitlib_cmd(arg)
+            && let Ok(_) = s.require(format!("jit.{cmd}"), 1)
+        {
+            (s.push("start"), s.get(-2), s.push(flags));
+            s.call(1, 0)
+        } else {
+            s.require("jit", 1).unwrap();
+            match arg.as_str() {
+                cmd @ ("on" | "off" | "flush") => {
+                    (s.push(cmd), s.get(-2));
+                    s.call(0, 0)
+                }
+                arg => {
+                    (s.push("opt"), s.get(-2));
+                    (s.push("start"), s.get(-2), s.push(arg));
+                    s.call(1, 0)
                 }
             }
         }
+        .unwrap_or_else(exit_err(ExitCode::Usage));
+    }
+
+    rt
+}
+
+fn parse_jitlib_cmd(s: &str) -> Option<(&str, &str)> {
+    match s {
+        "p" => Some(("p", "Flspv10")),
+        "v" => Some(("v", "-")),
+        "dump" => Some(("dump", "tirs")),
+        _ => s.split_once('='),
+    }
+}
+
+async fn main_async(args: Args, state: &mut luajit::State) -> Result<(), ExitCode> {
+    for ref path in args.path {
+        let mut s = state.guard();
+        let chunk = match std::fs::read(path) {
+            Ok(chunk) => chunk,
+            Err(err) => {
+                eprintln!("{}", format_args!("{path}: {err}").red());
+                ExitCode::NoInput.exit();
+            }
+        };
+
+        s.load(&luajit::Chunk::new(chunk).path(path))
+            .unwrap_or_else(exit_err(ExitCode::NoInput));
+
+        if let Err(err) = s.call_async(0, 0).await {
+            match err.trace() {
+                Some(trace) => eprintln!("{}\n{trace}", err.red()), // runtime error
+                None => eprintln!("{}", err.red()),
+            }
+
+            ExitCode::DataErr.exit();
+        }
+    }
+
+    Ok(())
+}