Implement Borrow and BorrowMut in object! macro

Author: madsmtm

objc2-foundation/CHANGELOG.md

@@ -28,6 +28,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * Added `NSPoint`.
 * Added `NSSize`.
 * Added `NSRect`.
+* Implement `Borrow` and `BorrowMut` for all objects.
 
 ### Changed
 * **BREAKING**: Removed the following helper traits in favor of inherent

objc2-foundation/src/data.rs

@@ -98,6 +98,9 @@ impl AsRef<[u8]> for NSData {
     }
 }
 
+// Note: We don't implement `Borrow<[u8]>` since we can't guarantee that `Eq`,
+// `Ord` and `Hash` are equal for `NSData` vs. `[u8]`!
+
 impl<I: SliceIndex<[u8]>> Index<I> for NSData {
     type Output = I::Output;
 
@@ -433,29 +436,34 @@ mod tests {
     }
 
     #[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) {}
+    fn test_as_ref_borrow() {
+        use core::borrow::{Borrow, BorrowMut};
+
+        fn impls_borrow<T: AsRef<U> + Borrow<U> + ?Sized, U: ?Sized>(_: &T) {}
+        fn impls_borrow_mut<T: AsMut<U> + BorrowMut<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_borrow::<Id<NSMutableData, Owned>, NSMutableData>(&obj);
+        impls_borrow_mut::<Id<NSMutableData, Owned>, NSMutableData>(&mut obj);
+
+        impls_borrow::<NSMutableData, NSMutableData>(&obj);
+        impls_borrow_mut::<NSMutableData, NSMutableData>(&mut obj);
+        impls_borrow::<NSMutableData, NSData>(&obj);
+        impls_borrow_mut::<NSMutableData, NSData>(&mut obj);
+        impls_borrow::<NSMutableData, NSObject>(&obj);
+        impls_borrow_mut::<NSMutableData, NSObject>(&mut obj);
+        impls_borrow::<NSMutableData, Object>(&obj);
+        impls_borrow_mut::<NSMutableData, Object>(&mut obj);
+
+        impls_borrow::<NSData, NSData>(&obj);
+        impls_borrow_mut::<NSData, NSData>(&mut obj);
+        impls_borrow::<NSData, NSObject>(&obj);
+        impls_borrow_mut::<NSData, NSObject>(&mut obj);
+        impls_borrow::<NSData, Object>(&obj);
+        impls_borrow_mut::<NSData, Object>(&mut obj);
+
+        fn impls_as_ref<T: AsRef<U> + ?Sized, U: ?Sized>(_: &T) {}
+        fn impls_as_mut<T: AsMut<U> + ?Sized, U: ?Sized>(_: &mut T) {}
 
         impls_as_ref::<NSMutableData, [u8]>(&obj);
         impls_as_mut::<NSMutableData, [u8]>(&mut obj);

objc2-foundation/src/macros.rs

@@ -1,4 +1,4 @@
-macro_rules! __impl_as_ref_as_mut {
+macro_rules! __impl_as_ref_borrow {
     ($name:ident<$($t:ident $(: $b:ident)?),*>,) => {};
     ($name:ident<$($t:ident $(: $b:ident)?),*>, $item:ty, $($tail:ty,)*) => {
         impl<$($t $(: $b)?),*> AsRef<$item> for $name<$($t),*> {
@@ -17,7 +17,29 @@ macro_rules! __impl_as_ref_as_mut {
             }
         }
 
-        __impl_as_ref_as_mut!($name<$($t $(: $b)?),*>, $($tail,)*);
+        // Borrow and BorrowMut are correct, since subclasses behaves
+        // identical to the class they inherit (message sending doesn't care).
+        //
+        // In particular, `Eq`, `Ord` and `Hash` all give the same results
+        // after borrow.
+
+        impl<$($t $(: $b)?),*> ::core::borrow::Borrow<$item> for $name<$($t),*> {
+            #[inline]
+            fn borrow(&self) -> &$item {
+                // Triggers Deref coercion depending on return type
+                &*self
+            }
+        }
+
+        impl<$($t $(: $b)?),*> ::core::borrow::BorrowMut<$item> for $name<$($t),*> {
+            #[inline]
+            fn borrow_mut(&mut self) -> &mut $item {
+                // Triggers Deref coercion depending on return type
+                &mut *self
+            }
+        }
+
+        __impl_as_ref_borrow!($name<$($t $(: $b)?),*>, $($tail,)*);
     };
 }
 
@@ -127,7 +149,21 @@ macro_rules! object {
             }
         }
 
-        __impl_as_ref_as_mut!($name<$($t $(: $b)?),*>, $name<$($t),*>, $inherits, $($inheritance_rest,)*);
+        impl<$($t $(: $b)?),*> AsRef<Self> for $name<$($t),*> {
+            #[inline]
+            fn as_ref(&self) -> &Self {
+                self
+            }
+        }
+
+        impl<$($t $(: $b)?),*> AsMut<Self> for $name<$($t),*> {
+            #[inline]
+            fn as_mut(&mut self) -> &mut Self {
+                self
+            }
+        }
+
+        __impl_as_ref_borrow!($name<$($t $(: $b)?),*>, $inherits, $($inheritance_rest,)*);
 
         // Objective-C equality has approximately the same semantics as Rust
         // equality (although less aptly specified).

objc2-foundation/src/object.rs

@@ -57,9 +57,11 @@ mod tests {
     }
 
     #[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) {}
+    fn test_as_ref_borrow() {
+        use core::borrow::{Borrow, BorrowMut};
+
+        fn impls_as_ref<T: AsRef<U> + Borrow<U> + ?Sized, U: ?Sized>(_: &T) {}
+        fn impls_as_mut<T: AsMut<U> + BorrowMut<U> + ?Sized, U: ?Sized>(_: &mut T) {}
 
         let mut obj = NSObject::new();
         impls_as_ref::<Id<NSObject, Owned>, NSObject>(&obj);