[workerd-cxx] rust future lifetimes support (#25)

Futures capture all lifetimes. We need to generate code appropriately in
such a case.

Part of kj::AsyncInputStream implementation effort.

Author: mikea

kj-rs/future.rs

@@ -38,22 +38,22 @@ pub(crate) mod repr {
 
     type DropCallback = unsafe extern "C" fn(fut: *mut c_void);
 
-    type FuturePtr<T> = *mut (dyn Future<Output = Result<T, String>> + Send);
+    type FuturePtr<'a, T> = *mut (dyn Future<Output = Result<T, String>> + Send + 'a);
 
     /// Represents a `dyn Future<Output = Result<T, String>>` + Send.
     #[repr(C)]
-    pub struct RustFuture<T> {
-        pub fut: FuturePtr<T>,
+    pub struct RustFuture<'a, T> {
+        pub fut: FuturePtr<'a, T>,
         pub poll: PollCallback,
         pub drop: DropCallback,
     }
 
-    type InfallibleFuturePtr<T> = *mut (dyn Future<Output = T> + Send);
+    type InfallibleFuturePtr<'a, T> = *mut (dyn Future<Output = T> + Send + 'a);
 
     /// Represents a `dyn Future<Output = T> + Send` where T is not a Result.
     #[repr(C)]
-    pub struct RustInfallibleFuture<T> {
-        pub fut: InfallibleFuturePtr<T>,
+    pub struct RustInfallibleFuture<'a, T> {
+        pub fut: InfallibleFuturePtr<'a, T>,
         pub poll: PollCallback,
         pub drop: DropCallback,
     }
@@ -65,7 +65,7 @@ pub(crate) mod repr {
     assert_eq_size!(RustFuture<()>, [*mut c_void; 4]);
     assert_eq_size!(RustInfallibleFuture<()>, [*mut c_void; 4]);
 
-    impl<T: Unpin> RustFuture<T> {
+    impl<T: Unpin> RustFuture<'_, T> {
         pub(crate) unsafe extern "C" fn poll(
             fut: *mut c_void,
             waker: *const c_void,
@@ -97,7 +97,7 @@ pub(crate) mod repr {
         }
     }
 
-    impl<T: Unpin> RustInfallibleFuture<T> {
+    impl<T: Unpin> RustInfallibleFuture<'_, T> {
         pub(crate) unsafe extern "C" fn poll(
             fut: *mut c_void,
             waker: *const c_void,
@@ -126,19 +126,19 @@ pub(crate) mod repr {
     }
 
     #[must_use]
-    pub fn future<T: Unpin>(
-        fut: Pin<Box<dyn Future<Output = Result<T, String>> + Send>>,
-    ) -> RustFuture<T> {
+    pub fn future<'a, T: Unpin>(
+        fut: Pin<Box<dyn Future<Output = Result<T, String>> + Send + 'a>>,
+    ) -> RustFuture<'a, T> {
         let fut = Box::into_raw(unsafe { Pin::into_inner_unchecked(fut) });
         let poll = RustFuture::<T>::poll;
         let drop = RustFuture::<T>::drop_in_place;
         RustFuture { fut, poll, drop }
     }
 
     #[must_use]
-    pub fn infallible_future<T: Unpin>(
-        fut: Pin<Box<dyn Future<Output = T> + Send>>,
-    ) -> RustInfallibleFuture<T> {
+    pub fn infallible_future<'a, T: Unpin>(
+        fut: Pin<Box<dyn Future<Output = T> + Send + 'a>>,
+    ) -> RustInfallibleFuture<'a, T> {
         let fut = Box::into_raw(unsafe { Pin::into_inner_unchecked(fut) });
         let poll = RustInfallibleFuture::<T>::poll;
         let drop = RustInfallibleFuture::<T>::drop_in_place;

kj-rs/tests/BUILD.bazel

@@ -1,5 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_library")
-load("@rules_rust//rust:defs.bzl", "rust_library")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
 load("//tools/bazel:rust_cxx_bridge.bzl", "rust_cxx_bridge")
 
 # https://bazel.build/configure/windows#clang
@@ -24,6 +24,14 @@ rust_library(
     ],
 )
 
+rust_test(
+    name = "awaitables-rust_test",
+    crate = "awaitables-rust",
+    deps = [
+        ":test-promises",
+    ],
+)
+
 rust_cxx_bridge(
     name = "bridge",
     src = "lib.rs",

kj-rs/tests/lib.rs

@@ -1,3 +1,7 @@
+#![allow(clippy::needless_lifetimes)]
+#![allow(clippy::missing_errors_doc)]
+#![allow(clippy::unused_async)]
+
 mod test_futures;
 
 use test_futures::{
@@ -59,4 +63,17 @@ mod ffi {
         async fn new_awaiting_future_i32() -> Result<()>;
         async fn new_ready_future_i32(value: i32) -> Result<i32>;
     }
+
+    // these are used to check compilation only
+    extern "Rust" {
+
+        async unsafe fn lifetime_arg_void<'a>(buf: &'a [u8]);
+        async unsafe fn lifetime_arg_result<'a>(buf: &'a [u8]) -> Result<()>;
+    }
+}
+
+pub async fn lifetime_arg_void<'a>(_buf: &'a [u8]) {}
+
+pub async fn lifetime_arg_result<'a>(_buf: &'a [u8]) -> Result<()> {
+    Ok(())
 }

macro/src/expand.rs

@@ -1145,10 +1145,17 @@ fn expand_rust_function_shim_impl(
         let ret = if let Type::Future(fut) = ret {
             let span = sig.ret.span();
             let output = &fut.output;
+            let lifetimes: Vec<_> = sig.generics.lifetimes().map(|lt| quote!(#lt)).collect();
+            let lifetimes = if lifetimes.is_empty() {
+                quote!()
+            } else {
+                assert_eq!(lifetimes.len(), 1, "workerd-cxx: expected single lifetime (todo: do we need to support multiple?)");
+                quote!(#(#lifetimes),*, )
+            };
             if fut.throws_tokens.is_some() {
-                quote_spanned!(span=> ::kj_rs::repr::RustFuture::<#output>)
+                quote_spanned!(span=> ::kj_rs::repr::RustFuture::<#lifetimes #output>)
             } else {
-                quote_spanned!(span=> ::kj_rs::repr::RustInfallibleFuture::<#output>)
+                quote_spanned!(span=> ::kj_rs::repr::RustInfallibleFuture::<#lifetimes #output>)
             }
         } else {
             expand_extern_type(ret, types, false)
@@ -1245,10 +1252,17 @@ fn expand_rust_function_shim_super(
         quote!(-> #result_begin #result_end)
     } else if let Some(Type::Future(fut)) = &sig.ret {
         let output = &fut.output;
+        let lifetimes: Vec<_> = sig.generics.lifetimes().map(|lt| quote!(#lt)).collect();
+        let lifetimes = if lifetimes.is_empty() {
+            quote!()
+        } else {
+            quote!( + #(#lifetimes)+* )
+        };
+        
         if fut.throws_tokens.is_some() {
-            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = ::std::result::Result<#output, String>> + Send>>)
+            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = ::std::result::Result<#output, String>> + Send #lifetimes>>)
         } else {
-            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = #output> + Send>>)
+            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = #output> + Send #lifetimes>>)
         }
     } else {
         expand_return_type(&sig.ret)