WIP: rc::MaybeOwnership + rc::Unknown

Author: madsmtm

objc2/src/__macro_helpers.rs

@@ -1,4 +1,4 @@
-use crate::rc::{Allocated, Id, Ownership};
+use crate::rc::{Allocated, Id, MaybeOwnership};
 use crate::runtime::{Class, Sel};
 use crate::{Message, MessageArguments, MessageReceiver};
 
@@ -51,7 +51,7 @@ pub trait MsgSendId<T, U> {
 }
 
 // `new`
-impl<T: ?Sized + Message, O: Ownership> MsgSendId<&'_ Class, Id<T, O>>
+impl<T: ?Sized + Message, O: MaybeOwnership> MsgSendId<&'_ Class, Id<T, O>>
     for RetainSemantics<true, false, false, false>
 {
     #[inline]
@@ -69,7 +69,7 @@ impl<T: ?Sized + Message, O: Ownership> MsgSendId<&'_ Class, Id<T, O>>
 }
 
 // `alloc`
-impl<T: ?Sized + Message, O: Ownership> MsgSendId<&'_ Class, Id<Allocated<T>, O>>
+impl<T: ?Sized + Message, O: MaybeOwnership> MsgSendId<&'_ Class, Id<Allocated<T>, O>>
     for RetainSemantics<false, true, false, false>
 {
     #[inline]
@@ -87,7 +87,7 @@ impl<T: ?Sized + Message, O: Ownership> MsgSendId<&'_ Class, Id<Allocated<T>, O>
 }
 
 // `init`
-impl<T: ?Sized + Message, O: Ownership> MsgSendId<Option<Id<Allocated<T>, O>>, Id<T, O>>
+impl<T: ?Sized + Message, O: MaybeOwnership> MsgSendId<Option<Id<Allocated<T>, O>>, Id<T, O>>
     for RetainSemantics<false, false, true, false>
 {
     #[inline]
@@ -111,7 +111,7 @@ impl<T: ?Sized + Message, O: Ownership> MsgSendId<Option<Id<Allocated<T>, O>>, I
 }
 
 // `copy` and `mutableCopy`
-impl<T: MessageReceiver, U: ?Sized + Message, O: Ownership> MsgSendId<T, Id<U, O>>
+impl<T: MessageReceiver, U: ?Sized + Message, O: MaybeOwnership> MsgSendId<T, Id<U, O>>
     for RetainSemantics<false, false, false, true>
 {
     #[inline]
@@ -126,7 +126,7 @@ impl<T: MessageReceiver, U: ?Sized + Message, O: Ownership> MsgSendId<T, Id<U, O
 }
 
 // All other selectors
