Add CxxException to wrap a C++ exception

The exception object can be passed as a pointer via `CxxException`
error through Rust frames.

A method to create the default message-based `rust::Error` and to drop
and clone the exception are provided.

Author: schreter

src/cxx.cc

@@ -454,10 +454,57 @@ static const char *errorCopy(const char *ptr, std::size_t len) {
   return copy;
 }
 
+namespace {
+template <>
+class impl<Error> final {
+public:
+  static Error error_copy(const char *ptr, std::size_t len) noexcept {
+    Error error;
+    error.msg = errorCopy(ptr, len);
+    error.len = len;
+    return error;
+  }
+};
+} // namespace
+
+// Ensure statically that `std::exception_ptr` is really a pointer.
+static_assert(sizeof(std::exception_ptr) == sizeof(void *),
+              "Unsupported std::exception_ptr size");
+static_assert(alignof(std::exception_ptr) == alignof(void *),
+              "Unsupported std::exception_ptr alignment");
+
 extern "C" {
 const char *cxxbridge1$error(const char *ptr, std::size_t len) noexcept {
   return errorCopy(ptr, len);
 }
+
+void *cxxbridge1$default_exception(const char *ptr, std::size_t len) noexcept {
+  // Construct an `std::exception_ptr` for the default `rust::Error` in the
+  // space provided by the pointer itself (placement new).
+  //
+  // The `std::exception_ptr` itself is just a pointer, so this effectively
+  // converts it to the pointer.
+  void *eptr;
+  new (&eptr) std::exception_ptr(
+      std::make_exception_ptr(impl<Error>::error_copy(ptr, len)));
+  return eptr;
+}
+
+void cxxbridge1$drop_exception(char *ptr) noexcept {
+  // Implement the `drop` for `CxxException` on the Rust side, which is just a
+  // pointer to the exception stored in `std::exception_ptr`.
+  auto eptr = std::move(*reinterpret_cast<std::exception_ptr *>(&ptr));
+  // eptr goes out of scope and deallocates `std::exception_ptr`.
+}
+
+void *cxxbridge1$clone_exception(const char *ptr) noexcept {
+  // Implement the `clone` for `CxxException` on the Rust side, which is just a
+  // pointer to the exception stored in `std::exception_ptr`.
+  void *eptr;
+  new (&eptr) std::exception_ptr(
+      *reinterpret_cast<const std::exception_ptr *const>(&ptr));
+  return eptr;
+}
 } // extern "C"
 
 Error::Error(const Error &other)

src/result.rs

@@ -17,6 +17,63 @@ pub struct PtrLen {
     pub len: usize,
 }
 
+extern "C" {
+    /// Helper to construct the default exception from the error message.
+    #[link_name = "cxxbridge1$default_exception"]
+    fn default_exception(ptr: *const u8, len: usize) -> *mut u8;
+    /// Helper to clone the instance of `std::exception_ptr` on the C++ side.
+    #[link_name = "cxxbridge1$clone_exception"]
+    fn clone_exception(ptr: *const u8) -> *mut u8;
+    /// Helper to drop the instance of `std::exception_ptr` on the C++ side.
+    #[link_name = "cxxbridge1$drop_exception"]
+    fn drop_exception(ptr: *mut u8);
+}
+
+/// C++ exception containing `std::exception_ptr`.
+///
+/// This object is the Rust wrapper over `std::exception_ptr`, so it owns the exception pointer.
+/// I.e., the exception is either referenced by a `std::exception_ptr` on the C++ side or the
+/// reference is moved to this object on the Rust side.
+#[repr(C)]
+#[must_use]
+pub struct CxxException(NonNull<u8>);
+
+impl CxxException {
+    /// Construct the default `rust::Error` exception from the specified `exc_text`.
+    pub fn new_default(exc_text: &str) -> Self {
+        let exception_ptr = unsafe {
+            default_exception(exc_text.as_ptr(), exc_text.len())
+        };
+        CxxException(
+            NonNull::new(exception_ptr)
+            .expect("Exception conversion returned a null pointer")
+        )
+    }
+}
+
+impl Clone for CxxException {
+    fn clone(&self) -> Self {
+        let clone_ptr = unsafe { clone_exception(self.0.as_ptr()) };
+        Self(
+            NonNull::new(clone_ptr)
+            .expect("Exception cloning returned a null pointer")
+        )
+    }
+}
+
+impl Drop for CxxException {
+    fn drop(&mut self) {
+        unsafe { drop_exception(self.0.as_ptr()) };
+    }
+}
+
+// SAFETY: This is safe, since the C++ exception referenced by `std::exception_ptr`
+// is not thread-local.
+unsafe impl Send for CxxException {}
+// SAFETY: This is safe, since the C++ exception referenced by `std::exception_ptr`
+// can be shared across threads read-only.
+unsafe impl Sync for CxxException {}
+
 #[repr(C)]
 pub union Result {
     err: PtrLen,