Allow omitting the superclass in msg_send![super(...), ...]

Uses ClassType to get the superclass instead.

Author: madsmtm

objc2/CHANGELOG.md

@@ -21,6 +21,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   `NSData::class()`.
 * Added `Id::into_super`.
 * Added `extern_methods!` macro.
+* Added ability to call `msg_send![super(obj), ...]` without explicitly
+  specifying the superclass.
 
 ### Changed
 * **BREAKING**: Change syntax in `extern_class!` macro to be more Rust-like.

objc2/examples/delegate.rs

@@ -32,7 +32,7 @@ declare_class!(
     unsafe impl CustomAppDelegate {
         #[sel(initWith:another:)]
         fn init_with(self: &mut Self, ivar: u8, another_ivar: Bool) -> *mut Self {
-            let this: *mut Self = unsafe { msg_send![super(self, NSResponder::class()), init] };
+            let this: *mut Self = unsafe { msg_send![super(self), init] };
             if let Some(this) = unsafe { this.as_mut() } {
                 // TODO: Allow initialization through MaybeUninit
                 *this.ivar = ivar;

objc2/src/macros.rs

@@ -620,6 +620,10 @@ macro_rules! __class_inner {
 /// implements [`MessageReceiver`], like a reference or a pointer to an
 /// object, or even a reference to an [`rc::Id`] containing an object.
 ///
+/// The expression can be wrapped in `super`, with an optional superclass
+/// as the second argument. If no specific superclass is specified, the
+/// direct superclass is retrieved from [`ClassType`].
+///
 /// All arguments, and the return type, must implement [`Encode`].
 ///
 /// This macro translates into a call to [`sel!`], and afterwards a fully
@@ -633,6 +637,7 @@ macro_rules! __class_inner {
 ///
 /// [`MessageReceiver`]: crate::MessageReceiver
 /// [`rc::Id`]: crate::rc::Id
+/// [`ClassType`]: crate::ClassType
 /// [`Encode`]: crate::Encode
 /// [`sel!`]: crate::sel
 /// [`MessageReceiver::send_message`]: crate::MessageReceiver::send_message
@@ -691,25 +696,68 @@ macro_rules! __class_inner {
 ///
 /// # Examples
 ///
+/// Sending messages to an object.
+///
 /// ```no_run
-/// # use objc2::msg_send;
-/// # use objc2::runtime::Object;
+/// use objc2::msg_send;
+/// use objc2::runtime::Object;
+///
 /// let obj: *mut Object;
-/// # let obj: *mut Object = 0 as *mut Object;
+/// # obj = 0 as *mut Object;
 /// let description: *const Object = unsafe { msg_send![obj, description] };
 /// // Usually you'd use msg_send_id here ^
-/// let _: () = unsafe { msg_send![obj, setArg1: 1u32, arg2: 2i32] };
+/// let _: () = unsafe { msg_send![obj, setArg1: 1u32, arg2: 2u8] };
 /// let arg1: i32 = unsafe { msg_send![obj, getArg1] };
-/// let arg2: i32 = unsafe { msg_send![obj, getArg2] };
+/// let arg2: u8 = unsafe { msg_send![obj, getArg2] };
+/// ```
+///
+/// Sending messages to the direct superclass of an object.
+///
+/// ```no_run
+/// use objc2::msg_send;
+/// # use objc2::ns_string;
+/// # use objc2::foundation::{NSString as MyObject};
+///
+/// let obj: &MyObject; // Some object that implements ClassType
+/// # obj = ns_string!("");
+/// let _: () = unsafe { msg_send![super(obj), someMethod] };
+/// ```
+///
+/// Sending messages to a specific superclass of an object.
+///
+/// ```no_run
+/// # use objc2::class;
+/// use objc2::msg_send;
+/// use objc2::runtime::{Class, Object};
+///
+/// // Since we specify the superclass ourselves, this doesn't need to
+/// // implement ClassType
+/// let obj: *mut Object;
+/// # obj = 0 as *mut Object;
+/// let superclass: &Class;
+/// # superclass = class!(NSObject);
+/// let arg3: u32 = unsafe { msg_send![super(obj, superclass), getArg3] };
 /// ```
 #[macro_export]
 macro_rules! msg_send {
-    [super($obj:expr, $superclass:expr), $selector:ident $(,)?] => ({
+    [super($obj:expr), $selector:ident $(,)?] => ({
         let sel = $crate::sel!($selector);
         let result;
         // Note: `sel` and `result` can be accessed from the `obj` and
         // `superclass` expressions - we won't (yet) bother with preventing
         // that though.
+        result = $crate::MessageReceiver::__send_super_message_static($obj, sel, ());
+        result
+    });
+    [super($obj:expr), $($selector:ident : $argument:expr),+ $(,)?] => ({
+        let sel = $crate::sel!($($selector :)+);
+        let result;
+        result = $crate::MessageReceiver::__send_super_message_static($obj, sel, ($($argument,)+));
+        result
+    });
+    [super($obj:expr, $superclass:expr), $selector:ident $(,)?] => ({
+        let sel = $crate::sel!($selector);
+        let result;
         result = $crate::MessageReceiver::send_super_message($obj, $superclass, sel, ());
         result
     });

objc2/src/macros/declare_class.rs

@@ -253,7 +253,7 @@ macro_rules! __inner_declare_class {
 ///         #[sel(initWithFoo:)]
 ///         fn init_with(&mut self, foo: u8) -> Option<&mut Self> {
 ///             let this: Option<&mut Self> = unsafe {
-///                 msg_send![super(self, NSObject::class()), init]
+///                 msg_send![super(self), init]
 ///             };
 ///             this.map(|this| {
 ///                 // TODO: Initialization through MaybeUninit

objc2/src/message/mod.rs

@@ -4,7 +4,7 @@ use core::ptr::NonNull;
 
 use crate::rc::{Id, Owned, Ownership};
 use crate::runtime::{Class, Imp, Object, Sel};
-use crate::{Encode, EncodeArguments, RefEncode};
+use crate::{ClassType, Encode, EncodeArguments, RefEncode};
 
 #[cfg(feature = "catch-all")]
 #[track_caller]
@@ -136,11 +136,15 @@ pub(crate) mod private {
 /// This is mostly an implementation detail; you'll want to implement
 /// [`Message`] for your type instead.
 ///
+///
 /// # Safety
 ///
 /// This is a sealed trait, and should not need to be implemented. Open an
 /// issue if you know a use-case where this restrition should be lifted!
 pub unsafe trait MessageReceiver: private::Sealed + Sized {
+    #[doc(hidden)]
+    type __Inner: ?Sized;
+
     #[doc(hidden)]
     fn __as_raw_receiver(self) -> *mut Object;
 
@@ -155,6 +159,7 @@ pub unsafe trait MessageReceiver: private::Sealed + Sized {
     ///
     /// [runtime]: https://developer.apple.com/documentation/objectivec/objective-c_runtime?language=objc
     ///
+    ///
     /// # Safety
     ///
     /// This shares the same safety requirements as [`msg_send!`].
@@ -189,7 +194,7 @@ pub unsafe trait MessageReceiver: private::Sealed + Sized {
         unsafe { send_unverified(this, sel, args) }
     }
 
-    /// Sends a message to self's superclass with the given selector and
+    /// Sends a message to a specific superclass with the given selector and
     /// arguments.
     ///
     /// The correct version of `objc_msgSend_super` will be chosen based on the
@@ -201,6 +206,7 @@ pub unsafe trait MessageReceiver: private::Sealed + Sized {
     ///
     /// [runtime]: https://developer.apple.com/documentation/objectivec/objective-c_runtime?language=objc
     ///
+    ///
     /// # Safety
     ///
     /// This shares the same safety requirements as
@@ -229,33 +235,54 @@ pub unsafe trait MessageReceiver: private::Sealed + Sized {
         }
         unsafe { send_super_unverified(this, superclass, sel, args) }
     }
+
+    #[inline]
+    #[track_caller]
+    #[doc(hidden)]
+    unsafe fn __send_super_message_static<A, R>(self, sel: Sel, args: A) -> R
+    where
+        Self::__Inner: ClassType,
+        <Self::__Inner as ClassType>::Super: ClassType,
+        A: MessageArguments,
+        R: Encode,
+    {
+        unsafe { self.send_super_message(<Self::__Inner as ClassType>::Super::class(), sel, args) }
+    }
 }
 
 // Note that we implement MessageReceiver for unsized types as well, this is
 // to support `extern type`s in the future, not because we want to allow DSTs.
 
 unsafe impl<T: Message + ?Sized> MessageReceiver for *const T {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         (self as *mut T).cast()
     }
 }
 
 unsafe impl<T: Message + ?Sized> MessageReceiver for *mut T {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         self.cast()
     }
 }
 
 unsafe impl<T: Message + ?Sized> MessageReceiver for NonNull<T> {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         self.as_ptr().cast()
     }
 }
 
 unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a T {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         let ptr: *const T = self;
@@ -264,6 +291,8 @@ unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a T {
 }
 
 unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a mut T {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         let ptr: *mut T = self;
@@ -272,34 +301,44 @@ unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a mut T {
 }
 
 unsafe impl<'a, T: Message + ?Sized, O: Ownership> MessageReceiver for &'a Id<T, O> {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         (Id::as_ptr(self) as *mut T).cast()
     }
 }
 
 unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a mut Id<T, Owned> {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         Id::as_mut_ptr(self).cast()
     }
 }
 
 unsafe impl<T: Message + ?Sized, O: Ownership> MessageReceiver for ManuallyDrop<Id<T, O>> {
+    type __Inner = T;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         Id::consume_as_ptr(self).cast()
     }
 }
 
 unsafe impl MessageReceiver for *const Class {
+    type __Inner = Class;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         (self as *mut Class).cast()
     }
 }
 
 unsafe impl<'a> MessageReceiver for &'a Class {
+    type __Inner = Class;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         let ptr: *const Class = self;

objc2/src/rc/test_object.rs

@@ -77,25 +77,25 @@ declare_class!(
         #[sel(init)]
         fn init(&mut self) -> *mut Self {
             TEST_DATA.with(|data| data.borrow_mut().init += 1);
-            unsafe { msg_send![super(self, NSObject::class()), init] }
+            unsafe { msg_send![super(self), init] }
         }
 
         #[sel(retain)]
         fn retain(&self) -> *mut Self {
             TEST_DATA.with(|data| data.borrow_mut().retain += 1);
-            unsafe { msg_send![super(self, NSObject::class()), retain] }
+            unsafe { msg_send![super(self), retain] }
         }
 
         #[sel(release)]
         fn release(&self) {
             TEST_DATA.with(|data| data.borrow_mut().release += 1);
-            unsafe { msg_send![super(self, NSObject::class()), release] }
+            unsafe { msg_send![super(self), release] }
         }
 
         #[sel(autorelease)]
         fn autorelease(&self) -> *mut Self {
             TEST_DATA.with(|data| data.borrow_mut().autorelease += 1);
-            unsafe { msg_send![super(self, NSObject::class()), autorelease] }
+            unsafe { msg_send![super(self), autorelease] }
         }
 
         #[sel(dealloc)]
@@ -107,7 +107,7 @@ declare_class!(
         #[sel(_tryRetain)]
         unsafe fn try_retain(&self) -> Bool {
             TEST_DATA.with(|data| data.borrow_mut().try_retain += 1);
-            let res = unsafe { msg_send_bool![super(self, NSObject::class()), _tryRetain] };
+            let res = unsafe { msg_send_bool![super(self), _tryRetain] };
             if !res {
                 TEST_DATA.with(|data| data.borrow_mut().try_retain -= 1);
                 TEST_DATA.with(|data| data.borrow_mut().try_retain_fail += 1);

objc2/src/test_utils.rs

@@ -27,20 +27,26 @@ impl crate::message::private::Sealed for &mut CustomObject {}
 impl crate::message::private::Sealed for ManuallyDrop<CustomObject> {}
 
 unsafe impl MessageReceiver for &CustomObject {
+    type __Inner = Object;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         self.obj
     }
 }
 
 unsafe impl MessageReceiver for &mut CustomObject {
+    type __Inner = Object;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         self.obj
     }
 }
 
 unsafe impl MessageReceiver for ManuallyDrop<CustomObject> {
+    type __Inner = Object;
+
     #[inline]
     fn __as_raw_receiver(self) -> *mut Object {
         self.obj

objc2/tests/no_prelude.rs

@@ -95,18 +95,22 @@ pub fn test_class() {
     let _class = new_objc2::class!(NSObject);
 }
 
-pub fn test_msg_send(obj: &new_objc2::runtime::Object) {
+pub fn test_msg_send(obj: &new_objc2::foundation::NSString) {
     let superclass = obj.class().superclass().unwrap();
     let _: () = unsafe { new_objc2::msg_send![obj, a] };
     let _: () = unsafe { new_objc2::msg_send![obj, a: obj, b: obj] };
+    let _: () = unsafe { new_objc2::msg_send![super(obj), a] };
+    let _: () = unsafe { new_objc2::msg_send![super(obj), a: obj, b: obj] };
     let _: () = unsafe { new_objc2::msg_send![super(obj, superclass), a] };
     let _: () = unsafe { new_objc2::msg_send![super(obj, superclass), a: obj, b: obj] };
 }
 
-pub fn test_msg_send_bool(obj: &new_objc2::runtime::Object) {
+pub fn test_msg_send_bool(obj: &new_objc2::foundation::NSString) {
     let superclass = obj.class().superclass().unwrap();
     unsafe { new_objc2::msg_send_bool![obj, a] };
     unsafe { new_objc2::msg_send_bool![obj, a: obj, b: obj] };
+    unsafe { new_objc2::msg_send_bool![super(obj), a] };
+    unsafe { new_objc2::msg_send_bool![super(obj), a: obj, b: obj] };
     unsafe { new_objc2::msg_send_bool![super(obj, superclass), a] };
     unsafe { new_objc2::msg_send_bool![super(obj, superclass), a: obj, b: obj] };
 }

objc2/tests/use_macros.rs

@@ -1,3 +1,4 @@
+use objc2::foundation::NSString;
 use objc2::runtime::{Class, Object};
 use objc2::{class, msg_send, sel};
 
@@ -24,7 +25,7 @@ fn use_sel() {
 }
 
 #[allow(unused)]
-fn test_msg_send_comma_handling(obj: &Object, superclass: &Class) {
+fn test_msg_send_comma_handling(obj: &NSString, superclass: &Class) {
     unsafe {
         let _: () = msg_send![obj, a];
         let _: () = msg_send![obj, a,];
@@ -46,4 +47,13 @@ fn test_msg_send_comma_handling(obj: &Object, superclass: &Class) {
         let _: () = msg_send![super(obj, superclass), a: 32i32, b: 32i32];
         let _: () = msg_send![super(obj, superclass), a: 32i32, b: 32i32,];
     }
+
+    unsafe {
+        let _: () = msg_send![super(obj), a];
+        let _: () = msg_send![super(obj), a,];
+        let _: () = msg_send![super(obj), a: 32i32];
+        let _: () = msg_send![super(obj), a: 32i32,];
+        let _: () = msg_send![super(obj), a: 32i32, b: 32i32];
+        let _: () = msg_send![super(obj), a: 32i32, b: 32i32,];
+    }
 }