Remove ShareId and default ownership for Id

This is a usability degradation, but before we know more about actual usage patterns this is the safer option; users will have to explicitly specify the ownership they're expecting.

See SSheldon/rust-objc-id#4

Author: madsmtm

objc2/src/rc/id.rs

@@ -59,10 +59,10 @@ use crate::Message;
 /// ```no_run
 /// use objc2::msg_send;
 /// use objc2::runtime::{Class, Object};
-/// use objc2::rc::{Id, WeakId, Shared};
+/// use objc2::rc::{Id, Owned, Shared, WeakId};
 ///
 /// let cls = Class::get("NSObject").unwrap();
-/// let obj: Id<Object> = unsafe {
+/// let obj: Id<Object, Owned> = unsafe {
 ///     Id::new(msg_send![cls, new])
 /// };
 /// // obj will be released when it goes out of scope
@@ -97,7 +97,7 @@ use crate::Message;
 #[repr(transparent)]
 // TODO: Figure out if `Message` bound on `T` would be better here?
 // TODO: Add `?Sized + ptr::Thin` bound on `T` to allow for extern types
-pub struct Id<T, O: Ownership = Owned> {
+pub struct Id<T, O: Ownership> {
     /// A pointer to the contained object. The pointer is always retained.
     ///
     /// It is important that this is `NonNull`, since we want to dereference
@@ -296,7 +296,7 @@ impl<T: Message> Clone for Id<T, Shared> {
     #[doc(alias = "objc_retain")]
     #[doc(alias = "retain")]
     #[inline]
-    fn clone(&self) -> ShareId<T> {
+    fn clone(&self) -> Self {
         // SAFETY: The pointer is valid
         unsafe { Id::retain(self.ptr) }
     }
@@ -509,14 +509,11 @@ impl<T, O: Ownership> Unpin for Id<T, O> {}
 
 // TODO: When stabilized impl Fn traits & CoerceUnsized
 
-/// A convenient alias for a shared [`Id`].
-pub type ShareId<T> = Id<T, Shared>;
-
 #[cfg(test)]
 mod tests {
     use core::ptr::NonNull;
 
-    use super::{Id, Shared};
+    use super::{Id, Owned, Shared};
     use crate::rc::autoreleasepool;
     use crate::runtime::Object;
     use crate::{class, msg_send};
@@ -543,7 +540,7 @@ mod tests {
     #[test]
     fn test_clone() {
         let cls = class!(NSObject);
-        let obj: Id<Object> = unsafe {
+        let obj: Id<Object, Owned> = unsafe {
             let obj: *mut Object = msg_send![cls, alloc];
             let obj: *mut Object = msg_send![obj, init];
             Id::new(NonNull::new_unchecked(obj))

objc2/src/rc/mod.rs

@@ -32,7 +32,7 @@ mod ownership;
 mod weak_id;
 
 pub use self::autorelease::{autoreleasepool, AutoreleasePool, AutoreleaseSafe};
-pub use self::id::{Id, ShareId};
+pub use self::id::Id;
 pub use self::ownership::{Owned, Ownership, Shared};
 pub use self::weak_id::WeakId;
 

objc2_foundation/src/array.rs

@@ -5,7 +5,7 @@ use core::marker::PhantomData;
 use core::ops::{Index, Range};
 use core::ptr::NonNull;
 
-use objc2::rc::{Id, Owned, Ownership, ShareId, Shared};
+use objc2::rc::{Id, Owned, Ownership, Shared};
 use objc2::runtime::{Class, Object};
 use objc2::{class, msg_send};
 use objc2::{Encode, Encoding};
@@ -71,7 +71,7 @@ unsafe impl Encode for NSRange {
         Encoding::Struct("_NSRange", &[usize::ENCODING, usize::ENCODING]);
 }
 
-unsafe fn from_refs<A>(refs: &[&A::Item]) -> Id<A>
+unsafe fn from_refs<A>(refs: &[&A::Item]) -> Id<A, Owned>
 where
     A: INSArray,
 {
@@ -126,7 +126,7 @@ pub trait INSArray: INSObject {
         }
     }
 
-    fn from_vec(vec: Vec<Id<Self::Item, Self::Own>>) -> Id<Self> {
+    fn from_vec(vec: Vec<Id<Self::Item, Self::Own>>) -> Id<Self, Owned> {
         let refs: Vec<&Self::Item> = vec.iter().map(|obj| &**obj).collect();
         unsafe { from_refs(&refs) }
     }
@@ -145,7 +145,7 @@ pub trait INSArray: INSObject {
         self.objects_in_range(0..self.count())
     }
 
-    fn into_vec(array: Id<Self>) -> Vec<Id<Self::Item, Self::Own>> {
+    fn into_vec(array: Id<Self, Owned>) -> Vec<Id<Self::Item, Self::Own>> {
         array
             .to_vec()
             .into_iter()
@@ -163,23 +163,23 @@ pub trait INSArray: INSObject {
         }
     }
 
-    fn shared_object_at(&self, index: usize) -> ShareId<Self::Item>
+    fn shared_object_at(&self, index: usize) -> Id<Self::Item, Shared>
     where
         Self: INSArray<Own = Shared>,
     {
         let obj = self.object_at(index);
         unsafe { Id::retain(obj.into()) }
     }
 
-    fn from_slice(slice: &[ShareId<Self::Item>]) -> Id<Self>
+    fn from_slice(slice: &[Id<Self::Item, Shared>]) -> Id<Self, Owned>
     where
         Self: INSArray<Own = Shared>,
     {
         let refs: Vec<&Self::Item> = slice.iter().map(|obj| &**obj).collect();
         unsafe { from_refs(&refs) }
     }
 
-    fn to_shared_vec(&self) -> Vec<ShareId<Self::Item>>
+    fn to_shared_vec(&self) -> Vec<Id<Self::Item, Shared>>
     where
         Self: INSArray<Own = Shared>,
     {
@@ -415,9 +415,9 @@ mod tests {
 
     use super::{INSArray, INSMutableArray, NSArray, NSMutableArray};
     use crate::{INSObject, INSString, NSObject, NSString};
-    use objc2::rc::Id;
+    use objc2::rc::{Id, Owned};
 
-    fn sample_array(len: usize) -> Id<NSArray<NSObject>> {
+    fn sample_array(len: usize) -> Id<NSArray<NSObject>, Owned> {
         let mut vec = Vec::with_capacity(len);
         for _ in 0..len {
             vec.push(NSObject::new());
@@ -441,7 +441,7 @@ mod tests {
         assert!(array.first_object().unwrap() == array.object_at(0));
         assert!(array.last_object().unwrap() == array.object_at(3));
 
-        let empty_array: Id<NSArray<NSObject>> = INSObject::new();
+        let empty_array: Id<NSArray<NSObject>, Owned> = INSObject::new();
         assert!(empty_array.first_object().is_none());
         assert!(empty_array.last_object().is_none());
     }

objc2_foundation/src/data.rs

@@ -6,7 +6,7 @@ use core::{ffi::c_void, ptr::NonNull};
 
 use super::{INSCopying, INSMutableCopying, INSObject, NSRange};
 use objc2::msg_send;
-use objc2::rc::Id;
+use objc2::rc::{Id, Owned};
 #[cfg(feature = "block")]
 use objc2_block::{Block, ConcreteBlock};
 
@@ -30,7 +30,7 @@ pub trait INSData: INSObject {
         unsafe { slice::from_raw_parts(ptr, len) }
     }
 
-    fn with_bytes(bytes: &[u8]) -> Id<Self> {
+    fn with_bytes(bytes: &[u8]) -> Id<Self, Owned> {
         let cls = Self::class();
         let bytes_ptr = bytes.as_ptr() as *const c_void;
         unsafe {
@@ -42,7 +42,7 @@ pub trait INSData: INSObject {
     }
 
     #[cfg(feature = "block")]
-    fn from_vec(bytes: Vec<u8>) -> Id<Self> {
+    fn from_vec(bytes: Vec<u8>) -> Id<Self, Owned> {
         let capacity = bytes.capacity();
         let dealloc = ConcreteBlock::new(move |bytes: *mut c_void, len: usize| unsafe {
             // Recreate the Vec and let it drop

objc2_foundation/src/dictionary.rs

@@ -4,13 +4,13 @@ use core::marker::PhantomData;
 use core::ops::Index;
 use core::ptr::{self, NonNull};
 
-use objc2::rc::{Id, Owned, Ownership, ShareId};
+use objc2::rc::{Id, Owned, Ownership, Shared};
 use objc2::runtime::Class;
 use objc2::{class, msg_send};
 
 use super::{INSCopying, INSFastEnumeration, INSObject, NSArray, NSEnumerator, NSSharedArray};
 
-unsafe fn from_refs<D, T>(keys: &[&T], vals: &[&D::Value]) -> Id<D>
+unsafe fn from_refs<D, T>(keys: &[&T], vals: &[&D::Value]) -> Id<D, Owned>
 where
     D: INSDictionary,
     T: INSCopying<Output = D::Key>,
@@ -93,22 +93,22 @@ pub trait INSDictionary: INSObject {
         }
     }
 
-    fn keys_array(&self) -> Id<NSSharedArray<Self::Key>> {
+    fn keys_array(&self) -> Id<NSSharedArray<Self::Key>, Owned> {
         unsafe {
             let keys = msg_send![self, allKeys];
             Id::retain(NonNull::new_unchecked(keys))
         }
     }
 
-    fn from_keys_and_objects<T>(keys: &[&T], vals: Vec<Id<Self::Value, Self::Own>>) -> Id<Self>
+    fn from_keys_and_objects<T>(keys: &[&T], vals: Vec<Id<Self::Value, Self::Own>>) -> Id<Self, Owned>
     where
         T: INSCopying<Output = Self::Key>,
     {
         let vals_refs: Vec<&Self::Value> = vals.iter().map(|obj| &**obj).collect();
         unsafe { from_refs(keys, &vals_refs) }
     }
 
-    fn into_values_array(dict: Id<Self>) -> Id<NSArray<Self::Value, Self::Own>> {
+    fn into_values_array(dict: Id<Self, Owned>) -> Id<NSArray<Self::Value, Self::Own>, Owned> {
         unsafe {
             let vals = msg_send![dict, allValues];
             Id::retain(NonNull::new_unchecked(vals))
@@ -117,8 +117,8 @@ pub trait INSDictionary: INSObject {
 }
 
 pub struct NSDictionary<K, V> {
-    key: PhantomData<ShareId<K>>,
-    obj: PhantomData<Id<V>>,
+    key: PhantomData<Id<K, Shared>>,
+    obj: PhantomData<Id<V, Owned>>,
 }
 
 object_impl!(NSDictionary<K, V>);
@@ -166,12 +166,12 @@ where
 #[cfg(test)]
 mod tests {
     use alloc::vec;
-    use objc2::rc::Id;
+    use objc2::rc::{Owned, Id};
 
     use super::{INSDictionary, NSDictionary};
     use crate::{INSArray, INSObject, INSString, NSObject, NSString};
 
-    fn sample_dict(key: &str) -> Id<NSDictionary<NSString, NSObject>> {
+    fn sample_dict(key: &str) -> Id<NSDictionary<NSString, NSObject>, Owned> {
         let string = NSString::from_str(key);
         let obj = NSObject::new();
         NSDictionary::from_keys_and_objects(&[&*string], vec![obj])

objc2_foundation/src/enumerator.rs

@@ -5,7 +5,7 @@ use core::ptr::NonNull;
 use core::slice;
 use std::os::raw::c_ulong;
 
-use objc2::rc::Id;
+use objc2::rc::{Id, Owned};
 use objc2::runtime::Object;
 use objc2::{msg_send, Encode, Encoding, RefEncode};
 
@@ -15,7 +15,7 @@ pub struct NSEnumerator<'a, T>
 where
     T: INSObject,
 {
-    id: Id<Object>,
+    id: Id<Object, Owned>,
     item: PhantomData<&'a T>,
 }
 

objc2_foundation/src/object.rs

@@ -2,7 +2,7 @@ use core::any::Any;
 use core::ptr::NonNull;
 
 use objc2::msg_send;
-use objc2::rc::{Id, ShareId};
+use objc2::rc::{Id, Owned, Shared};
 use objc2::runtime::{Class, BOOL, NO};
 use objc2::Message;
 
@@ -29,7 +29,7 @@ pub trait INSObject: Any + Sized + Message {
         result != NO
     }
 
-    fn description(&self) -> ShareId<NSString> {
+    fn description(&self) -> Id<NSString, Shared> {
         unsafe {
             let result: *mut NSString = msg_send![self, description];
             // TODO: Verify that description always returns a non-null string
@@ -42,7 +42,7 @@ pub trait INSObject: Any + Sized + Message {
         result != NO
     }
 
-    fn new() -> Id<Self> {
+    fn new() -> Id<Self, Owned> {
         let cls = Self::class();
         unsafe { Id::new(msg_send![cls, new]) }
     }

objc2_foundation/src/string.rs

@@ -6,14 +6,14 @@ use core::str;
 use std::os::raw::c_char;
 
 use objc2::msg_send;
-use objc2::rc::{Id, ShareId};
+use objc2::rc::{Id, Owned, Shared};
 
 use super::INSObject;
 
 pub trait INSCopying: INSObject {
     type Output: INSObject;
 
-    fn copy(&self) -> ShareId<Self::Output> {
+    fn copy(&self) -> Id<Self::Output, Shared> {
         unsafe {
             let obj: *mut Self::Output = msg_send![self, copy];
             Id::new(NonNull::new_unchecked(obj))
@@ -24,7 +24,7 @@ pub trait INSCopying: INSObject {
 pub trait INSMutableCopying: INSObject {
     type Output: INSObject;
 
-    fn mutable_copy(&self) -> Id<Self::Output> {
+    fn mutable_copy(&self) -> Id<Self::Output, Owned> {
         unsafe {
             let obj: *mut Self::Output = msg_send![self, mutableCopy];
             Id::new(NonNull::new_unchecked(obj))
@@ -58,7 +58,7 @@ pub trait INSString: INSObject {
         }
     }
 
-    fn from_str(string: &str) -> Id<Self> {
+    fn from_str(string: &str) -> Id<Self, Owned> {
         let cls = Self::class();
         let bytes = string.as_ptr() as *const c_void;
         unsafe {

objc2_foundation/src/value.rs

@@ -8,7 +8,7 @@ use core::str;
 use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
 
-use objc2::rc::Id;
+use objc2::rc::{Id, Owned};
 use objc2::runtime::Class;
 use objc2::Encode;
 use objc2::{class, msg_send};
@@ -36,7 +36,7 @@ pub trait INSValue: INSObject {
         }
     }
 
-    fn from_value(value: Self::Value) -> Id<Self> {
+    fn from_value(value: Self::Value) -> Id<Self, Owned> {
         let cls = Self::class();
         let value_ptr: *const Self::Value = &value;
         let bytes = value_ptr as *const c_void;