Create references from pointers using as_ref instead of &*

Hard to see difference between unsafe `&*` and safe Deref, and hard to know whether ptr nullability is handled.

Author: madsmtm

block2/src/global.rs

@@ -83,8 +83,10 @@ where
     type Target = Block<A, R>;
 
     fn deref(&self) -> &Self::Target {
+        let ptr: *const Self = self;
+        let ptr: *const Block<A, R> = ptr.cast();
         // TODO: SAFETY
-        unsafe { &*(self as *const Self as *const Block<A, R>) }
+        unsafe { ptr.as_ref().unwrap_unchecked() }
     }
 }
 

block2/src/lib.rs

@@ -468,7 +468,10 @@ impl<A, R, F> Deref for ConcreteBlock<A, R, F> {
     type Target = Block<A, R>;
 
     fn deref(&self) -> &Self::Target {
-        unsafe { &*(self as *const Self as *const Block<A, R>) }
+        let ptr: *const Self = self;
+        let ptr: *const Block<A, R> = ptr.cast();
+        // TODO: SAFETY
+        unsafe { ptr.as_ref().unwrap_unchecked() }
     }
 }
 

objc2-foundation/src/array.rs

@@ -310,7 +310,7 @@ impl<T: Message, O: Ownership> NSMutableArray<T, O> {
             // Bring back a reference to the closure.
             // Guaranteed to be unique, we gave `sortUsingFunction` unique is
             // ownership, and that method only runs one function at a time.
-            let closure: &mut F = unsafe { &mut *(context as *mut F) };
+            let closure: &mut F = unsafe { (context as *mut F).as_mut().unwrap_unchecked() };
 
             NSComparisonResult::from((*closure)(obj1, obj2))
         }

objc2-foundation/src/enumerator.rs

@@ -159,7 +159,7 @@ impl<'a, C: NSFastEnumeration + ?Sized> Iterator for NSFastEnumerator<'a, C> {
             unsafe {
                 let obj = *self.ptr;
                 self.ptr = self.ptr.offset(1);
-                Some(&*obj)
+                Some(obj.as_ref().unwrap_unchecked())
             }
         }
     }

objc2-foundation/src/macros.rs

@@ -178,7 +178,7 @@ macro_rules! object {
         impl<$($t: ::core::cmp::PartialEq $(+ $b)?),*> ::core::cmp::PartialEq for $name<$($t),*> {
             #[inline]
             fn eq(&self, other: &Self) -> bool {
-                self.is_equal(&*other)
+                self.is_equal(other.as_ref())
             }
         }
 

objc2-foundation/src/string.rs

@@ -276,6 +276,7 @@ impl fmt::Display for NSString {
 mod tests {
     use super::*;
     use alloc::format;
+    use core::ptr;
 
     #[cfg(feature = "gnustep-1-7")]
     #[test]
@@ -365,11 +366,10 @@ mod tests {
     fn test_copy_nsstring_is_same() {
         let string1 = NSString::from_str("Hello, world!");
         let string2 = string1.copy();
-
-        let s1: *const NSString = &*string1;
-        let s2: *const NSString = &*string2;
-
-        assert_eq!(s1, s2, "Cloned NSString didn't have the same address");
+        assert!(
+            ptr::eq(&*string1, &*string2),
+            "Cloned NSString didn't have the same address"
+        );
     }
 
     #[test]

objc2/src/cache.rs

@@ -57,12 +57,12 @@ impl CachedClass {
     pub unsafe fn get(&self, name: &str) -> Option<&'static Class> {
         // `Relaxed` should be fine since `objc_getClass` is thread-safe.
         let ptr = self.ptr.load(Ordering::Relaxed);
-        if ptr.is_null() {
-            let cls: *const Class = unsafe { ffi::objc_getClass(name.as_ptr().cast()) }.cast();
-            self.ptr.store(cls as *mut Class, Ordering::Relaxed);
-            unsafe { cls.as_ref() }
+        if let Some(cls) = unsafe { ptr.as_ref() } {
+            Some(cls)
         } else {
-            Some(unsafe { &*ptr })
+            let ptr: *const Class = unsafe { ffi::objc_getClass(name.as_ptr().cast()) }.cast();
+            self.ptr.store(ptr as *mut Class, Ordering::Relaxed);
+            unsafe { ptr.as_ref() }
         }
     }
 }

objc2/src/message/mod.rs

@@ -211,7 +211,7 @@ pub unsafe trait MessageReceiver: private::Sealed + Sized {
         A: EncodeArguments,
         R: Encode,
     {
-        let obj = unsafe { &*self.__as_raw_receiver() };
+        let obj = unsafe { self.__as_raw_receiver().as_ref().unwrap() };
         verify_message_signature::<A, R>(obj.class(), sel).map_err(MessageError::from)
     }
 }

objc2/src/rc/autorelease.rs

@@ -88,7 +88,7 @@ impl AutoreleasePool {
     pub unsafe fn ptr_as_ref<'p, T: ?Sized>(&'p self, ptr: *const T) -> &'p T {
         self.__verify_is_inner();
         // SAFETY: Checked by the caller
-        unsafe { &*ptr }
+        unsafe { ptr.as_ref().unwrap_unchecked() }
     }
 
     /// Returns a unique reference to the given autoreleased pointer object.
@@ -109,7 +109,7 @@ impl AutoreleasePool {
     pub unsafe fn ptr_as_mut<'p, T: ?Sized>(&'p self, ptr: *mut T) -> &'p mut T {
         self.__verify_is_inner();
         // SAFETY: Checked by the caller
-        unsafe { &mut *ptr }
+        unsafe { ptr.as_mut().unwrap_unchecked() }
     }
 }
 

objc2/src/rc/id_traits.rs

@@ -29,14 +29,14 @@ impl<T: Message + ?Sized, O: Ownership> SliceId for [Id<T, O>] {
         let ptr = self as *const Self as *const [&T];
         // SAFETY: Id<T, O> and &T have the same memory layout. Further safety
         // follows from `Deref` impl.
-        unsafe { &*ptr }
+        unsafe { ptr.as_ref().unwrap_unchecked() }
     }
 
     fn as_slice_mut(&mut self) -> &mut [&T] {
         let ptr = self as *mut Self as *mut [&T];
         // SAFETY: Id<T, O> and &T have the same memory layout. Further safety
         // follows from `Deref` impl.
-        unsafe { &mut *ptr }
+        unsafe { ptr.as_mut().unwrap_unchecked() }
     }
 }
 
@@ -46,7 +46,7 @@ impl<T: Message + ?Sized> SliceIdMut for [Id<T, Owned>] {
         // SAFETY: Id<T, O> and &mut T have the same memory layout, and the
         // `Id` is `Owned` so we're allowed to hand out mutable references.
         // Further safety follows from `DerefMut` impl.
-        unsafe { &mut *ptr }
+        unsafe { ptr.as_mut().unwrap_unchecked() }
     }
 }