split wit-dylib async feature into -raw and -runtime variations

- `async-runtime`: integrates with `std::future` by way of `wit_bindgen::rt`
- `async-raw`: minimal layer over raw bindings; does not use `std::future` or `wit_bindgen`

Note that these are mutually exclusive; enabling both will result in a compiler
error.

Signed-off-by: Joel Dice <[email protected]>

Author: dicej

crates/wit-dylib/ffi/Cargo.toml

@@ -15,5 +15,6 @@ doctest = false
 wit-bindgen = { workspace = true, optional = true, features = ['async'] }
 
 [features]
-default = ['async']
-async = ['dep:wit-bindgen']
+default = []
+async-raw = []
+async-runtime = ['dep:wit-bindgen']

crates/wit-dylib/ffi/src/lib.rs

@@ -11,6 +11,9 @@
 #![allow(unsafe_code)]
 #![allow(clippy::allow_attributes_without_reason)]
 
+#[cfg(all(feature = "async-runtime", feature = "async-raw"))]
+compile_error!("cannot enable both `async-runtime` and `async-raw` features");
+
 use std::alloc::Layout;
 use std::ptr;
 
@@ -372,17 +375,17 @@ pub trait Interpreter: 'static {
 
     fn export_call(wit: Wit, func: ExportFunction, cx: &mut Self::CallCx<'_>);
 
-    #[cfg(feature = "async")]
+    #[cfg(feature = "async-runtime")]
     fn export_call_async(
         wit: Wit,
         func: ExportFunction,
         cx: Box<Self::CallCx<'static>>,
     ) -> impl std::future::Future<Output = ()>;
 
-    #[cfg(not(feature = "async"))]
+    #[cfg(feature = "async-raw")]
     fn export_async_start(wit: Wit, func: ExportFunction, cx: Box<Self::CallCx<'static>>) -> u32;
 
-    #[cfg(not(feature = "async"))]
+    #[cfg(feature = "async-raw")]
     fn export_async_callback(event0: u32, event1: u32, event2: u32) -> u32;
 
     fn export_finish(cx: Box<Self::CallCx<'_>>, func: ExportFunction) {
@@ -529,7 +532,7 @@ pub trait RawInterpreter: Interpreter {
         unsafe {
             let wit = Wit::from_raw(WIT_T);
             let func = wit.export_func(which);
-            #[cfg(feature = "async")]
+            #[cfg(feature = "async-runtime")]
             {
                 wit_bindgen::rt::async_support::start_task(Self::export_call_async(
                     wit,
@@ -538,21 +541,32 @@ pub trait RawInterpreter: Interpreter {
                 ))
                 .cast_unsigned()
             }
-            #[cfg(not(feature = "async"))]
+            #[cfg(feature = "async-raw")]
             {
                 Self::export_async_start(wit, func, Box::from_raw(cx.cast()))
             }
+            #[cfg(not(any(feature = "async-runtime", feature = "async-raw")))]
+            {
+                _ = func;
+                panic!("no async features enabled")
+            }
         }
     }
 
     unsafe fn raw_export_async_callback(a: u32, b: u32, c: u32, which: usize) -> u32 {
         debug_println!("export_async_callback({a:#x}, {b:#x}, {c:#x}, {which})");
-        #[cfg(feature = "async")]
+        #[cfg(feature = "async-runtime")]
         unsafe {
             wit_bindgen::rt::async_support::callback(a, b, c)
         }
-        #[cfg(not(feature = "async"))]
-        Self::export_async_callback(a, b, c)
+        #[cfg(feature = "async-raw")]
+        {
+            Self::export_async_callback(a, b, c)
+        }
+        #[cfg(not(any(feature = "async-runtime", feature = "async-raw")))]
+        {
+            panic!("no async features enabled")
+        }
     }
 
     unsafe fn raw_export_finish(cx: *mut u8, which: usize) {

crates/wit-dylib/ffi/src/types.rs

@@ -393,7 +393,7 @@ impl ImportFunction {
         }
     }
 
-    #[cfg(not(feature = "async"))]
+    #[cfg(feature = "async-raw")]
     pub unsafe fn call_import_async(&self, cx: &mut impl Call) -> Option<PendingAsyncImportCall> {
         use core::alloc::Layout;
 
@@ -422,12 +422,12 @@ impl ImportFunction {
         }
     }
 
-    #[cfg(not(feature = "async"))]
+    #[cfg(feature = "async-raw")]
     pub unsafe fn lift_import_async_result(&self, cx: &mut impl Call, buffer: *mut u8) {
         unsafe { self.ptr.async_lift_impl.unwrap()((&raw mut *cx).cast(), buffer.cast()) };
     }
 
-    #[cfg(feature = "async")]
+    #[cfg(feature = "async-runtime")]
     pub async fn call_import_async(&self, cx: &mut impl Call) {
         use core::alloc::Layout;
         use wit_bindgen::rt::async_support::Subtask;