Relax ?Sized bounds everywhere

Possible since Message: Sized

Author: madsmtm

objc2-encode/src/encode.rs

@@ -496,8 +496,8 @@ encode_pointer_impls!(
 /// well. So trying to do it quickly requires generating a polynomial amount of
 /// implementations, which IMO is overkill for such a small issue.
 ///
-/// Using `?Sized` is probably not safe here because C functions can only take
-/// and return items with a known size.
+/// Using `?Sized` is not safe here because C functions can only take and
+/// return items with a known size.
 macro_rules! encode_fn_pointer_impl {
     (@ $FnTy: ty, $($Arg: ident),*) => {
         unsafe impl<Ret: Encode, $($Arg: Encode),*> Encode for $FnTy {

objc2/CHANGELOG.md

@@ -17,6 +17,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   determining the name of a specific class.
 * Allow directly specifying class name in declare_class! macro.
 
+### Changed
+* **BREAKING**: Slightly changed when a type implements `?Sized` to support
+  `extern type` in the future. In particular, `Message` now requires `Sized`.
+
 ### Removed
 * **BREAKING**: `MaybeUninit` no longer implements `IvarType` directly; use
   `Ivar::write` instead.

objc2/src/__macro_helpers.rs

@@ -1,7 +1,7 @@
 use crate::__sel_inner;
 use crate::rc::{Allocated, Id, Ownership};
 use crate::runtime::{Class, Object, Sel};
-use crate::{Message, MessageArguments, MessageReceiver};
+use crate::{Message, MessageArguments, MessageReceiver, Thin};
 
 pub use crate::cache::CachedClass;
 pub use crate::cache::CachedSel;
@@ -83,7 +83,7 @@ type Init = RetainSemantics<false, false, true, false>;
 type CopyOrMutCopy = RetainSemantics<false, false, false, true>;
 type Other = RetainSemantics<false, false, false, false>;
 
-pub trait MsgSendId<T, U: ?Sized, O: Ownership> {
+pub trait MsgSendId<T, U: ?Sized + Thin, O: Ownership> {
     unsafe fn send_message_id<A: MessageArguments, R: MaybeUnwrap<U, O>>(
         obj: T,
         sel: Sel,
@@ -162,7 +162,7 @@ impl<T: MessageReceiver, U: ?Sized + Message, O: Ownership> MsgSendId<T, U, O> f
     }
 }
 
-impl<T: MessageReceiver, U: Message, O: Ownership> MsgSendId<T, U, O> for Other {
+impl<T: MessageReceiver, U: ?Sized + Message, O: Ownership> MsgSendId<T, U, O> for Other {
     #[inline]
     #[track_caller]
     unsafe fn send_message_id<A: MessageArguments, R: MaybeUnwrap<U, O>>(
@@ -186,14 +186,14 @@ impl<T: MessageReceiver, U: Message, O: Ownership> MsgSendId<T, U, O> for Other
     }
 }
 
-pub trait MaybeUnwrap<T: ?Sized, O: Ownership> {
+pub trait MaybeUnwrap<T: ?Sized + Thin, O: Ownership> {
     fn maybe_unwrap<'a, Failed: MsgSendIdFailed<'a>>(
         obj: Option<Id<T, O>>,
         args: Failed::Args,
     ) -> Self;
 }
 
-impl<T: ?Sized, O: Ownership> MaybeUnwrap<T, O> for Option<Id<T, O>> {
+impl<T: ?Sized + Thin, O: Ownership> MaybeUnwrap<T, O> for Option<Id<T, O>> {
     #[inline]
     #[track_caller]
     fn maybe_unwrap<'a, Failed: MsgSendIdFailed<'a>>(
@@ -204,7 +204,7 @@ impl<T: ?Sized, O: Ownership> MaybeUnwrap<T, O> for Option<Id<T, O>> {
     }
 }
 
-impl<T: ?Sized, O: Ownership> MaybeUnwrap<T, O> for Id<T, O> {
+impl<T: ?Sized + Thin, O: Ownership> MaybeUnwrap<T, O> for Id<T, O> {
     #[inline]
     #[track_caller]
     fn maybe_unwrap<'a, Failed: MsgSendIdFailed<'a>>(

objc2/src/class_type.rs

@@ -67,7 +67,7 @@ pub unsafe trait ClassType: Message {
     /// [`Deref`]: std::ops::Deref
     /// [`Deref::Target`]: std::ops::Deref::Target
     /// [`runtime::Object`]: crate::runtime::Object
-    type Super: Message;
+    type Super: ?Sized + Message;
 
     /// The name of the Objective-C class that this type represents.
     const NAME: &'static str;

objc2/src/declare.rs

@@ -127,7 +127,7 @@ use crate::encode::{Encode, EncodeArguments, Encoding, RefEncode};
 use crate::ffi;
 use crate::runtime::{Bool, Class, Imp, Object, Protocol, Sel};
 use crate::sel;
-use crate::Message;
+use crate::{Message, Thin};
 
 pub use ivar::{InnerIvarType, Ivar, IvarType};
 pub use ivar_drop::IvarDrop;
@@ -142,7 +142,7 @@ pub(crate) mod private {
 /// function pointer types.
 pub trait MethodImplementation: private::Sealed {
     /// The callee type of the method.
-    type Callee: RefEncode + ?Sized;
+    type Callee: RefEncode + ?Sized + Thin;
     /// The return type of the method.
     type Ret: Encode;
     /// The argument types of the method.
@@ -156,14 +156,14 @@ macro_rules! method_decl_impl {
     (@<$($l:lifetime),*> T, $r:ident, $f:ty, $($t:ident),*) => {
         impl<$($l,)* T, $r, $($t),*> private::Sealed for $f
         where
-            T: Message + ?Sized,
+            T: ?Sized + Message,
             $r: Encode,
             $($t: Encode,)*
         {}
 
         impl<$($l,)* T, $r, $($t),*> MethodImplementation for $f
         where
-            T: Message + ?Sized,
+            T: ?Sized + Message,
             $r: Encode,
             $($t: Encode,)*
         {
@@ -336,7 +336,7 @@ impl ClassBuilder {
     /// when the method is invoked from Objective-C.
     pub unsafe fn add_method<T, F>(&mut self, sel: Sel, func: F)
     where
-        T: Message + ?Sized,
+        T: ?Sized + Message,
         F: MethodImplementation<Callee = T>,
     {
         let encs = F::Args::ENCODINGS;

objc2/src/declare/ivar_drop.rs

@@ -98,7 +98,7 @@ unsafe impl<T: Sized> InnerIvarType for IvarDrop<Option<Box<T>>> {
     }
 }
 
-impl<T: Message, O: Ownership> super::ivar::private::Sealed for IvarDrop<Id<T, O>> {}
+impl<T: ?Sized + Message, O: Ownership> super::ivar::private::Sealed for IvarDrop<Id<T, O>> {}
 // SAFETY: `Id` is `NonNull<T>`, and hence safe to store as a pointer.
 //
 // The user ensures that the Id has been initialized in an `init` method
@@ -107,7 +107,7 @@ impl<T: Message, O: Ownership> super::ivar::private::Sealed for IvarDrop<Id<T, O
 // Note: We could technically do `impl InnerIvarType for Ivar<Id<T, O>>`
 // directly today, but since we can't do so for `Box` (because that is
 // `#[fundamental]`), I think it makes sense to handle them similarly.
-unsafe impl<T: Message, O: Ownership> InnerIvarType for IvarDrop<Id<T, O>> {
+unsafe impl<T: ?Sized + Message, O: Ownership> InnerIvarType for IvarDrop<Id<T, O>> {
     const __ENCODING: Encoding = <*const T as EncodeConvert>::__ENCODING;
 
     type __Inner = Option<Id<T, O>>;
@@ -137,12 +137,15 @@ unsafe impl<T: Message, O: Ownership> InnerIvarType for IvarDrop<Id<T, O>> {
     }
 }
 
-impl<T: Message, O: Ownership> super::ivar::private::Sealed for IvarDrop<Option<Id<T, O>>> {}
+impl<T: ?Sized + Message, O: Ownership> super::ivar::private::Sealed
+    for IvarDrop<Option<Id<T, O>>>
+{
+}
 // SAFETY: `Id<T, O>` guarantees the null-pointer optimization.
 //
 // This is valid to initialize as all-zeroes, so the user doesn't have to do
 // anything to initialize it.
-unsafe impl<T: Message, O: Ownership> InnerIvarType for IvarDrop<Option<Id<T, O>>> {
+unsafe impl<T: ?Sized + Message, O: Ownership> InnerIvarType for IvarDrop<Option<Id<T, O>>> {
     const __ENCODING: Encoding = <*const T as EncodeConvert>::__ENCODING;
 
     type __Inner = Option<Id<T, O>>;

objc2/src/foundation/array.rs

@@ -52,29 +52,29 @@ __inner_extern_class!(
     // `T: PartialEq` bound correct because `NSArray` does deep (instead of
     // shallow) equality comparisons.
     #[derive(PartialEq, Eq, Hash)]
-    pub struct NSArray<T: Message, O: Ownership = Shared> {
+    pub struct NSArray<T: ?Sized + Message, O: Ownership = Shared> {
         item: PhantomData<Id<T, O>>,
         notunwindsafe: PhantomData<&'static mut ()>,
     }
 
-    unsafe impl<T: Message, O: Ownership> ClassType for NSArray<T, O> {
+    unsafe impl<T: ?Sized + Message, O: Ownership> ClassType for NSArray<T, O> {
         type Super = NSObject;
     }
 );
 
 // SAFETY: Same as Id<T, O> (which is what NSArray effectively stores).
-unsafe impl<T: Message + Sync + Send> Sync for NSArray<T, Shared> {}
-unsafe impl<T: Message + Sync + Send> Send for NSArray<T, Shared> {}
-unsafe impl<T: Message + Sync> Sync for NSArray<T, Owned> {}
-unsafe impl<T: Message + Send> Send for NSArray<T, Owned> {}
+unsafe impl<T: ?Sized + Message + Sync + Send> Sync for NSArray<T, Shared> {}
+unsafe impl<T: ?Sized + Message + Sync + Send> Send for NSArray<T, Shared> {}
+unsafe impl<T: ?Sized + Message + Sync> Sync for NSArray<T, Owned> {}
+unsafe impl<T: ?Sized + Message + Send> Send for NSArray<T, Owned> {}
 
 // Also same as Id<T, O>
-impl<T: Message + RefUnwindSafe, O: Ownership> RefUnwindSafe for NSArray<T, O> {}
-impl<T: Message + RefUnwindSafe> UnwindSafe for NSArray<T, Shared> {}
-impl<T: Message + UnwindSafe> UnwindSafe for NSArray<T, Owned> {}
+impl<T: ?Sized + Message + RefUnwindSafe, O: Ownership> RefUnwindSafe for NSArray<T, O> {}
+impl<T: ?Sized + Message + RefUnwindSafe> UnwindSafe for NSArray<T, Shared> {}
+impl<T: ?Sized + Message + UnwindSafe> UnwindSafe for NSArray<T, Owned> {}
 
 #[track_caller]
-pub(crate) unsafe fn with_objects<T: Message + ?Sized, R: Message, O: Ownership>(
+pub(crate) unsafe fn with_objects<T: ?Sized + Message, R: ?Sized + Message, O: Ownership>(
     cls: &Class,
     objects: &[&T],
 ) -> Id<R, O> {
@@ -89,7 +89,7 @@ pub(crate) unsafe fn with_objects<T: Message + ?Sized, R: Message, O: Ownership>
 
 extern_methods!(
     /// Generic creation methods.
-    unsafe impl<T: Message, O: Ownership> NSArray<T, O> {
+    unsafe impl<T: ?Sized + Message, O: Ownership> NSArray<T, O> {
         /// Get an empty array.
         pub fn new() -> Id<Self, Shared> {
             // SAFETY:
@@ -120,7 +120,7 @@ extern_methods!(
     }
 
     /// Creation methods that produce shared arrays.
-    unsafe impl<T: Message> NSArray<T, Shared> {
+    unsafe impl<T: ?Sized + Message> NSArray<T, Shared> {
         pub fn from_slice(slice: &[Id<T, Shared>]) -> Id<Self, Shared> {
             // SAFETY: Taking `&T` would not be sound, since the `&T` could come
             // from an `Id<T, Owned>` that would now no longer be owned!
@@ -133,7 +133,7 @@ extern_methods!(
     }
 
     /// Generic accessor methods.
-    unsafe impl<T: Message, O: Ownership> NSArray<T, O> {
+    unsafe impl<T: ?Sized + Message, O: Ownership> NSArray<T, O> {
         #[doc(alias = "count")]
         #[sel(count)]
         pub fn len(&self) -> usize;
@@ -200,7 +200,7 @@ extern_methods!(
     }
 
     /// Accessor methods that work on shared arrays.
-    unsafe impl<T: Message> NSArray<T, Shared> {
+    unsafe impl<T: ?Sized + Message> NSArray<T, Shared> {
         #[doc(alias = "objectAtIndex:")]
         pub fn get_retained(&self, index: usize) -> Id<T, Shared> {
             let obj = self.get(index).unwrap();
@@ -217,7 +217,7 @@ extern_methods!(
     }
 
     /// Accessor methods that work on owned arrays.
-    unsafe impl<T: Message> NSArray<T, Owned> {
+    unsafe impl<T: ?Sized + Message> NSArray<T, Owned> {
         #[doc(alias = "objectAtIndex:")]
         pub fn get_mut(&mut self, index: usize) -> Option<&mut T> {
             // TODO: Replace this check with catching the thrown NSRangeException
@@ -242,28 +242,28 @@ extern_methods!(
 /// This is implemented as a shallow copy.
 ///
 /// As such, it is only possible when the array's contents are `Shared`.
-unsafe impl<T: Message> NSCopying for NSArray<T, Shared> {
+unsafe impl<T: ?Sized + Message> NSCopying for NSArray<T, Shared> {
     type Ownership = Shared;
     type Output = NSArray<T, Shared>;
 }
 
 /// This is implemented as a shallow copy.
-unsafe impl<T: Message> NSMutableCopying for NSArray<T, Shared> {
+unsafe impl<T: ?Sized + Message> NSMutableCopying for NSArray<T, Shared> {
     type Output = NSMutableArray<T, Shared>;
 }
 
-impl<T: Message> alloc::borrow::ToOwned for NSArray<T, Shared> {
+impl<T: ?Sized + Message> alloc::borrow::ToOwned for NSArray<T, Shared> {
     type Owned = Id<NSArray<T, Shared>, Shared>;
     fn to_owned(&self) -> Self::Owned {
         self.copy()
     }
 }
 
-unsafe impl<T: Message, O: Ownership> NSFastEnumeration for NSArray<T, O> {
+unsafe impl<T: ?Sized + Message, O: Ownership> NSFastEnumeration for NSArray<T, O> {
     type Item = T;
 }
 
-impl<'a, T: Message, O: Ownership> IntoIterator for &'a NSArray<T, O> {
+impl<'a, T: ?Sized + Message, O: Ownership> IntoIterator for &'a NSArray<T, O> {
     type Item = &'a T;
     type IntoIter = NSFastEnumerator<'a, NSArray<T, O>>;
 
@@ -272,21 +272,21 @@ impl<'a, T: Message, O: Ownership> IntoIterator for &'a NSArray<T, O> {
     }
 }
 
-impl<T: Message, O: Ownership> Index<usize> for NSArray<T, O> {
+impl<T: ?Sized + Message, O: Ownership> Index<usize> for NSArray<T, O> {
     type Output = T;
 
     fn index(&self, index: usize) -> &T {
         self.get(index).unwrap()
     }
 }
 
-impl<T: Message> IndexMut<usize> for NSArray<T, Owned> {
+impl<T: ?Sized + Message> IndexMut<usize> for NSArray<T, Owned> {
     fn index_mut(&mut self, index: usize) -> &mut T {
         self.get_mut(index).unwrap()
     }
 }
 
-impl<T: Message, O: Ownership> DefaultId for NSArray<T, O> {
+impl<T: ?Sized + Message, O: Ownership> DefaultId for NSArray<T, O> {
     type Ownership = Shared;
 
     #[inline]
@@ -295,7 +295,7 @@ impl<T: Message, O: Ownership> DefaultId for NSArray<T, O> {
     }
 }
 
-impl<T: fmt::Debug + Message, O: Ownership> fmt::Debug for NSArray<T, O> {
+impl<T: ?Sized + fmt::Debug + Message, O: Ownership> fmt::Debug for NSArray<T, O> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.iter_fast()).finish()

objc2/src/foundation/copying.rs

@@ -28,7 +28,7 @@ pub unsafe trait NSCopying: Message {
     ///
     /// This is usually `Self`, but e.g. `NSMutableString` returns `NSString`.
     /// TODO: Verify???
-    type Output: Message;
+    type Output: ?Sized + Message;
 
     fn copy(&self) -> Id<Self::Output, Self::Ownership> {
         unsafe { msg_send_id![self, copy] }
@@ -40,7 +40,7 @@ pub unsafe trait NSCopying: Message {
 /// Note that the `mutableCopy` selector must return an owned object!
 pub unsafe trait NSMutableCopying: Message {
     /// TODO
-    type Output: Message;
+    type Output: ?Sized + Message;
 
     fn mutable_copy(&self) -> Id<Self::Output, Owned> {
         unsafe { msg_send_id![self, mutableCopy] }