Improve monomorphization of message sending with debug assertions

Author: madsmtm

crates/objc2/src/declare.rs

@@ -357,30 +357,32 @@ impl ClassBuilder {
         T: Message + ?Sized,
         F: MethodImplementation<Callee = T>,
     {
-        let encs = F::Args::ENCODINGS;
+        let enc_args = F::Args::ENCODINGS;
+        let enc_ret = F::Ret::ENCODING;
+
         let sel_args = count_args(sel);
         assert_eq!(
             sel_args,
-            encs.len(),
+            enc_args.len(),
             "Selector {:?} accepts {} arguments, but function accepts {}",
             sel,
             sel_args,
-            encs.len(),
+            enc_args.len(),
         );
 
         // Verify that, if the method is present on the superclass, that the
         // encoding is correct.
         #[cfg(debug_assertions)]
         if let Some(superclass) = self.superclass() {
             if let Some(method) = superclass.instance_method(sel) {
-                if let Err(err) = crate::verify::verify_method_signature::<F::Args, F::Ret>(method)
+                if let Err(err) = crate::verify::verify_method_signature(method, enc_args, &enc_ret)
                 {
                     panic!("declared invalid method -[{} {sel:?}]: {err}", self.name())
                 }
             }
         }
 
-        let types = method_type_encoding(&F::Ret::ENCODING, encs);
+        let types = method_type_encoding(&enc_ret, enc_args);
         let success = Bool::from_raw(unsafe {
             ffi::class_addMethod(
                 self.as_mut_ptr(),
@@ -412,30 +414,32 @@ impl ClassBuilder {
     where
         F: MethodImplementation<Callee = Class>,
     {
-        let encs = F::Args::ENCODINGS;
+        let enc_args = F::Args::ENCODINGS;
+        let enc_ret = F::Ret::ENCODING;
+
         let sel_args = count_args(sel);
         assert_eq!(
             sel_args,
-            encs.len(),
+            enc_args.len(),
             "Selector {:?} accepts {} arguments, but function accepts {}",
             sel,
             sel_args,
-            encs.len(),
+            enc_args.len(),
         );
 
         // Verify that, if the method is present on the superclass, that the
         // encoding is correct.
         #[cfg(debug_assertions)]
         if let Some(superclass) = self.superclass() {
             if let Some(method) = superclass.class_method(sel) {
-                if let Err(err) = crate::verify::verify_method_signature::<F::Args, F::Ret>(method)
+                if let Err(err) = crate::verify::verify_method_signature(method, enc_args, &enc_ret)
                 {
                     panic!("declared invalid method +[{} {sel:?}]: {err}", self.name())
                 }
             }
         }
 
-        let types = method_type_encoding(&F::Ret::ENCODING, encs);
+        let types = method_type_encoding(&enc_ret, enc_args);
         let success = Bool::from_raw(unsafe {
             ffi::class_addMethod(
                 self.metaclass_mut(),

crates/objc2/src/message/mod.rs

@@ -30,15 +30,48 @@ unsafe fn conditional_try<R: EncodeConvert>(f: impl FnOnce() -> R) -> R {
     f()
 }
 
+/// Help with monomorphizing in `icrate`
+#[cfg(debug_assertions)]
+#[track_caller]
+fn msg_send_check(
+    obj: Option<&Object>,
+    sel: Sel,
+    args: &[crate::encode::Encoding],
+    ret: &crate::encode::Encoding,
+) {
+    use crate::verify::{verify_method_signature, Inner, VerificationError};
+
+    let cls = if let Some(obj) = obj {
+        obj.class()
+    } else {
+        panic_null(sel)
+    };
+
+    let err = if let Some(method) = cls.instance_method(sel) {
+        if let Err(err) = verify_method_signature(method, args, ret) {
+            err
+        } else {
+            return;
+        }
+    } else {
+        VerificationError::from(Inner::MethodNotFound)
+    };
+
+    panic_verify(cls, sel, err);
+}
+
+#[cfg(debug_assertions)]
+#[track_caller]
+fn panic_null(sel: Sel) -> ! {
+    panic!("messsaging {sel:?} to nil")
+}
+
 #[cfg(debug_assertions)]
 #[track_caller]
 fn panic_verify(cls: &Class, sel: Sel, err: crate::VerificationError) -> ! {
     panic!(
-        "invalid message send to {}[{:?} {:?}]: {}",
+        "invalid message send to {}[{cls:?} {sel:?}]: {err}",
         if cls.is_metaclass() { "+" } else { "-" },
-        cls,
-        sel,
-        err
     )
 }
 
@@ -183,16 +216,8 @@ pub unsafe trait MessageReceiver: private::Sealed + Sized {
         #[cfg(debug_assertions)]
         {
             // SAFETY: Caller ensures only valid or NULL pointers.
-            let this = unsafe { this.as_ref() };
-            let cls = if let Some(this) = this {
-                this.class()
-            } else {
-                panic!("messsaging {:?} to nil", sel);
-            };
-
-            if let Err(err) = cls.verify_sel::<A, R>(sel) {
-                panic_verify(cls, sel, err);
-            }
+            let obj = unsafe { this.as_ref() };
+            msg_send_check(obj, sel, A::ENCODINGS, &R::__Inner::ENCODING);
         }
         unsafe { EncodeConvert::__from_inner(send_unverified(this, sel, args)) }
     }
@@ -230,7 +255,7 @@ pub unsafe trait MessageReceiver: private::Sealed + Sized {
         #[cfg(debug_assertions)]
         {
             if this.is_null() {
-                panic!("messsaging {:?} to nil", sel);
+                panic_null(sel);
             }
             if let Err(err) = superclass.verify_sel::<A, R>(sel) {
                 panic_verify(superclass, sel, err);

crates/objc2/src/runtime.rs

@@ -619,7 +619,7 @@ impl Class {
         R: EncodeConvert,
     {
         let method = self.instance_method(sel).ok_or(Inner::MethodNotFound)?;
-        verify_method_signature::<A, R>(method)
+        verify_method_signature(method, A::ENCODINGS, &R::__Inner::ENCODING)
     }
 }
 

crates/objc2/src/verify.rs

@@ -2,7 +2,7 @@ use core::fmt;
 use core::hash::Hash;
 use std::error::Error;
 
-use crate::encode::{Encode, EncodeArguments, EncodeConvert, Encoding, EncodingBox};
+use crate::encode::{Encoding, EncodingBox};
 use crate::runtime::{EncodingParseError, Method};
 
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -71,26 +71,25 @@ impl fmt::Display for VerificationError {
 
 impl Error for VerificationError {}
 
-pub(crate) fn verify_method_signature<A, R>(method: &Method) -> Result<(), VerificationError>
-where
-    A: EncodeArguments,
-    R: EncodeConvert,
-{
+pub(crate) fn verify_method_signature(
+    method: &Method,
+    args: &[Encoding],
+    ret: &Encoding,
+) -> Result<(), VerificationError> {
     let mut iter = method.types();
 
     // TODO: Verify stack layout
     let (expected, _stack_layout) = iter.extract_return()?;
-    let actual = R::__Inner::ENCODING;
-    if !actual.equivalent_to_box(&expected) {
-        return Err(Inner::MismatchedReturn(expected, actual).into());
+    if !ret.equivalent_to_box(&expected) {
+        return Err(Inner::MismatchedReturn(expected, ret.clone()).into());
     }
 
     iter.verify_receiver()?;
     iter.verify_sel()?;
 
-    let actual_count = A::ENCODINGS.len();
+    let actual_count = args.len();
 
-    for (i, actual) in A::ENCODINGS.iter().enumerate() {
+    for (i, actual) in args.iter().enumerate() {
         if let Some(res) = iter.next() {
             // TODO: Verify stack layout
             let (expected, _stack_layout) = res?;