[workerd-cxx] rust->c++ future passing (#19)

mikea · web-flow · commit 3fd6661daa46 · 2025-06-03T08:20:58.000-07:00
diff --git a/gen/src/write.rs b/gen/src/write.rs
@@ -941,6 +941,9 @@ fn write_rust_function_decl_impl(
                 }
                 write!(out, "*");
             }
+            Type::Future(_) => {
+                write!(out, "::kj_rs::repr::RustFuture ");
+            }
             ret => write_type_space(out, ret),
         }
         write!(out, "*return$");
@@ -1050,6 +1053,9 @@ fn write_rust_function_shim_impl(
                 }
                 write!(out, "*");
             }
+            Type::Future(_) => {
+                write!(out, "::kj_rs::repr::RustFuture");
+            }
             ret => write_type(out, ret),
         }
         writeln!(out, "> return$;");
diff --git a/macro/src/expand.rs b/macro/src/expand.rs
@@ -14,8 +14,8 @@ use crate::type_id::Crate;
 use crate::{derive, generics};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned, ToTokens};
-use syn::spanned::Spanned;
 use std::mem;
+use syn::spanned::Spanned;
 use syn::{parse_quote, punctuated, Generics, Lifetime, Result, Token};
 
 pub(crate) fn bridge(mut ffi: Module) -> Result<TokenStream> {
@@ -87,7 +87,12 @@ fn expand(ffi: Module, doc: Doc, attrs: OtherAttrs, apis: &[Api], types: &Types)
                 expanded.extend(expand_rust_type_impl(ety));
                 hidden.extend(expand_rust_type_layout(ety, types));
             }
-            Api::RustFunction(efn) => hidden.extend(expand_rust_function_shim(efn, types)),
+            Api::RustFunction(efn) => {
+                if efn.asyncness.is_some() {
+                    // todo!("expand_rust_function_shim\n{}", expand_rust_function_shim(efn, types).to_string());
+                }
+                hidden.extend(expand_rust_function_shim(efn, types));
+            }
             Api::TypeAlias(alias) => {
                 expanded.extend(expand_type_alias(alias));
                 hidden.extend(expand_type_alias_verify(alias, types));
@@ -723,10 +728,10 @@ fn expand_cxx_function_shim(efn: &ExternFn, types: &Types) -> TokenStream {
                         false => quote_spanned!(span=> #call.as_slice::<#inner>()),
                         true => quote_spanned!(span=> #call.as_mut_slice::<#inner>()),
                     }
-                },
+                }
                 Type::Future(_) => {
                     quote_spanned!(span=> ::kj_rs::new_callbacks_promise_future(#call))
-                },
+                }
                 _ => call,
             },
         };
@@ -1115,6 +1120,11 @@ fn expand_rust_function_shim_impl(
             false => Some(quote_spanned!(span=> ::cxx::private::RustSlice::from_ref)),
             true => Some(quote_spanned!(span=> ::cxx::private::RustSlice::from_mut)),
         },
+        Type::Future(fut) => if fut.throws_tokens.is_some() {
+            Some(quote_spanned!(span=> ::kj_rs::repr::future))
+        } else {
+            Some(quote_spanned!(span=> ::kj_rs::repr::infallible_future))
+        },
         _ => None,
     });
 
