Added "disable-encoding-assertions" Cargo feature flag

This allows completely disabling message encoding verification, to let
users resolve issues such as:
- #645
- #671

This is a hack, and ideally we should fix it in some other way (maybe
disabling in extern_methods! only?), but for now, this should at least
unblock the release.

Author: madsmtm

crates/objc2/CHANGELOG.md

@@ -39,6 +39,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   method family if need be.
 * Added `PartialEq`, `Eq`, `Hash`, `PartialOrd` and `Ord` implementations for
   `Bool`.
+* Added `"disable-encoding-assertions"` Cargo feature flag to allow completely
+  disabling encoding verification.
 
 ### Changed
 * **BREAKING**: Renamed `declare_class!` to `define_class!`, and changed the

crates/objc2/Cargo.toml

@@ -48,6 +48,21 @@ relax-void-encoding = []
 # instead of `UInt`.
 relax-sign-encoding = []
 
+# Fully disable debug assertions on invalid encodings.
+#
+# Sometimes, the method encoding registered with the runtime doesn't match the
+# encoding in the header. This happens for example in NSUUID methods, see:
+# https://github.com/madsmtm/objc2/issues/671
+#
+# Furthermore, sometimes a method may just not be visible to the runtime
+# before we actually send a message to it, see:
+# https://github.com/madsmtm/objc2/issues/645
+#
+# Ideally, `objc2`'s encoding checks should not encounter these issues, but
+# that is not the state we are in, so for now, this can be used to work around
+# them by disabling all encoding checks.
+disable-encoding-assertions = []
+
 # Enable deprecation of using `msg_send!` without a comma between arguments.
 unstable-msg-send-always-comma = []
 

crates/objc2/src/__macro_helpers/msg_send_retained.rs

