Relax Sized bound on Id to better allow extern types

Author: madsmtm

objc2/CHANGELOG.md

@@ -36,6 +36,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - `Class::instance_variables`
   - `Protocol::protocols`
   - `Protocol::adopted_protocols`
+* Relaxed `Sized` bound on `rc::Id` and `rc::WeakId` to prepare for
+  `extern type` support.
+* **BREAKING**: Relaxed `Sized` bound on `rc::SliceId` and `rc::DefaultId`.
 
 ### Removed
 * **BREAKING**: Removed the raw FFI functions from the `runtime` module. These

objc2/src/message/mod.rs

@@ -79,7 +79,7 @@ pub(crate) mod private {
     impl<'a, T: Message + ?Sized> Sealed for &'a T {}
     impl<'a, T: Message + ?Sized> Sealed for &'a mut T {}
     impl<T: Message + ?Sized> Sealed for NonNull<T> {}
-    impl<T: Message, O: Ownership> Sealed for Id<T, O> {}
+    impl<T: Message + ?Sized, O: Ownership> Sealed for Id<T, O> {}
 
     impl<T: MessageReceiver + ?Sized> Sealed for ManuallyDrop<T> {}
 }
@@ -248,7 +248,7 @@ unsafe impl<T: Message + ?Sized> MessageReceiver for NonNull<T> {
     }
 }
 
-unsafe impl<T: Message, O: Ownership> MessageReceiver for Id<T, O> {
+unsafe impl<T: Message + ?Sized, O: Ownership> MessageReceiver for Id<T, O> {
     #[inline]
     fn as_raw_receiver(&self) -> *mut Object {
         // TODO: Maybe don't dereference here, just to be safe?

objc2/src/rc/autorelease.rs

@@ -101,7 +101,7 @@ impl AutoreleasePool {
     /// the lifetime is bound to the pool instead of being unbounded.
     #[inline]
     #[allow(clippy::needless_lifetimes)]
-    pub unsafe fn ptr_as_ref<'p, T>(&'p self, ptr: *const T) -> &'p T {
+    pub unsafe fn ptr_as_ref<'p, T: ?Sized>(&'p self, ptr: *const T) -> &'p T {
         self.__verify_is_inner();
         // SAFETY: Checked by the caller
         unsafe { &*ptr }
@@ -122,7 +122,7 @@ impl AutoreleasePool {
     #[inline]
     #[allow(clippy::needless_lifetimes)]
     #[allow(clippy::mut_from_ref)]
-    pub unsafe fn ptr_as_mut<'p, T>(&'p self, ptr: *mut T) -> &'p mut T {
+    pub unsafe fn ptr_as_mut<'p, T: ?Sized>(&'p self, ptr: *mut T) -> &'p mut T {
         self.__verify_is_inner();
         // SAFETY: Checked by the caller
         unsafe { &mut *ptr }

objc2/src/rc/id.rs

@@ -53,6 +53,9 @@ use crate::Message;
 /// do so. If you need to run some code when the object is destroyed,
 /// implement the `dealloc` method instead.
 ///
+/// This allows `?Sized` types `T`, but the intention is to only support when
+/// `T` is an `extern type` (yet unstable).
+///
 /// # Examples
 ///
 /// ```no_run
@@ -95,9 +98,9 @@ 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
+// 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, O: Ownership> {
+pub struct Id<T: ?Sized, 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
@@ -116,8 +119,7 @@ pub struct Id<T, O: Ownership> {
     own: PhantomData<O>,
 }
 
-// TODO: Maybe make most of these functions "associated" functions instead?
-impl<T: Message, O: Ownership> Id<T, O> {
+impl<T: Message + ?Sized, O: Ownership> 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
@@ -171,7 +173,10 @@ impl<T: Message, O: Ownership> Id<T, O> {
             own: PhantomData,
         }
     }
+}
 
