Remove hack to support CustomObject test utility

Author: madsmtm

crates/objc2/src/declare/ivar.rs

@@ -320,7 +320,7 @@ mod tests {
     use crate::declare::{IvarBool, IvarEncode};
     use crate::mutability::Mutable;
     use crate::rc::Id;
-    use crate::runtime::{MessageReceiver, NSObject};
+    use crate::runtime::NSObject;
     use crate::{declare_class, msg_send, msg_send_id, test_utils, ClassType};
 
     struct TestIvar;
@@ -351,12 +351,7 @@ mod tests {
         let mut obj = test_utils::custom_object();
         let _: () = unsafe { msg_send![&mut obj, setFoo: 42u32] };
 
-        let obj = unsafe {
-            obj.__as_raw_receiver()
-                .cast::<IvarTestObject>()
-                .as_ref()
-                .unwrap()
-        };
+        let obj = unsafe { Id::as_ptr(&obj).cast::<IvarTestObject>().as_ref().unwrap() };
         assert_eq!(*obj.foo, 42);
     }
 

crates/objc2/src/runtime/message.rs

@@ -635,17 +635,6 @@ unsafe impl<'a> MessageReceiver for &'a AnyClass {
     }
 }
 
-#[cfg(test)]
-mod test_utils_hack {
-    use super::*;
-    use crate::test_utils::CustomObject;
-
-    // TODO: Remove the need for this hack
-    impl private::Sealed for &CustomObject {}
-    impl private::Sealed for &mut CustomObject {}
-    impl private::Sealed for ManuallyDrop<CustomObject> {}
-}
-
 mod message_args_private {
     pub trait Sealed {}
 }

crates/objc2/src/runtime/mod.rs

@@ -1544,7 +1544,7 @@ mod tests {
         let object = test_utils::custom_object();
         assert_eq!(
             format!("{:?}", &*object),
-            format!("<CustomObject: {:p}>", &*object)
+            format!("CustomObject(<CustomObject: {:p}>)", &*object)
         );
     }
 

crates/objc2/src/test_utils.rs

@@ -1,73 +1,54 @@
-use core::mem::ManuallyDrop;
 use core::ops::{Deref, DerefMut};
 use std::os::raw::c_char;
 use std::sync::Once;
 
 use crate::declare::{ClassBuilder, ProtocolBuilder};
-use crate::runtime::{AnyClass, AnyObject, AnyProtocol, MessageReceiver, Sel};
-use crate::{ffi, Encode, Encoding};
-use crate::{msg_send, sel};
+use crate::encode::{Encode, Encoding, RefEncode};
+use crate::rc::Id;
+use crate::runtime::{AnyClass, AnyObject, AnyProtocol, Sel};
+use crate::{ffi, msg_send, mutability, sel, ClassType, Message};
 
 #[derive(Debug)]
-pub(crate) struct CustomObject {
-    obj: *mut AnyObject,
-}
+#[repr(C)]
+pub(crate) struct CustomObject(AnyObject);
 
