[workerd-cxx] Add kj::Maybe type to kj-rs

gen/src/write.rs

@@ -233,7 +233,7 @@ fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) {
             Type::SliceRef(_) => out.builtin.rust_slice = true,
             Type::Array(_) => out.include.array = true,
             Type::Ref(_) | Type::Void(_) | Type::Ptr(_) => {}
-            Type::Future(_) | Type::Own(_) => out.include.kj_rs = true,
+            Type::Future(_) | Type::Maybe(_) | Type::Own(_) => out.include.kj_rs = true,
         }
     }
 }
@@ -1263,6 +1263,11 @@ fn write_type(out: &mut OutFile, ty: &Type) {
             write_type(out, &ptr.inner);
             write!(out, ">");
         }
+        Type::Maybe(ptr) => {
+            write!(out, "::kj::Maybe<");
+            write_type(out, &ptr.inner);
+            write!(out, ">");
+        }
         Type::CxxVector(ty) => {
             write!(out, "::std::vector<");
             write_type(out, &ty.inner);
@@ -1357,6 +1362,7 @@ fn write_space_after_type(out: &mut OutFile, ty: &Type) {
         | Type::SharedPtr(_)
         | Type::WeakPtr(_)
         | Type::Str(_)
+        | Type::Maybe(_)
         | Type::CxxVector(_)
         | Type::RustVec(_)
         | Type::SliceRef(_)
@@ -1431,6 +1437,7 @@ fn write_generic_instantiations(out: &mut OutFile) {
             ImplKey::RustVec(ident) => write_rust_vec_extern(out, ident),
             ImplKey::UniquePtr(ident) => write_unique_ptr(out, ident),
             ImplKey::Own(ident) => write_kj_own(out, ident),
+            ImplKey::Maybe(ident) => write_kj_maybe(out, ident),
             ImplKey::SharedPtr(ident) => write_shared_ptr(out, ident),
             ImplKey::WeakPtr(ident) => write_weak_ptr(out, ident),
             ImplKey::CxxVector(ident) => write_cxx_vector(out, ident),
@@ -1669,6 +1676,17 @@ fn write_kj_own(out: &mut OutFile, key: NamedImplKey) {
     );
 }
 
+// Writes static assertions for Maybe
+fn write_kj_maybe(out: &mut OutFile, key: NamedImplKey) {
+    let ident = key.rust;
+    let resolve = out.types.resolve(ident);
+    let inner = resolve.name.to_fully_qualified();
+
+    out.include.utility = true;
+    out.include.kj_rs = true;
+    writeln!(out, "static_assert(!::std::is_pointer<{}>::value, \"Maybe<T*> is not supported in workerd-cxx\");", inner);
+}
+
 fn write_unique_ptr(out: &mut OutFile, key: NamedImplKey) {
     let ty = UniquePtr::Ident(key.rust);
     write_unique_ptr_common(out, ty);

kj-rs/lib.rs

@@ -4,6 +4,7 @@ use awaiter::WakerRef;
 pub use crate::ffi::KjWaker;
 pub use awaiter::PromiseAwaiter;
 pub use future::FuturePollStatus;
+pub use maybe::repr::Maybe;
 pub use own::repr::Own;
 pub use promise::KjPromise;
 pub use promise::KjPromiseNodeImpl;
@@ -13,12 +14,14 @@ pub use promise::new_callbacks_promise_future;
 
 mod awaiter;
 mod future;
+pub mod maybe;
 mod own;
 mod promise;
 mod waker;
 
 pub mod repr {
     pub use crate::future::repr::*;
+    pub use crate::maybe::repr::*;
     pub use crate::own::repr::*;
 }
 

kj-rs/maybe.rs

@@ -0,0 +1,273 @@
+use repr::Maybe;
+use std::mem::MaybeUninit;
+
+/// # Safety
+/// This trait should only be implemented in `workerd-cxx` on types
+/// which contain a specialization of `kj::Maybe` that needs to be represented in
+/// Rust.
+unsafe trait HasNiche: Sized {
+    fn is_niche(value: &MaybeUninit<Self>) -> bool;
+}
+
+// In Rust, references are not allowed to be null, so a null `MaybeUninit<&T>` is a niche
+unsafe impl<T> HasNiche for &T {
+    fn is_niche(value: &MaybeUninit<&T>) -> bool {
+        unsafe {
+            // This is to avoid potentially zero-initalizing a reference, which is always undefined behavior
+            std::mem::transmute_copy::<MaybeUninit<&T>, MaybeUninit<*const T>>(value)
+                .assume_init()
+                .is_null()
+        }
+    }
+}
+
+unsafe impl<T> HasNiche for &mut T {
+    fn is_niche(value: &MaybeUninit<&mut T>) -> bool {
+        unsafe {
+            // This is to avoid potentially zero-initalizing a reference, which is always undefined behavior
+            std::mem::transmute_copy::<MaybeUninit<&mut T>, MaybeUninit<*mut T>>(value)
+                .assume_init()
+                .is_null()
+        }
+    }
+}
+
+// In `kj`, `kj::Own<T>` are considered `none` in a `Maybe` if the pointer is null
+unsafe impl<T> HasNiche for crate::repr::Own<T> {
+    fn is_niche(value: &MaybeUninit<crate::repr::Own<T>>) -> bool {
+        unsafe { value.assume_init_ref().as_ptr().is_null() }
+    }
+}
+
+/// Trait that is used as the bounds for what can be in a Maybe
+///
+/// # Safety
+/// This trait should only be implemented from macro expansion and should
+/// never be manually implemented.
+pub unsafe trait MaybeItem: Sized {
+    type Discriminant: Copy;
+    const NONE: Maybe<Self>;
+    fn is_some(value: &Maybe<Self>) -> bool;
+    fn is_none(value: &Maybe<Self>) -> bool;
+    fn some(value: Self) -> Maybe<Self>;
+    fn from_option(value: Option<Self>) -> Maybe<Self> {
+        match value {
+            None => Self::NONE,
+            Some(val) => Self::some(val),
+        }
+    }
+    fn drop_in_place(value: &mut Maybe<Self>) {
+        if <Self as MaybeItem>::is_some(value) {
+            unsafe {
+                value.some.assume_init_drop();
+            }
+        }
+    }
+}
+
+/// Macro to implement [`MaybeItem`] for `T` which implment [`HasNiche`]
+macro_rules! impl_maybe_item_for_has_niche {
+    ($ty:ty) => {
+        unsafe impl<T> MaybeItem for $ty {
+            type Discriminant = ();
+
+            fn is_some(value: &Maybe<Self>) -> bool {
+                !<$ty as HasNiche>::is_niche(&value.some)
+            }
+
+            fn is_none(value: &Maybe<Self>) -> bool {
+                <$ty as HasNiche>::is_niche(&value.some)
+            }
+
+            const NONE: Maybe<Self> = {
+                Maybe {
+                    is_set: (),
+                    some: MaybeUninit::zeroed(),
+                }
+            };
+
+            fn some(value: Self) -> Maybe<Self> {
+                Maybe {
+                    is_set: (),
+                    some: MaybeUninit::new(value)
+                }
+            }
+        }
+    };
+    ($ty:ty, $($tail:ty),+) => {
+        impl_maybe_item_for_has_niche!($ty);
+        impl_maybe_item_for_has_niche!($($tail),*);
+    };
+}
+
+/// Macro to implement [`MaybeItem`] for primitives
+macro_rules! impl_maybe_item_for_primitive {
+    ($ty:ty) => {
+        unsafe impl MaybeItem for $ty {
+            type Discriminant = bool;
+
+            fn is_some(value: &Maybe<Self>) -> bool {
+                value.is_set
+            }
+
+            fn is_none(value: &Maybe<Self>) -> bool {
+                !value.is_set
+            }
+
+            const NONE: Maybe<Self> = {
+                Maybe {
+                    is_set: false,
+                    some: MaybeUninit::uninit(),
+                }
+            };
+
+            fn some(value: Self) -> Maybe<Self> {
+                Maybe {
+                    is_set: true,
+                    some: MaybeUninit::new(value)
+                }
+            }
+        }
+    };
+    ($ty:ty, $($tail:ty),+) => {
+        impl_maybe_item_for_primitive!($ty);
+        impl_maybe_item_for_primitive!($($tail),*);
+    };
+}
+
+impl_maybe_item_for_has_niche!(crate::Own<T>, &T, &mut T);
+impl_maybe_item_for_primitive!(
+    u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64, bool
+);
+
+pub(crate) mod repr {
+    use super::MaybeItem;
+    use static_assertions::assert_eq_size;
+    use std::fmt::{Debug, Display};
+    use std::mem::MaybeUninit;
+
+    /// A [`Maybe`] represents bindings to the `kj::Maybe` class.
+    /// It is an optional type, but represented using a struct, for alignment with kj.
+    ///
+    /// # Layout
+    /// In kj, `Maybe` has 3 specializations, one without niche value optimization, and
+    /// two with it. In order to maintain an identical layout in Rust, we include an associated type
+    /// in the [`MaybeItem`] trait, which determines the discriminant of the `Maybe<T: MaybeItem>`.
+    ///
+    /// ## Niche Value Optimization
+    /// This discriminant is used in tandem with the [`crate::maybe::HasNiche`] to implement
+    /// [`MaybeItem`] properly for values which have a niche, which use a discriminant of [`()`],
+    /// the unit type. All other types use [`bool`].
+    #[repr(C)]
+    pub struct Maybe<T: MaybeItem> {
+        pub(super) is_set: T::Discriminant,
+        pub(super) some: MaybeUninit<T>,
+    }
+
+    assert_eq_size!(Maybe<isize>, [usize; 2]);
+    assert_eq_size!(Maybe<&isize>, usize);
+    assert_eq_size!(Maybe<crate::Own<isize>>, [usize; 2]);
+
+    impl<T: MaybeItem> Maybe<T> {
+        /// # Safety
+        /// This function shouldn't be used except by macro generation.
+        pub unsafe fn is_set(&self) -> T::Discriminant {
+            self.is_set
+        }
+
+        /// # Safety
+        /// This function shouldn't be used except by macro generation.
+        pub const unsafe fn from_parts_unchecked(
+            is_set: T::Discriminant,
+            some: MaybeUninit<T>,
+        ) -> Maybe<T> {
+            Maybe { is_set, some }
+        }
+
+        pub fn is_some(&self) -> bool {
+            T::is_some(self)
+        }
+
+        pub fn is_none(&self) -> bool {
+            T::is_none(self)
+        }
+
+        // # CONSTRUCTORS
+        // These emulate Rust's enum api, which offers constructors for each variant.
+        // This mean matching cases, syntax, and behavior.
+        // The only place this may be an issue is pattern matching, which will not work,
+        // but should produce an error.
+        //
+        // The following fails to compile:
+        // ```rust,compile_fail
+        // match maybe {
+        //     Maybe::Some(_) => ...,
+        //     Maybe::None => ...,
+        // }
+        // ```
+
+        /// The [`Maybe::Some`] function serves the same purpose as an enum constructor.
+        ///
+        /// Constructing a `Maybe<T>::Some(val)` should only be possible with a valid
+        /// instance of `T` from Rust.
+        #[allow(non_snake_case)]
+        pub fn Some(value: T) -> Maybe<T> {
+            T::some(value)
+        }
+
+        /// The [`Maybe::None`] functions as a constructor for the none variant. It uses
+        /// a `const` instead of a function to match syntax with normal Rust enums.
+        ///
+        /// Constructing a `Maybe<T>::None` variant should always be possible from Rust.
+        #[allow(non_upper_case_globals, dead_code)]
+        pub const None: Maybe<T> = T::NONE;
+    }
+
+    impl<T: MaybeItem> From<Maybe<T>> for Option<T> {
+        fn from(value: Maybe<T>) -> Self {
+            if value.is_some() {
+                // We can't move out of value so we copy it and forget it in
+                // order to perform a "manual" move out of value
+                let ret = unsafe { Some(value.some.assume_init_read()) };
+                std::mem::forget(value);
+                ret
+            } else {
+                None
+            }
+        }
+    }
+
+    impl<T: MaybeItem> From<Option<T>> for Maybe<T> {
+        fn from(value: Option<T>) -> Self {
+            <T as MaybeItem>::from_option(value)
+        }
+    }
+
+    impl<T: MaybeItem + Debug> Debug for Maybe<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            if self.is_none() {
+                write!(f, "Maybe::None")
+            } else {
+                write!(f, "Maybe::Some({:?})", unsafe {
+                    self.some.assume_init_ref()
+                })
+            }
+        }
+    }
+
+    impl<T: MaybeItem + Display> Display for Maybe<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            if self.is_none() {
+                write!(f, "Maybe::None")
+            } else {
+                write!(f, "Maybe::Some({})", unsafe { self.some.assume_init_ref() })
+            }
+        }
+    }
+
+    impl<T: MaybeItem> Drop for Maybe<T> {
+        fn drop(&mut self) {
+            T::drop_in_place(self);
+        }
+    }
+}