@@ -1132,7 +1142,17 @@ fn expand_rust_function_shim_impl(
 
     // always indirect return when there's a return value
     let out_param = sig.ret.as_ref().map(|ret| {
-        let ret = expand_extern_type(ret, types, false);
+        let ret = if let Type::Future(fut) = ret {
+            let span = sig.ret.span();
+            let output = &fut.output;
+            if fut.throws_tokens.is_some() {
+                quote_spanned!(span=>::kj_rs::repr::RustFuture::<#output>)
+            } else {
+                quote_spanned!(span=>::kj_rs::repr::RustInfallibleFuture::<#output>)
+            }
+        } else {
+            expand_extern_type(ret, types, false)
+        };
         quote_spanned!(span=> __return: *mut #ret,)
     });
     let out = match sig.ret {
@@ -1223,6 +1243,13 @@ fn expand_rust_function_shim_super(
             quote_spanned!(rangle.span=> ::cxx::core::fmt::Display>)
         };
         quote!(-> #result_begin #result_end)
+    } else if let Some(Type::Future(fut)) = &sig.ret {
+        let output = &fut.output;
+        if fut.throws_tokens.is_some() {
+            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = ::std::result::Result<#output, String>> + Send>>)
+        } else {
+            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = #output> + Send>>)
+        }
     } else {
         expand_return_type(&sig.ret)
     };
@@ -1239,7 +1266,15 @@ fn expand_rust_function_shim_super(
         }
     };
 
-    let mut body = quote_spanned!(span=> #call(#(#vars,)*));
+    let mut body = if let Some(Type::Future(fut)) = &sig.ret {
+        if fut.throws_tokens.is_some() {
+            quote_spanned!(span=> Box::pin(async move {#call(#(#vars,)*).await.map_err(|e| e.to_string())}))
+        } else {
+            quote_spanned!(span=> Box::pin(#call(#(#vars,)*)))
+        }
+    } else {
+        quote_spanned!(span=> #call(#(#vars,)*))
+    };
     let mut allow_unused_unsafe = None;
     if unsafety.is_some() {
         body = quote_spanned!(span=> unsafe { #body });
@@ -1939,8 +1974,8 @@ fn expand_extern_type(ty: &Type, types: &Types, proper: bool) -> TokenStream {
             let rust_slice = Ident::new("RustSlice", ty.bracket.span.join());
             quote_spanned!(span=> ::cxx::private::#rust_slice)
         }
-        Type::Future(ty) => {
-            let span = ty.span();
+        Type::Future(output) => {
+            let span = output.span();
             quote_spanned!(span=> ::kj_rs::KjPromiseNodeImpl)
         }
         _ => quote!(#ty),
diff --git a/syntax/mod.rs b/syntax/mod.rs
@@ -322,6 +322,7 @@ pub(crate) struct Array {
 
 pub(crate) struct Future {
     pub output: Type,
+    pub throws_tokens: Option<(kw::Result, Token![<], Token![>])>,
 }
 
 #[derive(Copy, Clone, PartialEq)]
diff --git a/syntax/parse.rs b/syntax/parse.rs
@@ -18,8 +18,8 @@ use syn::{
     Abi, Attribute, Error, Expr, Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemType,
     GenericArgument, GenericParam, Generics, Ident, ItemEnum, ItemImpl, ItemStruct, Lit, LitStr,
     Pat, PathArguments, Result, ReturnType, Signature as RustSignature, Token, TraitBound,
-    TraitBoundModifier, Type as RustType, TypeArray, TypeBareFn, TypeParamBound,
-    TypePath, TypePtr, TypeReference, Variant as RustVariant, Visibility,
+    TraitBoundModifier, Type as RustType, TypeArray, TypeBareFn, TypeParamBound, TypePath, TypePtr,
+    TypeReference, Variant as RustVariant, Visibility,
 };
 
 pub(crate) mod kw {
@@ -649,13 +649,19 @@ fn parse_extern_fn(
 
     let mut throws_tokens = None;
     let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens)?;
-    let throws = throws_tokens.is_some();
     let asyncness = foreign_fn.sig.asyncness;
-    let ret = if asyncness.is_some() {
-        Some(Type::Future(Box::new(Future{ output: ret.unwrap_or(Type::Void(foreign_fn.sig.fn_token.span)) })))
+    let (ret, throws_tokens) = if asyncness.is_some() {
+        (
+            Some(Type::Future(Box::new(Future {
+                output: ret.unwrap_or(Type::Void(foreign_fn.sig.fn_token.span)),
+                throws_tokens,
+            }))),
+            None,
+        )
     } else {
-        ret
+        (ret, throws_tokens)
     };
+    let throws = throws_tokens.is_some();
     let unsafety = foreign_fn.sig.unsafety;
     let fn_token = foreign_fn.sig.fn_token;
     let inherited_span = unsafety.map_or(fn_token.span, |unsafety| unsafety.span);
diff --git a/tests/kj-rs/lib.rs b/tests/kj-rs/lib.rs
@@ -1,3 +1,8 @@
+#![allow(dead_code)]
+#![allow(clippy::unused_async)]
+
+type Result<T> = std::io::Result<T>;
+
 #[cxx::bridge(namespace = "kj_rs")]
 pub mod ffi {
     struct Shared {
@@ -8,13 +13,35 @@ pub mod ffi {
         include!("tests/kj-rs/tests.h");
 
         async fn c_async_void_fn();
+        async fn c_async_int_fn() -> i64;
+        async fn c_async_struct_fn() -> Shared;
+    }
 
-        // todo
-        // async fn c_async_int_fn() -> i64;
-        // async fn c_async_struct_fn() -> Shared;
+    extern "Rust" {
+        // todo(soon): enable once kj-rs side is landed.
+        //
+        // async fn rust_async_void_fn();
+        // async fn rust_async_int_fn() -> i64;
+
+        // async fn rust_async_void_result_fn() -> Result<()>;
+        // async fn rust_async_int_result_fn() -> Result<i64>;
     }
 }
 
+async fn rust_async_void_fn() {
+}
+
+async fn rust_async_int_fn() -> i64 {
+    42
+}
+
+async fn rust_async_void_result_fn() -> Result<()> {
+    Ok(())
+}
+ 
+async fn rust_async_int_result_fn() -> Result<i64> {
+    Ok(42)
+}
 
 #[cfg(test)]
 mod tests {
@@ -25,7 +52,7 @@ mod tests {
     #[test]
     fn compilation() {
         let _ =  ffi::c_async_void_fn();
-        // let _ =  ffi::c_async_int_fn();
-        // let _ =  ffi::c_async_struct_fn();
+        let _ =  ffi::c_async_int_fn();
+        let _ =  ffi::c_async_struct_fn();
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -941,6 +941,9 @@ fn write_rust_function_decl_impl(`
`941`	`941`	`}`
`942`	`942`	`write!(out, "*");`
`943`	`943`	`}`
	`944`	`+ Type::Future(_) => {`
	`945`	`+ write!(out, "::kj_rs::repr::RustFuture ");`
	`946`	`+ }`
`944`	`947`	`ret => write_type_space(out, ret),`
`945`	`948`	`}`
`946`	`949`	`write!(out, "*return$");`
`@@ -1050,6 +1053,9 @@ fn write_rust_function_shim_impl(`
`1050`	`1053`	`}`
`1051`	`1054`	`write!(out, "*");`
`1052`	`1055`	`}`
	`1056`	`+ Type::Future(_) => {`
	`1057`	`+ write!(out, "::kj_rs::repr::RustFuture");`
	`1058`	`+ }`
`1053`	`1059`	`ret => write_type(out, ret),`
`1054`	`1060`	`}`
`1055`	`1061`	`writeln!(out, "> return$;");`
Original file line number	Diff line number	Diff line change
`@@ -322,6 +322,7 @@ pub(crate) struct Array {`
`322`	`322`
`323`	`323`	`pub(crate) struct Future {`
`324`	`324`	`pub output: Type,`
	`325`	`+ pub throws_tokens: Option<(kw::Result, Token![<], Token![>])>,`
`325`	`326`	`}`
`326`	`327`
`327`	`328`	`#[derive(Copy, Clone, PartialEq)]`