Support super in msg_send_id

Author: madsmtm

objc2/src/macros.rs

@@ -203,6 +203,28 @@ macro_rules! msg_send_bool {
 /// TODO
 #[macro_export]
 macro_rules! msg_send_id {
+    (super($obj:expr, $superclass:expr), $name:ident) => ({
+        let sel = $crate::sel!($name);
+        const NAME: &[u8] = stringify!($name).as_bytes();
+        use $crate::rc::{__Assert, __MsgSendId};
+        $crate::__msg_send_inner! {
+            @id NAME,
+            $crate::__msg_send_inner! {
+                @call <__Assert<ALLOC, INIT, RETAINED>>::__send_super_message_id($obj, $superclass, sel, ())
+            }
+        }
+    });
+    (super($obj:expr, $superclass:expr), $($name:ident: $arg:expr),+ $(,)?) => ({
+        let sel = $crate::sel!($($name:)+);
+        const NAME: &[u8] = concat!($(stringify!($name), ':'),+).as_bytes();
+        use $crate::rc::{__Assert, __MsgSendId};
+        $crate::__msg_send_inner! {
+            @id NAME,
+            $crate::__msg_send_inner! {
+                @call <__Assert<ALLOC, INIT, RETAINED>>::__send_super_message_id($obj, $superclass, sel, ($($arg,)+))
+            }
+        }
+    });
     ($obj:expr, $name:ident) => ({
         let sel = $crate::sel!($name);
         const NAME: &[u8] = stringify!($name).as_bytes();

objc2/src/rc/alloc.rs

@@ -27,6 +27,13 @@ pub trait __MsgSendId<T, U> {
         sel: Sel,
         args: A,
     ) -> Result<U, MessageError>;
+
+    unsafe fn __send_super_message_id<A: MessageArguments>(
+        obj: T,
+        superclass: &Class,
+        sel: Sel,
+        args: A,
+    ) -> Result<U, MessageError>;
 }
 
 impl<T: ?Sized + Message, O: Ownership> __MsgSendId<&'_ Class, Id<Allocated<T>, O>>
@@ -43,6 +50,19 @@ impl<T: ?Sized + Message, O: Ownership> __MsgSendId<&'_ Class, Id<Allocated<T>,
                 .map(|r| Id::new(r).expect("Failed allocating"))
         }
     }
+
+    #[inline(always)]
+    unsafe fn __send_super_message_id<A: MessageArguments>(
+        cls: &Class,
+        superclass: &Class,
+        sel: Sel,
+        args: A,
+    ) -> Result<Id<Allocated<T>, O>, MessageError> {
+        unsafe {
+            MessageReceiver::send_super_message(&cls, superclass, sel, args)
+                .map(|r| Id::new(r).expect("Failed allocating"))
+        }
+    }
 }
 
 impl<T: ?Sized + Message, O: Ownership> __MsgSendId<Id<Allocated<T>, O>, Option<Id<T, O>>>
@@ -57,6 +77,19 @@ impl<T: ?Sized + Message, O: Ownership> __MsgSendId<Id<Allocated<T>, O>, Option<
         let obj = ManuallyDrop::new(obj);
         unsafe { MessageReceiver::send_message(&obj, sel, args).map(|r| Id::new(r)) }
     }
+
+    #[inline(always)]
+    unsafe fn __send_super_message_id<A: MessageArguments>(
+        obj: Id<Allocated<T>, O>,
+        superclass: &Class,
+        sel: Sel,
+        args: A,
+    ) -> Result<Option<Id<T, O>>, MessageError> {
+        let obj = ManuallyDrop::new(obj);
+        unsafe {
+            MessageReceiver::send_super_message(&obj, superclass, sel, args).map(|r| Id::new(r))
+        }
+    }
 }
 
 impl<T: MessageReceiver, U: ?Sized + Message, O: Ownership> __MsgSendId<T, Option<Id<U, O>>>
@@ -70,6 +103,18 @@ impl<T: MessageReceiver, U: ?Sized + Message, O: Ownership> __MsgSendId<T, Optio
     ) -> Result<Option<Id<U, O>>, MessageError> {
         unsafe { MessageReceiver::send_message(&obj, sel, args).map(|r| Id::new(r)) }
     }
+
+    #[inline(always)]
+    unsafe fn __send_super_message_id<A: MessageArguments>(
+        obj: T,
+        superclass: &Class,
+        sel: Sel,
+        args: A,
+    ) -> Result<Option<Id<U, O>>, MessageError> {
+        unsafe {
+            MessageReceiver::send_super_message(&obj, superclass, sel, args).map(|r| Id::new(r))
+        }
+    }
 }
 
 impl<T: MessageReceiver, U: Message, O: Ownership> __MsgSendId<T, Option<Id<U, O>>>
@@ -87,4 +132,19 @@ impl<T: MessageReceiver, U: Message, O: Ownership> __MsgSendId<T, Option<Id<U, O
             MessageReceiver::send_message(&obj, sel, args).map(|r| Id::retain_autoreleased(r))
         }
     }
+
+    #[inline(always)]
+    unsafe fn __send_super_message_id<A: MessageArguments>(
+        obj: T,
+        superclass: &Class,
+        sel: Sel,
+        args: A,
+    ) -> Result<Option<Id<U, O>>, MessageError> {
+        // All code between the message send and the `retain_autoreleased`
+        // must be able to be optimized away for this to work.
+        unsafe {
+            MessageReceiver::send_super_message(&obj, superclass, sel, args)
+                .map(|r| Id::retain_autoreleased(r))
+        }
+    }
 }