[workerd-cxx] unifying KjMaybe and KjOwn names (#63)

I want it to be very explicit that these are kj types.

Author: mikea

gen/src/write.rs

@@ -233,7 +233,11 @@ 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::Maybe(_) | Type::Own(_) | Type::KjRc(_) | Type::KjArc(_) => {
+            Type::Future(_)
+            | Type::KjMaybe(_)
+            | Type::KjOwn(_)
+            | Type::KjRc(_)
+            | Type::KjArc(_) => {
                 out.include.kj_rs = true;
             }
         }
@@ -1039,7 +1043,7 @@ fn write_rust_function_shim_impl(
     writeln!(out, " {{");
     sig.args
         .iter()
-        .filter(|arg| matches!(arg.ty, Type::Own(_)))
+        .filter(|arg| matches!(arg.ty, Type::KjOwn(_)))
         .for_each(|arg_own| {
             writeln!(
                 out,
@@ -1243,7 +1247,7 @@ fn write_type(out: &mut OutFile, ty: &Type) {
             write_type(out, &ptr.inner);
             write!(out, ">");
         }
-        Type::Own(ptr) => {
+        Type::KjOwn(ptr) => {
             write!(out, "::kj::Own<");
             write_type(out, &ptr.inner);
             write!(out, ">");
@@ -1268,7 +1272,7 @@ fn write_type(out: &mut OutFile, ty: &Type) {
             write_type(out, &ptr.inner);
             write!(out, ">");
         }
-        Type::Maybe(ptr) => {
+        Type::KjMaybe(ptr) => {
             write!(out, "::kj::Maybe<");
             write_type(out, &ptr.inner);
             write!(out, ">");
@@ -1363,13 +1367,13 @@ fn write_space_after_type(out: &mut OutFile, ty: &Type) {
         Type::Ident(_)
         | Type::RustBox(_)
         | Type::UniquePtr(_)
-        | Type::Own(_)
+        | Type::KjOwn(_)
         | Type::KjRc(_)
         | Type::KjArc(_)
         | Type::SharedPtr(_)
         | Type::WeakPtr(_)
         | Type::Str(_)
-        | Type::Maybe(_)
+        | Type::KjMaybe(_)
         | Type::CxxVector(_)
         | Type::RustVec(_)
         | Type::SliceRef(_)

kj-rs/lib.rs

@@ -4,8 +4,8 @@ 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 maybe::repr::KjMaybe;
+pub use own::repr::KjOwn;
 pub use promise::KjPromise;
 pub use promise::KjPromiseNodeImpl;
 pub use promise::OwnPromiseNode;

kj-rs/maybe.rs

@@ -1,4 +1,4 @@
-use repr::Maybe;
+use repr::KjMaybe;
 use std::mem::MaybeUninit;
 
 /// # Safety
@@ -18,7 +18,7 @@ use std::mem::MaybeUninit;
 /// `Own`s have a niche where the pointer to the owned data is null. This is
 /// a valid instance of `Own`, but was decided by the `kj` authors to represent
 /// `kj::none`. In Rust, it is guaranteed that an `Own` is nonnull, requiring
-/// `Maybe<Own<T>>` to represent a null `Own`.
+/// `KjMaybe<Own<T>>` to represent a null `Own`.
 ///
 /// Pointers are not optimized in this way, as `null` is a valid and meaningful
 /// instance of a pointer.
@@ -53,42 +53,42 @@ unsafe impl<T> HasNiche for &mut T {
 }
 
 // In `kj`, `kj::Own<T>` are considered `none` in a `Maybe` if the data pointer is null
-unsafe impl<T> HasNiche for crate::repr::Own<T> {
-    fn is_niche(value: *const crate::repr::Own<T>) -> bool {
+unsafe impl<T> HasNiche for crate::repr::KjOwn<T> {
+    fn is_niche(value: *const crate::repr::KjOwn<T>) -> bool {
         unsafe { (*value).as_ptr().is_null() }
     }
 }
 
-/// Trait that is used as the bounds for what can be in a `kj_rs::Maybe`.
+/// Trait that is used as the bounds for what can be in a `kj_rs::KjMaybe`.
 ///
 /// # Safety
 /// This trait should only be implemented from macro expansion and should
 /// never be manually implemented. An unsound implementation of this trait
 /// could result in undefined behavior when passed between languages.
 ///
-/// This trait contains all behavior we need to implement `Maybe<T: MaybeItem>`
+/// This trait contains all behavior we need to implement `KjMaybe<T: MaybeItem>`
 /// for every `T` we use, and additionally determines the type layout of
-/// the `Maybe<T>`. The only information we can know about `T` comes from
+/// the `KjMaybe<T>`. The only information we can know about `T` comes from
 /// this trait, so it must be capable of handling all behavior we want in
-/// `kj_rs::Maybe`.
+/// `kj_rs::KjMaybe`.
 ///
 /// Every function without a default depends on `MaybeItem::Discriminant`
 /// and whether or not `T` implements [`HasNiche`]. Functions with defaults
 /// use those functions to implement shared behavior, and simplfy the actual
-/// `Maybe<T>` implementation.
+/// `KjMaybe<T>` implementation.
 pub unsafe trait MaybeItem: Sized {
     type Discriminant: Copy;
-    const NONE: Maybe<Self>;
-    fn some(value: Self) -> Maybe<Self>;
-    fn is_some(value: &Maybe<Self>) -> bool;
-    fn is_none(value: &Maybe<Self>) -> bool;
-    fn from_option(value: Option<Self>) -> Maybe<Self> {
+    const NONE: KjMaybe<Self>;
+    fn some(value: Self) -> KjMaybe<Self>;
+    fn is_some(value: &KjMaybe<Self>) -> bool;
+    fn is_none(value: &KjMaybe<Self>) -> bool;
+    fn from_option(value: Option<Self>) -> KjMaybe<Self> {
         match value {
             None => <Self as MaybeItem>::NONE,
             Some(val) => <Self as MaybeItem>::some(val),
         }
     }
-    fn drop_in_place(value: &mut Maybe<Self>) {
+    fn drop_in_place(value: &mut KjMaybe<Self>) {
         if <Self as MaybeItem>::is_some(value) {
             unsafe {
                 value.some.assume_init_drop();
@@ -104,23 +104,23 @@ macro_rules! impl_maybe_item_for_has_niche {
         unsafe impl<T> MaybeItem for $ty {
             type Discriminant = ();
 
-            fn is_some(value: &Maybe<Self>) -> bool {
+            fn is_some(value: &KjMaybe<Self>) -> bool {
                 !<$ty as HasNiche>::is_niche(value.some.as_ptr())
             }
 
-            fn is_none(value: &Maybe<Self>) -> bool {
+            fn is_none(value: &KjMaybe<Self>) -> bool {
                 <$ty as HasNiche>::is_niche(value.some.as_ptr())
             }
 
-            const NONE: Maybe<Self> = {
-                Maybe {
+            const NONE: KjMaybe<Self> = {
+                KjMaybe {
                     is_set: (),
                     some: MaybeUninit::zeroed(),
                 }
             };
 
-            fn some(value: Self) -> Maybe<Self> {
-                Maybe {
+            fn some(value: Self) -> KjMaybe<Self> {
+                KjMaybe {
                     is_set: (),
                     some: MaybeUninit::new(value)
                 }
@@ -140,23 +140,23 @@ macro_rules! impl_maybe_item_for_primitive {
         unsafe impl MaybeItem for $ty {
             type Discriminant = bool;
 
-            fn is_some(value: &Maybe<Self>) -> bool {
+            fn is_some(value: &KjMaybe<Self>) -> bool {
                 value.is_set
             }
 
-            fn is_none(value: &Maybe<Self>) -> bool {
+            fn is_none(value: &KjMaybe<Self>) -> bool {
                 !value.is_set
             }
 
-            const NONE: Maybe<Self> = {
-                Maybe {
+            const NONE: KjMaybe<Self> = {
+                KjMaybe {
                     is_set: false,
                     some: MaybeUninit::uninit(),
                 }
             };
 
-            fn some(value: Self) -> Maybe<Self> {
-                Maybe {
+            fn some(value: Self) -> KjMaybe<Self> {
+                KjMaybe {
                     is_set: true,
                     some: MaybeUninit::new(value)
                 }
@@ -169,7 +169,7 @@ macro_rules! impl_maybe_item_for_primitive {
     };
 }
 
-impl_maybe_item_for_has_niche!(crate::Own<T>, &T, &mut T);
+impl_maybe_item_for_has_niche!(crate::KjOwn<T>, &T, &mut T);
 impl_maybe_item_for_primitive!(
     u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64, bool
 );
@@ -180,29 +180,29 @@ pub(crate) mod repr {
     use std::fmt::Debug;
     use std::mem::MaybeUninit;
 
-    /// A [`Maybe`] represents bindings to the `kj::Maybe` class.
+    /// A [`KjMaybe`] 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>`.
+    /// in the [`MaybeItem`] trait, which determines the discriminant of the `KjMaybe<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 struct KjMaybe<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]);
+    assert_eq_size!(KjMaybe<isize>, [usize; 2]);
+    assert_eq_size!(KjMaybe<&isize>, usize);
+    assert_eq_size!(KjMaybe<crate::KjOwn<isize>>, [usize; 2]);
 
-    impl<T: MaybeItem> Maybe<T> {
+    impl<T: MaybeItem> KjMaybe<T> {
         /// # Safety
         /// This function shouldn't be used except by macro generation.
         pub unsafe fn is_set(&self) -> T::Discriminant {
@@ -215,8 +215,8 @@ pub(crate) mod repr {
         pub const unsafe fn from_parts_unchecked(
             is_set: T::Discriminant,
             some: MaybeUninit<T>,
-        ) -> Maybe<T> {
-            Maybe { is_set, some }
+        ) -> KjMaybe<T> {
+            KjMaybe { is_set, some }
         }
 
         pub fn is_some(&self) -> bool {
@@ -243,23 +243,23 @@ pub(crate) mod repr {
 
         /// 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
+        /// Constructing a `KjMaybe<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> {
+        pub fn Some(value: T) -> KjMaybe<T> {
             T::some(value)
         }
 
         /// [`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.
+        /// Constructing a `KjMaybe<T>::None` variant should always be possible from Rust.
         #[allow(non_upper_case_globals, dead_code)]
-        pub const None: Maybe<T> = T::NONE;
+        pub const None: KjMaybe<T> = T::NONE;
     }
 
-    impl<T: MaybeItem> From<Maybe<T>> for Option<T> {
-        fn from(value: Maybe<T>) -> Self {
+    impl<T: MaybeItem> From<KjMaybe<T>> for Option<T> {
+        fn from(value: KjMaybe<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
@@ -272,13 +272,13 @@ pub(crate) mod repr {
         }
     }
 
-    impl<T: MaybeItem> From<Option<T>> for Maybe<T> {
+    impl<T: MaybeItem> From<Option<T>> for KjMaybe<T> {
         fn from(value: Option<T>) -> Self {
             <T as MaybeItem>::from_option(value)
         }
     }
 
-    impl<T: MaybeItem + Debug> Debug for Maybe<T> {
+    impl<T: MaybeItem + Debug> Debug for KjMaybe<T> {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             if self.is_none() {
                 write!(f, "Maybe::None")
@@ -290,13 +290,13 @@ pub(crate) mod repr {
         }
     }
 
-    impl<T: MaybeItem> Default for Maybe<T> {
+    impl<T: MaybeItem> Default for KjMaybe<T> {
         fn default() -> Self {
             T::NONE
         }
     }
 
-    impl<T: MaybeItem> Drop for Maybe<T> {
+    impl<T: MaybeItem> Drop for KjMaybe<T> {
         fn drop(&mut self) {
             T::drop_in_place(self);
         }