Add unstable-coerce-pointee Cargo feature

To experiment with the unstable #[derive(CoercePointee)].

Author: madsmtm

crates/block2/Cargo.toml

@@ -47,6 +47,9 @@ unstable-objfw = []
 # Expose private ffi functions and statics.
 unstable-private = []
 
+# Uses the nightly derive_coerce_pointee feature to make conversions more ergonomic.
+unstable-coerce-pointee = []
+
 [dependencies]
 objc2 = { path = "../objc2", version = "0.5.2", default-features = false, features = ["std"] }
 

crates/block2/src/lib.rs

@@ -303,6 +303,7 @@
 #![doc(html_root_url = "https://docs.rs/block2/0.5.1")]
 #![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide))]
 #![cfg_attr(docsrs, doc(cfg_hide(doc)))]
+#![cfg_attr(feature = "unstable-coerce-pointee", feature(derive_coerce_pointee))]
 
 #[cfg(not(feature = "alloc"))]
 compile_error!("The `alloc` feature currently must be enabled.");

crates/block2/src/rc_block.rs

@@ -31,6 +31,10 @@ use crate::{ffi, Block, IntoBlock, StackBlock};
 /// `RcBlock<A, R>`.
 #[repr(transparent)]
 #[doc(alias = "MallocBlock")]
+#[cfg_attr(
+    feature = "unstable-coerce-pointee",
+    derive(std::marker::CoercePointee)
+)]
 pub struct RcBlock<F: ?Sized> {
     // Covariant
     ptr: NonNull<Block<F>>,

crates/objc2/Cargo.toml

@@ -89,6 +89,9 @@ unstable-apple-new = []
 # ergonomic.
 unstable-arbitrary-self-types = []
 
+# Uses the nightly derive_coerce_pointee feature to make conversions more ergonomic.
+unstable-coerce-pointee = []
+
 # Deprecated; this is the default on Apple platforms, and not applicable on other platforms.
 apple = []
 

crates/objc2/src/lib.rs

@@ -153,6 +153,10 @@
     feature = "unstable-arbitrary-self-types",
     feature(arbitrary_self_types)
 )]
+#![cfg_attr(
+    feature = "unstable-coerce-pointee",
+    feature(derive_coerce_pointee, trait_upcasting)
+)]
 // Note: `doc_notable_trait` doesn't really make sense for us, it's only shown
 // for functions returning a specific trait.
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg, doc_cfg_hide))]

crates/objc2/src/rc/allocated_partial_init.rs

@@ -35,6 +35,10 @@ use crate::{DefinedClass, Message};
 /// object, `*const T`. The pointer may be NULL.
 #[repr(transparent)]
 #[derive(Debug)]
+#[cfg_attr(
+    feature = "unstable-coerce-pointee",
+    derive(std::marker::CoercePointee)
+)]
 pub struct Allocated<T: ?Sized> {
     /// The yet-to-be initialized object.
     ///

crates/objc2/src/rc/retained.rs

@@ -121,6 +121,10 @@ use crate::{ffi, ClassType, DowncastTarget, Message};
 #[doc(alias = "id")]
 #[doc(alias = "Id")]
 #[doc(alias = "StrongPtr")]
+#[cfg_attr(
+    feature = "unstable-coerce-pointee",
+    derive(std::marker::CoercePointee)
+)]
 // TODO: Add `ptr::Thin` bound on `T` to allow for only extern types
 pub struct Retained<T: ?Sized> {
     /// A pointer to the contained object. The pointer is always retained.
@@ -1014,4 +1018,35 @@ mod tests {
         let _: Retained<NSObject> = Into::into(obj_retained_ref);
         let _: Retained<AnyObject> = Into::into(obj_retained_ref);
     }
+
+    #[test]
+    #[cfg(feature = "unstable-coerce-pointee")]
+    fn test_coercion() {
+        use crate::{extern_protocol, ProtocolType};
+
+        extern_protocol!(
+            unsafe trait ExampleProtocol: NSObjectProtocol {}
+
+            unsafe impl ProtocolType for dyn ExampleProtocol {}
+        );
+
+        unsafe impl ExampleProtocol for RcTestObject {}
+
+        let obj = RcTestObject::new();
+        let mut expected = ThreadTestData::current();
+
+        let obj: Retained<dyn ExampleProtocol> = obj;
+        expected.assert_current();
+
+        let obj: Retained<dyn NSObjectProtocol> = obj;
+        expected.assert_current();
+
+        // TODO: Allow calling methods on trait objects like this.
+        // let _ = obj.hash();
+
+        drop(obj);
+        expected.release += 1;
+        expected.drop += 1;
+        expected.assert_current();
+    }
 }

crates/objc2/src/rc/test_object.rs

@@ -3,7 +3,7 @@ use core::cell::RefCell;
 use core::ptr;
 
 use crate::rc::{Allocated, DefaultRetained, Retained};
-use crate::runtime::{NSObject, NSZone};
+use crate::runtime::{NSObject, NSObjectProtocol, NSZone};
 use crate::{define_class, msg_send, msg_send_id, ClassType};
 
 // TODO: Put tests that use this in another crate
@@ -282,6 +282,8 @@ define_class!(
             }
         }
     }
+
+    unsafe impl NSObjectProtocol for RcTestObject {}
 );
 
 impl Drop for RcTestObject {

crates/objc2/src/rc/weak.rs

@@ -29,6 +29,7 @@ use crate::{ffi, Message};
 /// [`sync::Arc`]: std::sync::Arc
 #[repr(transparent)] // This is not a public guarantee
 #[doc(alias = "WeakId")]
+// TODO: Add derive(CoercePointee) once this doesn't Box internally.
 pub struct Weak<T: ?Sized> {
     /// We give the runtime the address to this box, so that it can modify it
     /// even if the `Weak` is moved.

crates/objc2/src/runtime/nsobject.rs

@@ -26,6 +26,9 @@ pub struct NSObject {
     __superclass: AnyObject,
 }
 
+// Would be _super_ nice to have this kind of impl, but that isn't possible.
+// impl Unsize<AnyObject> for NSObject {}
+
 crate::__extern_class_impl_traits! {
     ()
     (unsafe impl)