-impl<T: MessageReceiver, U: Message, O: Ownership> MsgSendId<T, Id<U, O>>
+impl<T: MessageReceiver, U: Message, O: MaybeOwnership> MsgSendId<T, Id<U, O>>
     for RetainSemantics<false, false, false, false>
 {
     #[inline]

objc2/src/message/mod.rs

@@ -2,7 +2,7 @@ use core::mem;
 use core::mem::ManuallyDrop;
 use core::ptr::NonNull;
 
-use crate::rc::{Id, Owned, Ownership};
+use crate::rc::{Id, MaybeOwnership, Owned};
 use crate::runtime::{Class, Imp, Object, Sel};
 use crate::{Encode, EncodeArguments, RefEncode};
 
@@ -115,10 +115,10 @@ pub(crate) mod private {
     impl<'a, T: Message + ?Sized> Sealed for &'a T {}
     impl<'a, T: Message + ?Sized> Sealed for &'a mut T {}
 
-    impl<'a, T: Message + ?Sized, O: Ownership> Sealed for &'a Id<T, O> {}
+    impl<'a, T: Message + ?Sized, O: MaybeOwnership> Sealed for &'a Id<T, O> {}
     impl<'a, T: Message + ?Sized> Sealed for &'a mut Id<T, Owned> {}
 
-    impl<T: Message + ?Sized, O: Ownership> Sealed for ManuallyDrop<Id<T, O>> {}
+    impl<T: Message + ?Sized, O: MaybeOwnership> Sealed for ManuallyDrop<Id<T, O>> {}
 
     impl Sealed for *const Class {}
     impl<'a> Sealed for &'a Class {}
@@ -266,7 +266,7 @@ unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a mut T {
     }
 }
 
-unsafe impl<'a, T: Message + ?Sized, O: Ownership> MessageReceiver for &'a Id<T, O> {
+unsafe impl<'a, T: Message + ?Sized, O: MaybeOwnership> MessageReceiver for &'a Id<T, O> {
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         (Id::as_ptr(self) as *mut T).cast()
@@ -280,7 +280,7 @@ unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a mut Id<T, Owned> {
     }
 }
 
-unsafe impl<T: Message + ?Sized, O: Ownership> MessageReceiver for ManuallyDrop<Id<T, O>> {
+unsafe impl<T: Message + ?Sized, O: MaybeOwnership> MessageReceiver for ManuallyDrop<Id<T, O>> {
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         Id::consume_as_ptr(self).cast()

objc2/src/rc/id.rs

@@ -7,7 +7,7 @@ use core::ptr::NonNull;
 
 use super::Allocated;
 use super::AutoreleasePool;
-use super::{Owned, Ownership, Shared};
+use super::{MaybeOwnership, Owned, Ownership, Shared, Unknown};
 use crate::ffi;
 use crate::Message;
 
@@ -101,7 +101,7 @@ use crate::Message;
 // TODO: Figure out if `Message` bound on `T` would be better here?
 // TODO: Add `ptr::Thin` bound on `T` to allow for only extern types
 // TODO: Consider changing the name of Id -> Retain
-pub struct Id<T: ?Sized, O: Ownership> {
+pub struct Id<T: ?Sized, O: MaybeOwnership> {
     /// A pointer to the contained object. The pointer is always retained.
     ///
     /// It is important that this is `NonNull`, since we want to dereference
@@ -125,7 +125,7 @@ pub struct Id<T: ?Sized, O: Ownership> {
     notunwindsafe: PhantomData<&'static mut ()>,
 }
 
-impl<T: ?Sized, O: Ownership> Id<T, O> {
+impl<T: ?Sized, O: MaybeOwnership> Id<T, O> {
     #[inline]
     unsafe fn new_nonnull(ptr: NonNull<T>) -> Self {
         Self {
@@ -137,7 +137,7 @@ impl<T: ?Sized, O: Ownership> Id<T, O> {
     }
 }
 
-impl<T: Message + ?Sized, O: Ownership> Id<Allocated<T>, O> {
+impl<T: Message + ?Sized, O: MaybeOwnership> Id<Allocated<T>, O> {
     #[inline]
     pub(crate) unsafe fn new_allocated(ptr: *mut T) -> Option<Self> {
         // SAFETY: Upheld by the caller
@@ -158,7 +158,7 @@ impl<T: Message + ?Sized, O: Ownership> Id<Allocated<T>, O> {
     }
 }
 
-impl<T: Message + ?Sized, O: Ownership> Id<T, O> {
+impl<T: Message + ?Sized, O: MaybeOwnership> Id<T, O> {
     /// Constructs an [`Id`] to an object that already has +1 retain count.
     ///
     /// This is useful when you have a retain count that has been handed off
@@ -258,7 +258,7 @@ impl<T: Message + ?Sized> Id<T, Owned> {
 }
 
 // TODO: Add ?Sized bound
-impl<T: Message, O: Ownership> Id<T, O> {
+impl<T: Message, O: MaybeOwnership> Id<T, O> {
     /// Convert the type of the given object to another.
     ///
     /// This is equivalent to a `cast` between two pointers.
@@ -546,6 +546,38 @@ impl<T: Message> Id<T, Shared> {
     }
 }
 
+impl<T: Message + ?Sized> Id<T, Unknown> {
+    /// TODO
+    #[inline]
+    pub unsafe fn into_owned(self) -> Id<T, Owned> {
+        unsafe { self.into_ownership() }
+    }
+
+    /// TODO
+    #[inline]
+    pub unsafe fn into_shared(self) -> Id<T, Shared> {
+        unsafe { self.into_ownership() }
+    }
+
+    /// TODO
+    #[inline]
+    pub unsafe fn into_ownership<O: Ownership>(self) -> Id<T, O> {
+        let ptr = ManuallyDrop::new(self).ptr;
+        unsafe { Id::new_nonnull(ptr) }
+    }
+}
+
+impl<T: Message> Id<T, Unknown> {
+    /// TODO
+    #[doc(alias = "objc_autorelease")]
+    #[must_use = "If you don't intend to use the object any more, just drop it as usual"]
+    #[inline]
+    pub fn autorelease(self, pool: &AutoreleasePool) -> *mut T {
+        pool.__verify_is_inner();
+        self.autorelease_inner()
+    }
+}
+
 impl<T: Message + ?Sized> From<Id<T, Owned>> for Id<T, Shared> {
     /// Downgrade from an owned to a shared [`Id`], allowing it to be cloned.
     #[inline]
@@ -556,6 +588,15 @@ impl<T: Message + ?Sized> From<Id<T, Owned>> for Id<T, Shared> {
     }
 }
 
+impl<T: Message + ?Sized, O: Ownership> From<Id<T, O>> for Id<T, Unknown> {
+    #[inline]
+    fn from(obj: Id<T, O>) -> Self {
+        let ptr = ManuallyDrop::new(obj).ptr;
+        // SAFETY: The pointer is valid, and ownership is simply decreased
+        unsafe { <Id<T, Unknown>>::new_nonnull(ptr) }
+    }
+}
+
 // TODO: Add ?Sized bound
 impl<T: Message> Clone for Id<T, Shared> {
     /// Makes a clone of the shared object.
@@ -580,7 +621,7 @@ impl<T: Message> Clone for Id<T, Shared> {
 /// borrowed data.
 ///
 /// [dropck_eyepatch]: https://doc.rust-lang.org/nightly/nomicon/dropck.html#an-escape-hatch
-impl<T: ?Sized, O: Ownership> Drop for Id<T, O> {
+impl<T: ?Sized, O: MaybeOwnership> Drop for Id<T, O> {
     /// Releases the retained object.
     ///
     /// The contained object's destructor (if it has one) is never run!
@@ -624,6 +665,9 @@ unsafe impl<T: Send + ?Sized> Send for Id<T, Owned> {}
 /// access as having a `T` directly.
 unsafe impl<T: Sync + ?Sized> Sync for Id<T, Owned> {}
 
+// TODO: Maybe implement Send and Sync for `O: Unknown`?
+
+// Explicitly using `Ownership` and not `MaybeOwnership` here!
 impl<T: ?Sized, O: Ownership> Deref for Id<T, O> {
     type Target = T;
 
@@ -647,7 +691,7 @@ impl<T: ?Sized> DerefMut for Id<T, Owned> {
     }
 }
 
-impl<T: ?Sized, O: Ownership> fmt::Pointer for Id<T, O> {
+impl<T: ?Sized, O: MaybeOwnership> fmt::Pointer for Id<T, O> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Pointer::fmt(&self.ptr.as_ptr(), f)
     }
@@ -657,8 +701,11 @@ impl<T: ?Sized, O: Ownership> fmt::Pointer for Id<T, O> {
 //
 // See https://doc.rust-lang.org/1.54.0/src/alloc/boxed.rs.html#1652-1675
 // and the `Arc` implementation.
+//
+// TODO: MaybeOwnership?
 impl<T: ?Sized, O: Ownership> Unpin for Id<T, O> {}
 
+// TODO: MaybeOwnership?
 impl<T: RefUnwindSafe + ?Sized, O: Ownership> RefUnwindSafe for Id<T, O> {}
 
 // Same as `Arc<T>`.

objc2/src/rc/mod.rs

@@ -70,7 +70,7 @@ pub use self::allocated::Allocated;
 pub use self::autorelease::{autoreleasepool, AutoreleasePool, AutoreleaseSafe};
 pub use self::id::Id;
 pub use self::id_traits::{DefaultId, SliceId, SliceIdMut};
-pub use self::ownership::{Owned, Ownership, Shared};
+pub use self::ownership::{MaybeOwnership, Owned, Ownership, Shared, Unknown};
 pub use self::weak_id::WeakId;
 
 #[cfg(test)]

objc2/src/rc/ownership.rs

@@ -8,19 +8,31 @@ pub enum Owned {}
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub enum Shared {}
 
+/// TODO
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Unknown {}
+
 mod private {
     pub trait Sealed {}
 
     impl Sealed for super::Owned {}
     impl Sealed for super::Shared {}
+    impl Sealed for super::Unknown {}
 }
 
+/// TODO
+pub trait MaybeOwnership: private::Sealed + 'static {}
+
+impl MaybeOwnership for Owned {}
+impl MaybeOwnership for Shared {}
+impl MaybeOwnership for Unknown {}
+
 /// A type that marks what type of ownership a struct has over the object(s)
 /// it contains; specifically, either [`Owned`] or [`Shared`].
 ///
 /// This trait is sealed and not meant to be implemented outside of the this
 /// crate.
-pub trait Ownership: private::Sealed + 'static {}
+pub trait Ownership: private::Sealed + MaybeOwnership + 'static {}
 
 impl Ownership for Owned {}
 impl Ownership for Shared {}