Implement AsRef<T> and AsMut<T> for T in object! macro

Author: madsmtm

objc2-foundation/src/data.rs

@@ -336,7 +336,7 @@ unsafe fn data_from_vec(cls: &Class, bytes: Vec<u8>) -> *mut Object {
 
 #[cfg(test)]
 mod tests {
-    use super::{NSData, NSMutableData};
+    use super::*;
     #[cfg(feature = "block")]
     use alloc::vec;
 
@@ -431,4 +431,41 @@ mod tests {
         data.extend(iter);
         assert_eq!(data.bytes(), &[1, 2, 3, 4, 5]);
     }
+
+    #[test]
+    fn test_as_ref() {
+        fn impls_as_ref<T: AsRef<U> + ?Sized, U: ?Sized>(_: &T) {}
+        fn impls_as_mut<T: AsMut<U> + ?Sized, U: ?Sized>(_: &mut T) {}
+
+        let mut obj = NSMutableData::new();
+        impls_as_ref::<Id<NSMutableData, Owned>, NSMutableData>(&obj);
+        impls_as_mut::<Id<NSMutableData, Owned>, NSMutableData>(&mut obj);
+
+        impls_as_ref::<NSMutableData, NSMutableData>(&obj);
+        impls_as_mut::<NSMutableData, NSMutableData>(&mut obj);
+        impls_as_ref::<NSMutableData, NSData>(&obj);
+        impls_as_mut::<NSMutableData, NSData>(&mut obj);
+        impls_as_ref::<NSMutableData, NSObject>(&obj);
+        impls_as_mut::<NSMutableData, NSObject>(&mut obj);
+        impls_as_ref::<NSMutableData, Object>(&obj);
+        impls_as_mut::<NSMutableData, Object>(&mut obj);
+
+        impls_as_ref::<NSData, NSData>(&obj);
+        impls_as_mut::<NSData, NSData>(&mut obj);
+        impls_as_ref::<NSData, NSObject>(&obj);
+        impls_as_mut::<NSData, NSObject>(&mut obj);
+        impls_as_ref::<NSData, Object>(&obj);
+        impls_as_mut::<NSData, Object>(&mut obj);
+
+        impls_as_ref::<NSMutableData, [u8]>(&obj);
+        impls_as_mut::<NSMutableData, [u8]>(&mut obj);
+        impls_as_ref::<NSData, [u8]>(&obj);
+
+        let obj: &mut NSMutableData = &mut *obj;
+        let _: &[u8] = obj.as_ref();
+        let _: &mut [u8] = obj.as_mut();
+
+        let obj: &mut NSData = &mut **obj;
+        let _: &[u8] = obj.as_ref();
+    }
 }

objc2-foundation/src/macros.rs

@@ -4,14 +4,16 @@ macro_rules! __impl_as_ref_as_mut {
         impl<$($t $(: $b)?),*> AsRef<$item> for $name<$($t),*> {
             #[inline]
             fn as_ref(&self) -> &$item {
-                &**self
+                // Triggers Deref coercion depending on return type
+                &*self
             }
         }
 
         impl<$($t $(: $b)?),*> AsMut<$item> for $name<$($t),*> {
             #[inline]
             fn as_mut(&mut self) -> &mut $item {
-                &mut **self
+                // Triggers DerefMut coercion depending on return type
+                &mut *self
             }
         }
 
@@ -125,7 +127,7 @@ macro_rules! object {
             }
         }
 
-        __impl_as_ref_as_mut!($name<$($t $(: $b)?),*>, $inherits, $($inheritance_rest,)*);
+        __impl_as_ref_as_mut!($name<$($t $(: $b)?),*>, $name<$($t),*>, $inherits, $($inheritance_rest,)*);
 
         // Objective-C equality has approximately the same semantics as Rust
         // equality (although less aptly specified).
@@ -166,13 +168,12 @@ macro_rules! object {
         // TODO: Consider T: Debug bound
         impl<$($t $(: $b)?),*> ::core::fmt::Debug for $name<$($t),*> {
             fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-                use ::objc2::MessageReceiver;
                 use ::alloc::borrow::ToOwned;
                 use $crate::NSObject;
                 // "downgrading" to  NSObject and calling `to_owned` to work
                 // around `f` and Self not being AutoreleaseSafe.
                 // TODO: Fix this!
-                let this: &NSObject = unsafe { &*self.as_raw_receiver().cast() };
+                let this: &NSObject = self.as_ref();
                 let s = ::objc2::rc::autoreleasepool(|pool| {
                     this.description().as_str(pool).to_owned()
                 });

objc2-foundation/src/object.rs

@@ -44,10 +44,32 @@ impl DefaultId for NSObject {
 
 #[cfg(test)]
 mod tests {
-    use super::NSObject;
-    use crate::NSString;
+    use super::*;
     use alloc::format;
 
+    #[test]
+    fn test_deref() {
+        let mut obj: Id<NSObject, Owned> = NSObject::new();
+        let _: &NSObject = &*obj;
+        let _: &mut NSObject = &mut *obj;
+        let _: &Object = &*obj;
+        let _: &mut Object = &mut *obj;
+    }
+
+    #[test]
+    fn test_as_ref() {
+        fn impls_as_ref<T: AsRef<U> + ?Sized, U: ?Sized>(_: &T) {}
+        fn impls_as_mut<T: AsMut<U> + ?Sized, U: ?Sized>(_: &mut T) {}
+
+        let mut obj = NSObject::new();
+        impls_as_ref::<Id<NSObject, Owned>, NSObject>(&obj);
+        impls_as_mut::<Id<NSObject, Owned>, NSObject>(&mut obj);
+        impls_as_ref::<NSObject, NSObject>(&obj);
+        impls_as_mut::<NSObject, NSObject>(&mut obj);
+        impls_as_ref::<NSObject, Object>(&obj);
+        impls_as_mut::<NSObject, Object>(&mut obj);
+    }
+
     #[test]
     fn test_equality() {
         let obj1 = NSObject::new();