@@ -656,10 +656,6 @@ mod tests {
     #[test]
     #[should_panic = "tried to initialize ivars after they were already initialized"]
     #[cfg_attr(not(debug_assertions), ignore = "only checked with debug assertions")]
-    #[cfg_attr(
-        debug_assertions,
-        ignore = "panicking in `init` requires that we emit the function as `C-unwind`"
-    )]
     fn test_super_init_not_initialized() {
         let obj = RcTestObject::alloc().set_ivars(());
         let _: Retained<RcTestObject> =

crates/objc2/src/macros/mod.rs

@@ -937,6 +937,9 @@ macro_rules! __class_inner {
 ///
 /// Panics if `debug_assertions` are enabled and the Objective-C method's
 /// encoding does not match the encoding of the given arguments and return.
+/// This behaviour can be tweaked with the `"relax-void-encoding"`,
+/// `"relax-sign-encoding"` or `"disable-encoding-assertions"` Cargo feature
+/// flags if it is causing you trouble.
 ///
 /// Finally, panics if the return type is specified as `Retained<_>`, but the
 /// method actually returned NULL. If this happens, you should change the

crates/objc2/src/runtime/define.rs

@@ -282,7 +282,7 @@ impl ClassBuilder {
 
         // Verify that, if the method is present on the superclass, that the
         // encoding is correct.
-        #[cfg(debug_assertions)]
+        #[cfg(all(debug_assertions, not(feature = "disable-encoding-assertions")))]
         if let Some(superclass) = self.superclass() {
             if let Some(method) = superclass.instance_method(sel) {
                 if let Err(err) = crate::verify::verify_method_signature(method, enc_args, enc_ret)
@@ -347,7 +347,7 @@ impl ClassBuilder {
 
         // Verify that, if the method is present on the superclass, that the
         // encoding is correct.
-        #[cfg(debug_assertions)]
+        #[cfg(all(debug_assertions, not(feature = "disable-encoding-assertions")))]
         if let Some(superclass) = self.superclass() {
             if let Some(method) = superclass.class_method(sel) {
                 if let Err(err) = crate::verify::verify_method_signature(method, enc_args, enc_ret)
@@ -681,7 +681,7 @@ mod tests {
 
     #[test]
     #[cfg_attr(
-        debug_assertions,
+        all(debug_assertions, not(feature = "disable-encoding-assertions")),
         should_panic = "defined invalid method -[TestClassBuilderInvalidMethod foo]: expected return to have type code 'I', but found 's'"
     )]
     fn invalid_method() {
@@ -699,7 +699,11 @@ mod tests {
 
     #[test]
     #[cfg_attr(
-        all(debug_assertions, not(feature = "relax-sign-encoding")),
+        all(
+            debug_assertions,
+            not(feature = "disable-encoding-assertions"),
+            not(feature = "relax-sign-encoding")
+        ),
         should_panic = "defined invalid method +[TestClassBuilderInvalidClassMethod classFoo]: expected return to have type code 'I', but found 'i'"
     )]
     fn invalid_class_method() {

crates/objc2/src/runtime/message_receiver.rs

@@ -316,6 +316,11 @@ fn msg_send_check_class(
     args: &[crate::encode::Encoding],
     ret: &crate::encode::Encoding,
 ) {
+    if cfg!(feature = "disable-encoding-assertions") {
+        // These checks are disabled.
+        return;
+    }
+
     use crate::verify::{verify_method_signature, Inner, VerificationError};
 
     let err = if let Some(method) = cls.instance_method(sel) {

crates/objc2/src/runtime/mod.rs

@@ -339,7 +339,7 @@ impl Ivar {
 
     #[inline]
     pub(crate) fn debug_assert_encoding(&self, _expected: &Encoding) {
-        #[cfg(debug_assertions)]
+        #[cfg(all(debug_assertions, not(feature = "disable-encoding-assertions")))]
         {
             let encoding = self.type_encoding();
             let encoding = encoding.to_str().expect("encoding must be UTF-8");
@@ -369,7 +369,8 @@ impl Ivar {
     /// # Panics
     ///
     /// Panics when `debug_assertions` are enabled if the type encoding of the
-    /// ivar differs from the type encoding of `T`.
+    /// ivar differs from the type encoding of `T`. This can be disabled with
+    /// the `"disable-encoding-assertions"` Cargo feature flag.
     ///
     ///
     /// # Safety
@@ -407,7 +408,8 @@ impl Ivar {
     /// # Panics
     ///
     /// Panics when `debug_assertions` are enabled if the type encoding of the
-    /// ivar differs from the type encoding of `T`.
+    /// ivar differs from the type encoding of `T`. This can be disabled with
+    /// the `"disable-encoding-assertions"` Cargo feature flag.
     ///
     ///
     /// # Safety
@@ -434,7 +436,8 @@ impl Ivar {
     /// # Panics
     ///
     /// Panics when `debug_assertions` are enabled if the type encoding of the
-    /// ivar differs from the type encoding of `T`.
+    /// ivar differs from the type encoding of `T`. This can be disabled with
+    /// the `"disable-encoding-assertions"` Cargo feature flag.
     ///
     ///
     /// # Safety
@@ -1717,7 +1720,7 @@ mod tests {
 
     #[test]
     #[cfg_attr(
-        debug_assertions,
+        all(debug_assertions, not(feature = "disable-encoding-assertions")),
         should_panic = "wrong encoding. Tried to retrieve ivar with encoding I, but the encoding of the given type was C"
     )]
     fn test_object_ivar_wrong_type() {

crates/objc2/src/verify.rs

@@ -227,15 +227,15 @@ mod tests {
     }
 
     #[test]
-    #[cfg(debug_assertions)]
+    #[cfg(all(debug_assertions, not(feature = "disable-encoding-assertions")))]
     #[should_panic = "invalid message send to -[CustomObject foo]: expected return to have type code 'I', but found '^i'"]
     fn test_send_message_verified() {
         let obj = test_utils::custom_object();
         let _: *const i32 = unsafe { msg_send![&obj, foo] };
     }
 
     #[test]
-    #[cfg(debug_assertions)]
+    #[cfg(all(debug_assertions, not(feature = "disable-encoding-assertions")))]
     #[should_panic = "invalid message send to +[CustomObject abcDef]: method not found"]
     fn test_send_message_verified_to_class() {
         let cls = test_utils::custom_class();
@@ -263,7 +263,11 @@ mod tests {
 
     #[test]
     #[cfg_attr(
-        all(debug_assertions, not(feature = "relax-void-encoding")),
+        all(
+            debug_assertions,
+            not(feature = "disable-encoding-assertions"),
+            not(feature = "relax-void-encoding")
+        ),
         should_panic = "invalid message send to -[CustomObject fooReference]: expected return to have type code '^I', but found '^v'"
     )]
     fn test_get_reference_void() {
@@ -276,7 +280,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(debug_assertions)]
+    #[cfg(all(debug_assertions, not(feature = "disable-encoding-assertions")))]
     #[should_panic = "invalid message send to -[CustomObject foo]: expected return to have type code 'I', but found '^v'"]
     fn test_get_integer_void() {
         let obj = test_utils::custom_object();

crates/objc2/tests/track_caller.rs

@@ -78,17 +78,19 @@ impl Drop for PanicChecker {
 fn test_track_caller() {
     let checker = PanicChecker::new();
 
-    #[cfg(debug_assertions)]
-    {
+    if cfg!(debug_assertions) {
         test_nil(&checker);
-        test_verify(&checker);
-        test_error_methods(&checker);
+        if cfg!(not(feature = "disable-encoding-assertions")) {
+            test_verify(&checker);
+            test_error_methods(&checker);
+        }
     }
 
     test_id_unwrap(&checker);
 
-    #[cfg(feature = "catch-all")]
-    test_catch_all(&checker);
+    if cfg!(feature = "catch-all") {
+        test_catch_all(&checker);
+    }
 
     test_unwind(&checker);
 

framework-crates/objc2-foundation/src/tests/uuid.rs

@@ -19,21 +19,15 @@ fn test_new() {
 }
 
 #[test]
-#[cfg_attr(
-    not(target_arch = "aarch64"),
-    ignore = "encoding depends on Foundation version"
-)]
+#[ignore = "encoding depends on Foundation version"]
 fn test_bytes() {
     let uuid = NSUUID::from_bytes([10; 16]);
     assert_eq!(uuid.as_bytes(), [10; 16]);
 }
 
 #[test]
 #[cfg(feature = "NSString")]
-#[cfg_attr(
-    not(target_arch = "aarch64"),
-    ignore = "encoding depends on Foundation version"
-)]
+#[ignore = "encoding depends on Foundation version"]
 fn display_debug() {
     let uuid = NSUUID::from_bytes([10; 16]);
     let expected = "0A0A0A0A-0A0A-0A0A-0A0A-0A0A0A0A0A0A";

framework-crates/objc2-foundation/src/uuid.rs

@@ -11,21 +11,15 @@ use crate::{util, NSUUID};
 impl UnwindSafe for NSUUID {}
 impl RefUnwindSafe for NSUUID {}
 
-/// The headers describe `initWithUUIDBytes:` and `getUUIDBytes:` as
-/// taking `uuid_t`, but something fishy is going on, in reality they
-/// expect a reference to these!
-///
-/// Hence we create this newtype to change the encoding.
 #[repr(transparent)]
 struct UuidBytes([u8; 16]);
 
 unsafe impl RefEncode for UuidBytes {
-    // Encoding depends on Foundation version, we hack it for now.
-    const ENCODING_REF: Encoding = if cfg!(target_arch = "aarch64") {
-        Encoding::String
-    } else {
-        Encoding::Array(16, &u8::ENCODING)
-    };
+    // Encoding actually depends on the instance class, `__NSConcreteUUID` has
+    // a different method encoding than `NSUUID`, the former takes a `char*`.
+    //
+    // This may also depend on the Foundation / OS version.
+    const ENCODING_REF: Encoding = Encoding::Array(16, &u8::ENCODING);
 }
 
 extern_methods!(
@@ -46,6 +40,13 @@ impl NSUUID {
 
     /// Create a new `NSUUID` from the given bytes.
     ///
+    /// NOTE: The headers describe `initWithUUIDBytes:` as taking `uuid_t`,
+    /// but their actual implementation may use something else.
+    ///
+    /// Thus, to use this method, you must currently disable encoding
+    /// verification using the `"disable-encoding-assertions"` Cargo feature
+    /// in `objc2`.
+    ///
     ///
     /// # Example
     ///
@@ -70,6 +71,14 @@ impl NSUUID {
         Self::initWithUUIDString(Self::alloc(), string)
     }
 
+    /// Convert the UUID to an array.
+    ///
+    /// NOTE: The headers describe `getUUIDBytes:` as taking `uuid_t`, but
+    /// their actual implementation may use something else.
+    ///
+    /// Thus, to use this method, you must currently disable encoding
+    /// verification using the `"disable-encoding-assertions"` Cargo feature
+    /// in `objc2`.
     pub fn as_bytes(&self) -> [u8; 16] {
         let mut bytes = UuidBytes([0; 16]);
         self.getUUIDBytes(&mut bytes);