+// TODO: Add ?Sized bound
+impl<T: Message, O: Ownership> Id<T, O> {
     /// Retains the given object pointer.
     ///
     /// This is useful when you have been given a pointer to an object from
@@ -254,6 +259,7 @@ impl<T: Message, O: Ownership> Id<T, O> {
 //     }
 // }
 
+// TODO: Add ?Sized bound
 impl<T: Message> Id<T, Owned> {
     /// Autoreleases the owned [`Id`], returning a mutable reference bound to
     /// the pool.
@@ -291,6 +297,7 @@ impl<T: Message> Id<T, Owned> {
     }
 }
 
+// TODO: Add ?Sized bound
 impl<T: Message> Id<T, Shared> {
     /// Autoreleases the shared [`Id`], returning an aliased reference bound
     /// to the pool.
@@ -308,7 +315,7 @@ impl<T: Message> Id<T, Shared> {
     }
 }
 
-impl<T: Message> From<Id<T, Owned>> for Id<T, Shared> {
+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]
     fn from(obj: Id<T, Owned>) -> Self {
@@ -318,6 +325,7 @@ impl<T: Message> From<Id<T, Owned>> for Id<T, Shared> {
     }
 }
 
+// TODO: Add ?Sized bound
 impl<T: Message> Clone for Id<T, Shared> {
     /// Makes a clone of the shared object.
     ///
@@ -338,7 +346,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, O: Ownership> Drop for Id<T, O> {
+impl<T: ?Sized, O: Ownership> Drop for Id<T, O> {
     /// Releases the retained object.
     ///
     /// The contained object's destructor (if it has one) is never run!
@@ -363,25 +371,25 @@ impl<T, O: Ownership> Drop for Id<T, O> {
 /// clone a `Id<T, Shared>`, send it to another thread, and drop the clone
 /// last, making `dealloc` get called on the other thread, and violate
 /// `T: !Send`.
-unsafe impl<T: Sync + Send> Send for Id<T, Shared> {}
+unsafe impl<T: Sync + Send + ?Sized> Send for Id<T, Shared> {}
 
 /// The `Sync` implementation requires `T: Sync` because `&Id<T, Shared>` give
 /// access to `&T`.
 ///
 /// Additiontally, it requires `T: Send`, because if `T: !Send`, you could
 /// clone a `&Id<T, Shared>` from another thread, and drop the clone last,
 /// making `dealloc` get called on the other thread, and violate `T: !Send`.
-unsafe impl<T: Sync + Send> Sync for Id<T, Shared> {}
+unsafe impl<T: Sync + Send + ?Sized> Sync for Id<T, Shared> {}
 
 /// `Id<T, Owned>` are `Send` if `T` is `Send` because they give the same
 /// access as having a T directly.
-unsafe impl<T: Send> Send for Id<T, Owned> {}
+unsafe impl<T: Send + ?Sized> Send for Id<T, Owned> {}
 
 /// `Id<T, Owned>` are `Sync` if `T` is `Sync` because they give the same
 /// access as having a `T` directly.
-unsafe impl<T: Sync> Sync for Id<T, Owned> {}
+unsafe impl<T: Sync + ?Sized> Sync for Id<T, Owned> {}
 
-impl<T, O: Ownership> Deref for Id<T, O> {
+impl<T: ?Sized, O: Ownership> Deref for Id<T, O> {
     type Target = T;
 
     /// Obtain an immutable reference to the object.
@@ -393,7 +401,7 @@ impl<T, O: Ownership> Deref for Id<T, O> {
     }
 }
 
-impl<T> DerefMut for Id<T, Owned> {
+impl<T: ?Sized> DerefMut for Id<T, Owned> {
     /// Obtain a mutable reference to the object.
     #[inline]
     fn deref_mut(&mut self) -> &mut T {
@@ -404,7 +412,7 @@ impl<T> DerefMut for Id<T, Owned> {
     }
 }
 
-impl<T, O: Ownership> fmt::Pointer for Id<T, O> {
+impl<T: ?Sized, O: Ownership> fmt::Pointer for Id<T, O> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Pointer::fmt(&self.ptr.as_ptr(), f)
     }
@@ -414,15 +422,15 @@ impl<T, 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.
-impl<T, O: Ownership> Unpin for Id<T, O> {}
+impl<T: ?Sized, O: Ownership> Unpin for Id<T, O> {}
 
-impl<T: RefUnwindSafe, O: Ownership> RefUnwindSafe for Id<T, O> {}
+impl<T: RefUnwindSafe + ?Sized, O: Ownership> RefUnwindSafe for Id<T, O> {}
 
 // Same as `Arc<T>`.
-impl<T: RefUnwindSafe> UnwindSafe for Id<T, Shared> {}
+impl<T: RefUnwindSafe + ?Sized> UnwindSafe for Id<T, Shared> {}
 
 // Same as `Box<T>`.
-impl<T: UnwindSafe> UnwindSafe for Id<T, Owned> {}
+impl<T: UnwindSafe + ?Sized> UnwindSafe for Id<T, Owned> {}
 
 #[cfg(test)]
 mod tests {

objc2/src/rc/id_forwarding_impls.rs

@@ -21,7 +21,7 @@ use std::io;
 
 use super::{Id, Owned, Ownership};
 
-impl<T: PartialEq, O: Ownership> PartialEq for Id<T, O> {
+impl<T: PartialEq + ?Sized, O: Ownership> PartialEq for Id<T, O> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
         (**self).eq(&**other)
@@ -34,9 +34,9 @@ impl<T: PartialEq, O: Ownership> PartialEq for Id<T, O> {
     }
 }
 
-impl<T: Eq, O: Ownership> Eq for Id<T, O> {}
+impl<T: Eq + ?Sized, O: Ownership> Eq for Id<T, O> {}
 
-impl<T: PartialOrd, O: Ownership> PartialOrd for Id<T, O> {
+impl<T: PartialOrd + ?Sized, O: Ownership> PartialOrd for Id<T, O> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         (**self).partial_cmp(&**other)
@@ -59,20 +59,20 @@ impl<T: PartialOrd, O: Ownership> PartialOrd for Id<T, O> {
     }
 }
 
-impl<T: Ord, O: Ownership> Ord for Id<T, O> {
+impl<T: Ord + ?Sized, O: Ownership> Ord for Id<T, O> {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         (**self).cmp(&**other)
     }
 }
 
-impl<T: hash::Hash, O: Ownership> hash::Hash for Id<T, O> {
+impl<T: hash::Hash + ?Sized, O: Ownership> hash::Hash for Id<T, O> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         (**self).hash(state)
     }
 }
 
-impl<T: hash::Hasher> hash::Hasher for Id<T, Owned> {
+impl<T: hash::Hasher + ?Sized> hash::Hasher for Id<T, Owned> {
     fn finish(&self) -> u64 {
         (**self).finish()
     }
@@ -117,19 +117,19 @@ impl<T: hash::Hasher> hash::Hasher for Id<T, Owned> {
     }
 }
 
-impl<T: fmt::Display, O: Ownership> fmt::Display for Id<T, O> {
+impl<T: fmt::Display + ?Sized, O: Ownership> fmt::Display for Id<T, O> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         (**self).fmt(f)
     }
 }
 
-impl<T: fmt::Debug, O: Ownership> fmt::Debug for Id<T, O> {
+impl<T: fmt::Debug + ?Sized, O: Ownership> fmt::Debug for Id<T, O> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         (**self).fmt(f)
     }
 }
 
-impl<I: Iterator> Iterator for Id<I, Owned> {
+impl<I: Iterator + ?Sized> Iterator for Id<I, Owned> {
     type Item = I::Item;
     fn next(&mut self) -> Option<I::Item> {
         (**self).next()
@@ -142,7 +142,7 @@ impl<I: Iterator> Iterator for Id<I, Owned> {
     }
 }
 
-impl<I: DoubleEndedIterator> DoubleEndedIterator for Id<I, Owned> {
+impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for Id<I, Owned> {
     fn next_back(&mut self) -> Option<I::Item> {
         (**self).next_back()
     }
@@ -151,13 +151,13 @@ impl<I: DoubleEndedIterator> DoubleEndedIterator for Id<I, Owned> {
     }
 }
 
-impl<I: ExactSizeIterator> ExactSizeIterator for Id<I, Owned> {
+impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Id<I, Owned> {
     fn len(&self) -> usize {
         (**self).len()
     }
 }
 
-impl<I: FusedIterator> FusedIterator for Id<I, Owned> {}
+impl<I: FusedIterator + ?Sized> FusedIterator for Id<I, Owned> {}
 
 impl<T, O: Ownership> borrow::Borrow<T> for Id<T, O> {
     fn borrow(&self) -> &T {
@@ -171,25 +171,25 @@ impl<T> borrow::BorrowMut<T> for Id<T, Owned> {
     }
 }
 
-impl<T, O: Ownership> AsRef<T> for Id<T, O> {
+impl<T: ?Sized, O: Ownership> AsRef<T> for Id<T, O> {
     fn as_ref(&self) -> &T {
         &**self
     }
 }
 
-impl<T> AsMut<T> for Id<T, Owned> {
+impl<T: ?Sized> AsMut<T> for Id<T, Owned> {
     fn as_mut(&mut self) -> &mut T {
         &mut **self
     }
 }
 
-impl<T: Error, O: Ownership> Error for Id<T, O> {
+impl<T: Error + ?Sized, O: Ownership> Error for Id<T, O> {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         (**self).source()
     }
 }
 
-impl<T: io::Read> io::Read for Id<T, Owned> {
+impl<T: io::Read + ?Sized> io::Read for Id<T, Owned> {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         (**self).read(buf)
@@ -216,7 +216,7 @@ impl<T: io::Read> io::Read for Id<T, Owned> {
     }
 }
 
-impl<T: io::Write> io::Write for Id<T, Owned> {
+impl<T: io::Write + ?Sized> io::Write for Id<T, Owned> {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         (**self).write(buf)
@@ -243,7 +243,7 @@ impl<T: io::Write> io::Write for Id<T, Owned> {
     }
 }
 
-impl<T: io::Seek> io::Seek for Id<T, Owned> {
+impl<T: io::Seek + ?Sized> io::Seek for Id<T, Owned> {
     #[inline]
     fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
         (**self).seek(pos)
@@ -255,7 +255,7 @@ impl<T: io::Seek> io::Seek for Id<T, Owned> {
     }
 }
 
-impl<T: io::BufRead> io::BufRead for Id<T, Owned> {
+impl<T: io::BufRead + ?Sized> io::BufRead for Id<T, Owned> {
     #[inline]
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
         (**self).fill_buf()
@@ -277,7 +277,7 @@ impl<T: io::BufRead> io::BufRead for Id<T, Owned> {
     }
 }
 
-impl<T: Future + Unpin> Future for Id<T, Owned> {
+impl<T: Future + Unpin + ?Sized> Future for Id<T, Owned> {
     type Output = T::Output;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {