update async futures support to use ToKjException as well (#61)

Author: mikea

kj-rs/future.h

@@ -40,11 +40,14 @@ class FuturePoller {
     switch (pollFunc(&result)) {
       case ::kj_rs::FuturePollStatus::Pending:
         return;
-      case ::kj_rs::FuturePollStatus::Complete:
-        output.value = toResult();
+      case ::kj_rs::FuturePollStatus::Complete: {
+        output.value = kj::mv(result);
+        kj::dtor(result);
         return;
+      }
       case ::kj_rs::FuturePollStatus::Error: {
-        output.addException(toException());
+        output.addException(kj::mv(*error));
+        delete error;
         return;
       }
     }
@@ -53,22 +56,9 @@ class FuturePoller {
   }
 
  private:
-  T toResult() {
-    auto ret = kj::mv(result);
-    kj::dtor(result);
-    return ret;
-  }
-
-  kj::Exception toException() {
-    auto description = ::kj::ArrayPtr<const char>(error.data(), error.size());
-    auto exception = KJ_EXCEPTION(FAILED, kj::str(description));
-    kj::dtor(error);
-    return exception;
-  }
-
   union {
     T result;
-    ::rust::String error;
+    kj::Exception* error;
   };
 };
 

kj-rs/future.rs

@@ -38,9 +38,9 @@ pub(crate) mod repr {
 
     type DropCallback = unsafe extern "C" fn(fut: *mut c_void);
 
-    type FuturePtr<'a, T> = *mut (dyn Future<Output = Result<T, String>> + 'a);
+    type FuturePtr<'a, T> = *mut (dyn Future<Output = Result<T, cxx::KjException>> + 'a);
 
-    /// Represents a `dyn Future<Output = Result<T, String>>`.
+    /// Represents a `dyn Future<Output = Result<T, cxx::KjException>>`.
     #[repr(C)]
     pub struct RustFuture<'a, T> {
         pub fut: FuturePtr<'a, T>,
@@ -82,7 +82,12 @@ pub(crate) mod repr {
                     FuturePollStatus::Complete
                 }
                 Poll::Ready(Err(error)) => {
-                    unsafe { std::ptr::write(ret.cast::<String>(), error.to_string()) };
+                    unsafe {
+                        std::ptr::write(
+                            ret.cast::<*mut c_void>(),
+                            error.into_raw().as_ptr().cast(),
+                        );
+                    };
                     FuturePollStatus::Error
                 }
                 Poll::Pending => FuturePollStatus::Pending,
@@ -127,7 +132,7 @@ pub(crate) mod repr {
 
     #[must_use]
     pub fn future<'a, T: Unpin>(
-        fut: Pin<Box<dyn Future<Output = Result<T, String>> + 'a>>,
+        fut: Pin<Box<dyn Future<Output = Result<T, cxx::KjException>> + 'a>>,
     ) -> RustFuture<'a, T> {
         let fut = Box::into_raw(unsafe { Pin::into_inner_unchecked(fut) });
         let poll = RustFuture::<T>::poll;

kj-rs/tests/awaitables-cc-test.c++

@@ -118,6 +118,23 @@ KJ_TEST("co_awaiting a fallible future from C++ can throw") {
   }().wait(waitScope);
 }
 
+KJ_TEST("co_awaiting a KjError future from C++ can throw with proper exception type") {
+  kj::EventLoop loop;
+  kj::WaitScope waitScope(loop);
+
+  []() -> kj::Promise<void> {
+    kj::Maybe<kj::Exception> maybeException;
+    try {
+      co_await new_kj_errored_future_void();
+    } catch (...) {
+      maybeException = kj::getCaughtExceptionAsKj();
+    }
+    auto& exception = KJ_ASSERT_NONNULL(maybeException, "should have thrown");
+    KJ_EXPECT(exception.getDescription() == "test error");
+    KJ_EXPECT(exception.getType() == kj::Exception::Type::OVERLOADED);
+  }().wait(waitScope);
+}
+
 KJ_TEST(".awaiting a Promise<T> from Rust can produce an Err Result") {
   kj::EventLoop loop;
   kj::WaitScope waitScope(loop);

kj-rs/tests/lib.rs

@@ -17,9 +17,9 @@ mod test_refcount;
 
 use test_futures::{
     new_awaiting_future_i32, new_error_handling_future_void_infallible, new_errored_future_void,
-    new_layered_ready_future_void, new_naive_select_future_void, new_pending_future_void,
-    new_ready_future_i32, new_ready_future_void, new_threaded_delay_future_void,
-    new_waking_future_void, new_wrapped_waker_future_void,
+    new_kj_errored_future_void, new_layered_ready_future_void, new_naive_select_future_void,
+    new_pending_future_void, new_ready_future_i32, new_ready_future_void,
+    new_threaded_delay_future_void, new_waking_future_void, new_wrapped_waker_future_void,
 };
 
 use test_maybe::{
@@ -265,6 +265,9 @@ mod ffi {
         async fn new_wrapped_waker_future_void() -> Result<()>;
 
         async fn new_errored_future_void() -> Result<()>;
+
+        async fn new_kj_errored_future_void() -> Result<()>;
+
         async fn new_error_handling_future_void_infallible();
 
         async fn new_awaiting_future_i32() -> Result<()>;

kj-rs/tests/test_futures.rs

@@ -210,6 +210,13 @@ pub async fn new_errored_future_void() -> Result<()> {
     Err(std::io::Error::new(std::io::ErrorKind::Other, "test error"))
 }
 
+pub async fn new_kj_errored_future_void() -> std::result::Result<(), cxx::KjError> {
+    Err(cxx::KjError::new(
+        cxx::KjExceptionType::Overloaded,
+        "test error".to_string(),
+    ))
+}
+
 pub async fn new_error_handling_future_void_infallible() {
     let err = crate::ffi::new_errored_promise_void()
         .await

macro/src/expand.rs

@@ -1277,7 +1277,7 @@ fn expand_rust_function_shim_super(
         };
 
         if fut.throws_tokens.is_some() {
-            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = ::std::result::Result<#output, String>> #lifetimes>>)
+            quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = ::std::result::Result<#output, ::cxx::KjException>> #lifetimes>>)
         } else {
             quote!(-> std::pin::Pin<Box<dyn ::std::future::Future<Output = #output> #lifetimes>>)
         }
@@ -1299,7 +1299,7 @@ fn expand_rust_function_shim_super(
 
     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())}))
+            quote_spanned!(span=> Box::pin(async move {#call(#(#vars,)*).await.map_err(|e| ::cxx::IntoKjException::into_kj_exception(e, ::cxx::core::file!(), ::cxx::core::line!()))}))
         } else {
             quote_spanned!(span=> Box::pin(#call(#(#vars,)*)))
         }

src/exception.rs

@@ -1,6 +1,7 @@
 use core::{
     ffi::CStr,
     fmt::{self, Display},
+    mem::ManuallyDrop,
     ptr::NonNull,
 };
 
@@ -215,6 +216,13 @@ impl KjException {
 
         Some(result)
     }
+
+    /// Consumes the exception, returning the raw pointer.
+    /// # Safety
+    /// The caller must ensure that the returned pointer is eventually dropped.
+    pub unsafe fn into_raw(self) -> NonNull<repr::KjException> {
+        ManuallyDrop::new(self).err
+    }
 }
 
 impl Drop for KjException {