-impl CustomObject {
-    fn new(class: &AnyClass) -> Self {
-        let ptr: *const AnyClass = class;
-        let obj = unsafe { ffi::class_createInstance(ptr.cast(), 0) }.cast();
-        CustomObject { obj }
-    }
+unsafe impl RefEncode for CustomObject {
+    const ENCODING_REF: Encoding = Encoding::Object;
 }
 
-unsafe impl MessageReceiver for &CustomObject {
-    type __Inner = AnyObject;
+unsafe impl Message for CustomObject {}
 
-    #[inline]
-    fn __as_raw_receiver(self) -> *mut AnyObject {
-        self.obj
-    }
-}
+unsafe impl ClassType for CustomObject {
+    type Super = AnyObject;
+
+    type Mutability = mutability::Mutable;
 
-unsafe impl MessageReceiver for &mut CustomObject {
-    type __Inner = AnyObject;
+    const NAME: &'static str = "CustomObject";
 
-    #[inline]
-    fn __as_raw_receiver(self) -> *mut AnyObject {
-        self.obj
+    fn class() -> &'static AnyClass {
+        custom_class()
     }
-}
 
-unsafe impl MessageReceiver for ManuallyDrop<CustomObject> {
-    type __Inner = AnyObject;
+    fn as_super(&self) -> &Self::Super {
+        &self.0
+    }
 
-    #[inline]
-    fn __as_raw_receiver(self) -> *mut AnyObject {
-        self.obj
+    fn as_super_mut(&mut self) -> &mut Self::Super {
+        &mut self.0
     }
 }
 
 impl Deref for CustomObject {
     type Target = AnyObject;
 
     fn deref(&self) -> &AnyObject {
-        unsafe { self.obj.as_ref().unwrap_unchecked() }
+        &self.0
     }
 }
 
 impl DerefMut for CustomObject {
     fn deref_mut(&mut self) -> &mut AnyObject {
-        unsafe { self.obj.as_mut().unwrap_unchecked() }
-    }
-}
-
-impl Drop for CustomObject {
-    fn drop(&mut self) {
-        unsafe {
-            #[allow(deprecated)]
-            ffi::object_dispose(self.obj.cast());
-        }
+        &mut self.0
     }
 }
 
@@ -105,8 +86,10 @@ pub(crate) fn custom_class() -> &'static AnyClass {
         builder.add_ivar::<u32>("_foo");
 
         unsafe extern "C" fn custom_obj_release(this: *mut AnyObject, _cmd: Sel) {
-            // Drop the value
-            let _ = CustomObject { obj: this };
+            unsafe {
+                #[allow(deprecated)]
+                ffi::object_dispose(this.cast());
+            }
         }
 
         extern "C" fn custom_obj_set_foo(this: &mut AnyObject, _cmd: Sel, foo: u32) {
@@ -172,8 +155,21 @@ pub(crate) fn custom_class() -> &'static AnyClass {
         }
 
         unsafe {
-            let release: unsafe extern "C" fn(_, _) = custom_obj_release;
-            builder.add_method(sel!(release), release);
+            // On GNUStep 2.0, it is required to have `dealloc` methods for some reason
+            if cfg!(all(feature = "gnustep-2-0", not(feature = "gnustep-2-1"))) {
+                unsafe extern "C" fn forward_to_dealloc(this: *mut AnyObject, _cmd: Sel) {
+                    unsafe { msg_send![this, dealloc] }
+                }
+
+                let release: unsafe extern "C" fn(_, _) = forward_to_dealloc;
+                builder.add_method(sel!(release), release);
+
+                let release: unsafe extern "C" fn(_, _) = custom_obj_release;
+                builder.add_method(sel!(dealloc), release);
+            } else {
+                let release: unsafe extern "C" fn(_, _) = custom_obj_release;
+                builder.add_method(sel!(release), release);
+            }
 
             let set_foo: extern "C" fn(_, _, _) = custom_obj_set_foo;
             builder.add_method(sel!(setFoo:), set_foo);
@@ -237,8 +233,9 @@ pub(crate) fn custom_subprotocol() -> &'static AnyProtocol {
     AnyProtocol::get("CustomSubProtocol").unwrap()
 }
 
-pub(crate) fn custom_object() -> CustomObject {
-    CustomObject::new(custom_class())
+pub(crate) fn custom_object() -> Id<CustomObject> {
+    let ptr: *const AnyClass = custom_class();
+    unsafe { Id::new(ffi::class_createInstance(ptr.cast(), 0).cast()) }.unwrap()
 }
 
 pub(crate) fn custom_subclass() -> &'static AnyClass {
@@ -270,6 +267,7 @@ pub(crate) fn custom_subclass() -> &'static AnyClass {
     AnyClass::get("CustomSubclassObject").unwrap()
 }
 
-pub(crate) fn custom_subclass_object() -> CustomObject {
-    CustomObject::new(custom_subclass())
+pub(crate) fn custom_subclass_object() -> Id<CustomObject> {
+    let ptr: *const AnyClass = custom_subclass();
+    unsafe { Id::new(ffi::class_createInstance(ptr.cast(), 0).cast()) }.unwrap()
 }