Implement Message and MessageReceiver for ManuallyDrop

Author: madsmtm

objc2/CHANGELOG.md

@@ -11,6 +11,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * Added common trait impls on `rc::Owned` and `rc::Shared` (useful in generic
   contexts).
 * Implement `RefEncode` for `runtime::Protocol`.
+* Added `Message` and `MessageReceiver` implementation for `ManuallyDrop<T>`
+  (where `T` is appropriately bound). This allows patterns like:
+  ```rust
+  let obj = Id::new(msg_send![class!(MyObject), alloc]);
+  let obj = ManuallyDrop::new(obj);
+  // `init` takes ownership and possibly returns a new object.
+  let obj = Id::new(msg_send![obj, init]);
+  ```
 
 ### Changed
 * Deprecated `runtime::BOOL`, `runtime::YES` and `runtime::NO`. Use the

objc2/src/message/mod.rs

@@ -1,6 +1,7 @@
 use alloc::string::{String, ToString};
 use core::fmt;
 use core::mem;
+use core::mem::ManuallyDrop;
 use core::ptr::NonNull;
 use std::error::Error;
 
@@ -57,13 +58,16 @@ use self::verify::{verify_message_signature, VerificationError};
 /// [`objc_msgSend`]: https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend
 pub unsafe trait Message: RefEncode {}
 
+// SAFETY: `ManuallyDrop` is `repr(transparent)`.
+unsafe impl<T: Message + ?Sized> Message for ManuallyDrop<T> {}
+
 unsafe impl Message for Object {}
 
 unsafe impl Message for Class {}
 
 // TODO: Make this fully private
 pub(crate) mod private {
-    use super::{Id, Message, NonNull, Ownership};
+    use super::{Id, ManuallyDrop, Message, MessageReceiver, NonNull, Ownership};
 
     pub trait Sealed {}
 
@@ -74,6 +78,8 @@ pub(crate) mod private {
     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: MessageReceiver + ?Sized> Sealed for ManuallyDrop<T> {}
 }
 
 /// Types that can directly be used as the receiver of Objective-C messages.
@@ -247,6 +253,13 @@ unsafe impl<T: Message, O: Ownership> MessageReceiver for Id<T, O> {
     }
 }
 
+unsafe impl<T: MessageReceiver + ?Sized> MessageReceiver for ManuallyDrop<T> {
+    #[inline]
+    fn as_raw_receiver(&self) -> *mut Object {
+        (**self).as_raw_receiver()
+    }
+}
+
 /// Types that may be used as the arguments of an Objective-C message.
 ///
 /// This is implemented for tuples of up to 12 arguments, where each argument
@@ -419,6 +432,21 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_send_message_manuallydrop() {
+        let obj = test_utils::custom_object();
+        let obj = ManuallyDrop::new(obj);
+        let result: u32 = unsafe {
+            let _: () = msg_send![obj, setFoo: 4u32];
+            msg_send![obj, foo]
+        };
+        assert_eq!(result, 4);
+
+        let obj: *const ManuallyDrop<Object> = (&**obj as *const Object).cast();
+        let result: u32 = unsafe { msg_send![obj, foo] };
+        assert_eq!(result, 4);
+    }
+
     #[test]
     fn test_verify_message() {
         let obj = test_utils::custom_object();