Remove INSObject::Ownership

Instead, it is present on the types that actually need it. This is in preparation for bigger changes to objc2-foundation, see #58.

Author: madsmtm

objc2-foundation/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## Unreleased - YYYY-MM-DD
 
+### Added
+* **BREAKING**: Added associated `Ownership` type to `NSCopying`.
+* **BREAKING**: Added associated `Ownership` type to `INSData`.
+* **BREAKING**: Added associated `Ownership` type to `INSArray`.
+
+### Changed
+* **BREAKING**: Made some creation methods a bit less generic (e.g.
+  `INSDictionary::from_keys_and_objects` now always returns `Id<_, Shared>`).
+
+### Removed
+* **BREAKING**: Removed associated `Ownership` type from `INSObject`; instead,
+  it is present on the types that actually need it (for example `NSCopying`).
+
 ## 0.2.0-alpha.2 - 2021-11-22
 
 ### Added

objc2-foundation/examples/class_with_lifetime.rs

@@ -53,8 +53,6 @@ impl<'a> MyObject<'a> {
 static MYOBJECT_REGISTER_CLASS: Once = Once::new();
 
 unsafe impl INSObject for MyObject<'_> {
-    type Ownership = Owned;
-
     fn class() -> &'static Class {
         MYOBJECT_REGISTER_CLASS.call_once(|| {
             let superclass = NSObject::class();

objc2-foundation/examples/custom_class.rs

@@ -23,7 +23,7 @@ unsafe impl RefEncode for MYObject {
 }
 
 impl MYObject {
-    fn new() -> Id<Self, <Self as INSObject>::Ownership> {
+    fn new() -> Id<Self, Owned> {
         let cls = Self::class();
         unsafe { Id::new(NonNull::new_unchecked(msg_send![cls, new])) }
     }
@@ -48,8 +48,6 @@ unsafe impl Message for MYObject {}
 static MYOBJECT_REGISTER_CLASS: Once = Once::new();
 
 unsafe impl INSObject for MYObject {
-    type Ownership = Owned;
-
     fn class() -> &'static Class {
         MYOBJECT_REGISTER_CLASS.call_once(|| {
             let superclass = NSObject::class();

objc2-foundation/src/array.rs

@@ -29,10 +29,11 @@ unsafe fn from_refs<A: INSArray>(refs: &[&A::Item]) -> Id<A, A::Ownership> {
 }
 
 pub unsafe trait INSArray: INSObject {
+    type Ownership: Ownership;
     type Item: INSObject;
     type ItemOwnership: Ownership;
 
-    unsafe_def_fn!(fn new);
+    unsafe_def_fn!(fn new -> Self::Ownership);
 
     #[doc(alias = "count")]
     fn len(&self) -> usize {
@@ -165,33 +166,36 @@ pub unsafe trait INSArray: INSObject {
 ///
 /// `Id<NSArray<T, Owned>, Shared>` is possible, but pretty useless.
 /// TODO: Can we make it impossible? Should we?
+///
+/// What about `Id<NSArray<T, Shared>, Owned>`?
 pub struct NSArray<T, O: Ownership> {
     item: PhantomData<Id<T, O>>,
 }
 
 object_impl!(unsafe NSArray<T, O: Ownership>);
 
 unsafe impl<T: INSObject, O: Ownership> INSObject for NSArray<T, O> {
+    fn class() -> &'static Class {
+        class!(NSArray)
+    }
+}
+
+unsafe impl<T: INSObject, O: Ownership> INSArray for NSArray<T, O> {
     /// The `NSArray` itself (length and number of items) is always immutable,
     /// but we would like to know when we're the only owner of the array, to
     /// allow mutation of the array's items.
     ///
     /// We only implement `INSCopying` when `O = Shared`, so this is safe.
     type Ownership = O;
 
-    fn class() -> &'static Class {
-        class!(NSArray)
-    }
-}
-
-unsafe impl<T: INSObject, O: Ownership> INSArray for NSArray<T, O> {
     type Item = T;
     type ItemOwnership = O;
 }
 
 // Copying only possible when ItemOwnership = Shared
 
 unsafe impl<T: INSObject> INSCopying for NSArray<T, Shared> {
+    type Ownership = Shared;
     type Output = NSArray<T, Shared>;
 }
 
@@ -322,14 +326,13 @@ pub struct NSMutableArray<T, O: Ownership> {
 object_impl!(unsafe NSMutableArray<T, O: Ownership>);
 
 unsafe impl<T: INSObject, O: Ownership> INSObject for NSMutableArray<T, O> {
-    type Ownership = Owned;
-
     fn class() -> &'static Class {
         class!(NSMutableArray)
     }
 }
 
 unsafe impl<T: INSObject, O: Ownership> INSArray for NSMutableArray<T, O> {
+    type Ownership = Owned;
     type Item = T;
     type ItemOwnership = O;
 }
@@ -339,6 +342,7 @@ unsafe impl<T: INSObject, O: Ownership> INSMutableArray for NSMutableArray<T, O>
 // Copying only possible when ItemOwnership = Shared
 
 unsafe impl<T: INSObject> INSCopying for NSMutableArray<T, Shared> {
+    type Ownership = Shared;
     type Output = NSArray<T, Shared>;
 }
 

objc2-foundation/src/copying.rs

@@ -1,34 +1,53 @@
 use core::ptr::NonNull;
 
 use objc2::msg_send;
-use objc2::rc::{Id, Owned};
+use objc2::rc::{Id, Owned, Ownership};
 
 use super::INSObject;
 
 pub unsafe trait INSCopying: INSObject {
-    /// This can be an [`Owned`] [`INSObject`] if and only if `copy` creates a
-    /// new instance, see the following example:
+    /// Indicates whether the type is mutable or immutable.
+    ///
+    /// This can be [`Owned`] if and only if `copy` creates a new instance,
+    /// see the following example:
     ///
     /// ```ignore
-    /// let x: Id<MyObject, Owned> = MyObject::new();
+    /// let x: Id<MyObject, _> = MyObject::new();
     /// // This is valid only if `y` is a new instance. Otherwise `x` and `y`
     /// // would be able to create aliasing mutable references!
     /// let y: Id<MyObject, Owned> = x.copy();
     /// ```
+    ///
+    /// Note that for the same reason, you should be careful when defining
+    /// `new` methods on your object; e.g. immutable types like [`NSString`]
+    /// don't return `Id<NSString, Owned>`, because that would allow this
+    /// trait to create an aliasing `Id<NSString, Shared>` (since sending the
+    /// `copy` message (and others) does not create a new instance, but
+    /// instead just retains the instance).
+    ///
+    /// [`NSString`]: crate::NSString
+    type Ownership: Ownership;
+
+    /// The output type.
+    ///
+    /// This is usually `Self`, but e.g. `NSMutableString` returns `NSString`.
+    /// TODO: Verify???
     type Output: INSObject;
 
-    fn copy(&self) -> Id<Self::Output, <Self::Output as INSObject>::Ownership> {
+    fn copy(&self) -> Id<Self::Output, Self::Ownership> {
         unsafe {
             let obj: *mut Self::Output = msg_send![self, copy];
             Id::new(NonNull::new_unchecked(obj))
         }
     }
 }
 
+/// TODO
+///
+/// Note that the `mutableCopy` selector must return an owned object!
 pub unsafe trait INSMutableCopying: INSObject {
-    /// An [`Owned`] [`INSObject`] is required to be able to return an owned
-    /// [`Id`].
-    type Output: INSObject<Ownership = Owned>;
+    /// TODO
+    type Output: INSObject;
 
     fn mutable_copy(&self) -> Id<Self::Output, Owned> {
         unsafe {

objc2-foundation/src/data.rs

@@ -6,10 +6,12 @@ use core::{ffi::c_void, ptr::NonNull};
 
 use super::{INSCopying, INSMutableCopying, INSObject, NSRange};
 use objc2::msg_send;
-use objc2::rc::{Id, Owned, Shared};
+use objc2::rc::{Id, Owned, Ownership, Shared};
 
 pub unsafe trait INSData: INSObject {
-    unsafe_def_fn!(fn new);
+    type Ownership: Ownership;
+
+    unsafe_def_fn!(fn new -> Self::Ownership);
 
     fn len(&self) -> usize {
         unsafe { msg_send![self, length] }
@@ -90,11 +92,14 @@ pub unsafe trait INSData: INSObject {
     }
 }
 
-object_struct!(unsafe NSData, Shared);
+object_struct!(unsafe NSData);
 
-unsafe impl INSData for NSData {}
+unsafe impl INSData for NSData {
+    type Ownership = Shared;
+}
 
 unsafe impl INSCopying for NSData {
+    type Ownership = Shared;
     type Output = NSData;
 }
 
@@ -150,13 +155,16 @@ pub unsafe trait INSMutableData: INSData {
     }
 }
 
-object_struct!(unsafe NSMutableData, Owned);
+object_struct!(unsafe NSMutableData);
 
-unsafe impl INSData for NSMutableData {}
+unsafe impl INSData for NSMutableData {
+    type Ownership = Owned;
+}
 
 unsafe impl INSMutableData for NSMutableData {}
 
 unsafe impl INSCopying for NSMutableData {
+    type Ownership = Shared;
     type Output = NSData;
 }
 

objc2-foundation/src/dictionary.rs

@@ -10,7 +10,7 @@ use objc2::{class, msg_send};
 
 use super::{INSCopying, INSFastEnumeration, INSObject, NSArray, NSEnumerator};
 
-unsafe fn from_refs<D, T>(keys: &[&T], vals: &[&D::Value]) -> Id<D, D::Ownership>
+unsafe fn from_refs<D, T>(keys: &[&T], vals: &[&D::Value]) -> Id<D, Shared>
 where
     D: INSDictionary,
     T: INSCopying<Output = D::Key>,
@@ -35,8 +35,6 @@ pub unsafe trait INSDictionary: INSObject {
     type Value: INSObject;
     type ValueOwnership: Ownership;
 
-    unsafe_def_fn!(fn new);
-
     #[doc(alias = "count")]
     fn len(&self) -> usize {
         unsafe { msg_send![self, count] }
@@ -124,7 +122,7 @@ pub unsafe trait INSDictionary: INSObject {
     fn from_keys_and_objects<T>(
         keys: &[&T],
         vals: Vec<Id<Self::Value, Self::ValueOwnership>>,
-    ) -> Id<Self, Self::Ownership>
+    ) -> Id<Self, Shared>
     where
         T: INSCopying<Output = Self::Key>,
     {
@@ -148,9 +146,11 @@ pub struct NSDictionary<K, V> {
 
 object_impl!(unsafe NSDictionary<K, V>);
 
-unsafe impl<K: INSObject, V: INSObject> INSObject for NSDictionary<K, V> {
-    type Ownership = Shared;
+impl<K: INSObject, V: INSObject> NSDictionary<K, V> {
+    unsafe_def_fn!(pub fn new -> Shared);
+}
 
+unsafe impl<K: INSObject, V: INSObject> INSObject for NSDictionary<K, V> {
     fn class() -> &'static Class {
         class!(NSDictionary)
     }

objc2-foundation/src/macros.rs

@@ -7,7 +7,7 @@
 /// example: `NSAutoreleasePool` does not have this). Finally the ownership
 /// must be correct for this class.
 macro_rules! object_struct {
-    (unsafe $name:ident, $ownership:ty) => {
+    (unsafe $name:ident) => {
         // TODO: `extern type`
         #[repr(C)]
         pub struct $name {
@@ -21,8 +21,6 @@ macro_rules! object_struct {
         }
 
         unsafe impl $crate::INSObject for $name {
-            type Ownership = $ownership;
-
             fn class() -> &'static ::objc2::runtime::Class {
                 ::objc2::class!($name)
             }
@@ -77,8 +75,8 @@ macro_rules! object_impl {
 }
 
 macro_rules! unsafe_def_fn {
-    ($v:vis fn new) => {
-        $v fn new() -> Id<Self, <Self as INSObject>::Ownership> {
+    ($v:vis fn new -> $o:ty) => {
+        $v fn new() -> Id<Self, $o> {
             let cls = <Self as INSObject>::class();
             unsafe { Id::new(NonNull::new_unchecked(msg_send![cls, new])) }
         }

objc2-foundation/src/object.rs

@@ -1,7 +1,7 @@
 use core::ptr::NonNull;
 
 use objc2::msg_send;
-use objc2::rc::{Id, Owned, Ownership, Shared};
+use objc2::rc::{Id, Owned, Shared};
 use objc2::runtime::{Bool, Class};
 use objc2::Message;
 
@@ -12,16 +12,6 @@ use super::NSString;
 // type pointer to an Object pointer, because dynamically-sized types can have
 // fat pointers (two words) instead of real pointers.
 pub unsafe trait INSObject: Sized + Message {
-    /// Indicates whether the type is mutable or immutable.
-    ///
-    /// [`Shared`] means that only a shared [`Id`] can ever be held to this
-    /// object. This is important for immutable types like `NSString`, because
-    /// sending the `copy` message (and others) does not create a new
-    /// instance, but instead just retains the instance.
-    ///
-    /// Most objects are mutable and hence can return [`Owned`] [`Id`]s.
-    type Ownership: Ownership;
-
     fn class() -> &'static Class;
 
     fn hash_code(&self) -> usize {
@@ -47,10 +37,10 @@ pub unsafe trait INSObject: Sized + Message {
     }
 }
 
-object_struct!(unsafe NSObject, Owned);
+object_struct!(unsafe NSObject);
 
 impl NSObject {
-    unsafe_def_fn!(pub fn new);
+    unsafe_def_fn!(pub fn new -> Owned);
 }
 
 #[cfg(test)]

objc2-foundation/src/string.rs

@@ -22,8 +22,6 @@ const UTF8_ENCODING: i32 = 4;
 const NSNotFound: ffi::NSInteger = ffi::NSIntegerMax;
 
 pub unsafe trait INSString: INSObject {
-    unsafe_def_fn!(fn new);
-
     fn len(&self) -> usize {
         unsafe { msg_send![self, lengthOfBytesUsingEncoding: UTF8_ENCODING] }
     }
@@ -86,7 +84,7 @@ pub unsafe trait INSString: INSObject {
         str::from_utf8(bytes).unwrap()
     }
 
-    fn from_str(string: &str) -> Id<Self, Self::Ownership> {
+    fn from_str(string: &str) -> Id<Self, Shared> {
         let cls = Self::class();
         let bytes = string.as_ptr() as *const c_void;
         unsafe {
@@ -102,11 +100,16 @@ pub unsafe trait INSString: INSObject {
     }
 }
 
-object_struct!(unsafe NSString, Shared);
+object_struct!(unsafe NSString);
+
+impl NSString {
+    unsafe_def_fn!(pub fn new -> Shared);
+}
 
 unsafe impl INSString for NSString {}
 
 unsafe impl INSCopying for NSString {
+    type Ownership = Shared;
     type Output = NSString;
 }