remove ptr_from_ref helpers (#5523)

Author: davidhewitt

src/instance.rs

@@ -4,7 +4,6 @@ use crate::call::PyCallArgs;
 use crate::conversion::IntoPyObject;
 use crate::err::{PyErr, PyResult};
 use crate::impl_::pycell::PyClassObject;
-use crate::internal_tricks::ptr_from_ref;
 use crate::pycell::{PyBorrowError, PyBorrowMutError};
 use crate::pyclass::boolean_struct::{False, True};
 use crate::types::{any::PyAnyMethods, string::PyStringMethods, typeobject::PyTypeMethods};
@@ -444,9 +443,10 @@ impl<'py> Bound<'py, PyAny> {
         _py: Python<'py>,
         ptr: &'a *mut ffi::PyObject,
     ) -> &'a Self {
+        let ptr = NonNull::from(ptr).cast();
         // SAFETY: caller has upheld the safety contract,
         // and `Bound<PyAny>` is layout-compatible with `*mut ffi::PyObject`.
-        unsafe { &*ptr_from_ref(ptr).cast::<Bound<'py, PyAny>>() }
+        unsafe { ptr.as_ref() }
     }
 
     /// Variant of the above which returns `None` for null pointers.
@@ -458,9 +458,10 @@ impl<'py> Bound<'py, PyAny> {
         _py: Python<'py>,
         ptr: &'a *mut ffi::PyObject,
     ) -> &'a Option<Self> {
+        let ptr = NonNull::from(ptr).cast();
         // SAFETY: caller has upheld the safety contract,
         // and `Option<Bound<PyAny>>` is layout-compatible with `*mut ffi::PyObject`.
-        unsafe { &*ptr_from_ref(ptr).cast::<Option<Bound<'py, PyAny>>>() }
+        unsafe { ptr.as_ref() }
     }
 
     /// This slightly strange method is used to obtain `&Bound<PyAny>` from a [`NonNull`] in macro
@@ -477,9 +478,10 @@ impl<'py> Bound<'py, PyAny> {
         _py: Python<'py>,
         ptr: &'a NonNull<ffi::PyObject>,
     ) -> &'a Self {
+        let ptr = NonNull::from(ptr).cast();
         // SAFETY: caller has upheld the safety contract,
         // and `Bound<PyAny>` is layout-compatible with `NonNull<ffi::PyObject>`.
-        unsafe { NonNull::from(ptr).cast().as_ref() }
+        unsafe { ptr.as_ref() }
     }
 }
 
@@ -839,9 +841,10 @@ impl<'py, T> Bound<'py, T> {
     /// Helper to cast to `Bound<'py, PyAny>`.
     #[inline]
     pub fn as_any(&self) -> &Bound<'py, PyAny> {
+        let ptr = NonNull::from(self).cast();
         // Safety: all Bound<T> have the same memory layout, and all Bound<T> are valid
         // Bound<PyAny>, so pointer casting is valid.
-        unsafe { &*ptr_from_ref(self).cast::<Bound<'py, PyAny>>() }
+        unsafe { ptr.as_ref() }
     }
 
     /// Helper to cast to `Bound<'py, PyAny>`, transferring ownership.
@@ -1171,8 +1174,8 @@ impl<'py, T> Deref for Borrowed<'_, 'py, T> {
 
     #[inline]
     fn deref(&self) -> &Bound<'py, T> {
-        // safety: Bound has the same layout as NonNull<ffi::PyObject>
-        unsafe { &*ptr_from_ref(&self.0).cast() }
+        // SAFETY: self.0 is a valid object of type T
+        unsafe { Bound::ref_from_non_null(self.2, &self.0).cast_unchecked() }
     }
 }
 
@@ -1483,9 +1486,10 @@ impl<T> Py<T> {
     /// Helper to cast to `Py<PyAny>`.
     #[inline]
     pub fn as_any(&self) -> &Py<PyAny> {
+        let ptr = NonNull::from(self).cast();
         // Safety: all Py<T> have the same memory layout, and all Py<T> are valid
         // Py<PyAny>, so pointer casting is valid.
-        unsafe { &*ptr_from_ref(self).cast::<Py<PyAny>>() }
+        unsafe { ptr.as_ref() }
     }
 
     /// Helper to cast to `Py<PyAny>`, transferring ownership.

src/internal_tricks.rs

@@ -19,18 +19,6 @@ pub(crate) fn get_ssize_index(index: usize) -> Py_ssize_t {
     index.min(PY_SSIZE_T_MAX as usize) as Py_ssize_t
 }
 
-// TODO: use ptr::from_ref on MSRV 1.76
-#[inline]
-pub(crate) const fn ptr_from_ref<T>(t: &T) -> *const T {
-    t as *const T
-}
-
-// TODO: use ptr::from_mut on MSRV 1.76
-#[inline]
-pub(crate) fn ptr_from_mut<T>(t: &mut T) -> *mut T {
-    t as *mut T
-}
-
 // TODO: use ptr::fn_addr_eq on MSRV 1.85
 pub(crate) fn clear_eq(f: Option<ffi::inquiry>, g: ffi::inquiry) -> bool {
     #[cfg(fn_ptr_eq)]

src/pycell.rs

@@ -196,13 +196,13 @@
 use crate::conversion::IntoPyObject;
 use crate::exceptions::PyRuntimeError;
 use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::internal_tricks::{ptr_from_mut, ptr_from_ref};
 use crate::pyclass::{boolean_struct::False, PyClass};
 use crate::{ffi, Borrowed, Bound, PyErr, Python};
 use std::convert::Infallible;
 use std::fmt;
 use std::mem::ManuallyDrop;
 use std::ops::{Deref, DerefMut};
+use std::ptr::NonNull;
 
 pub(crate) mod impl_;
 use impl_::{PyClassBorrowChecker, PyClassObjectLayout};
@@ -444,12 +444,13 @@ where
     /// # });
     /// ```
     pub fn as_super(&self) -> &PyRef<'p, U> {
-        let ptr = ptr_from_ref::<Bound<'p, T>>(&self.inner)
+        let ptr = NonNull::from(&self.inner)
             // `Bound<T>` has the same layout as `Bound<T::BaseType>`
             .cast::<Bound<'p, T::BaseType>>()
             // `Bound<T::BaseType>` has the same layout as `PyRef<T::BaseType>`
             .cast::<PyRef<'p, T::BaseType>>();
-        unsafe { &*ptr }
+        // SAFETY: lifetimes are correctly transferred, and `PyRef<T>` and `PyRef<U>` have the same layout
+        unsafe { ptr.as_ref() }
     }
 }
 
@@ -580,8 +581,9 @@ impl<'py, T: PyClass<Frozen = False>> PyRefMut<'py, T> {
     }
 
     pub(crate) fn downgrade(slf: &Self) -> &PyRef<'py, T> {
-        // `PyRefMut<T>` and `PyRef<T>` have the same layout
-        unsafe { &*ptr_from_ref(slf).cast() }
+        let ptr = NonNull::from(slf).cast();
+        // SAFETY: `PyRefMut<T>` and `PyRef<T>` have the same layout
+        unsafe { ptr.as_ref() }
     }
 }
 
@@ -613,13 +615,14 @@ where
     ///
     /// See [`PyRef::as_super`] for more.
     pub fn as_super(&mut self) -> &mut PyRefMut<'p, U> {
-        let ptr = ptr_from_mut::<Bound<'p, T>>(&mut self.inner)
+        let mut ptr = NonNull::from(&mut self.inner)
             // `Bound<T>` has the same layout as `Bound<T::BaseType>`
             .cast::<Bound<'p, T::BaseType>>()
             // `Bound<T::BaseType>` has the same layout as `PyRefMut<T::BaseType>`,
             // and the mutable borrow on `self` prevents aliasing
             .cast::<PyRefMut<'p, T::BaseType>>();
-        unsafe { &mut *ptr }
+        // SAFETY: lifetimes are correctly transferred, and `PyRefMut<T>` and `PyRefMut<U>` have the same layout
+        unsafe { ptr.as_mut() }
     }
 }
 

src/pyclass/create_type_object.rs

@@ -10,15 +10,14 @@ use crate::{
         pymethods::{Getter, PyGetterDef, PyMethodDefType, PySetterDef, Setter, _call_clear},
         trampoline::trampoline,
     },
-    internal_tricks::ptr_from_ref,
     types::{typeobject::PyTypeMethods, PyType},
     Py, PyClass, PyResult, PyTypeInfo, Python,
 };
 use std::{
     collections::HashMap,
     ffi::{CStr, CString},
     os::raw::{c_char, c_int, c_ulong, c_void},
-    ptr,
+    ptr::{self, NonNull},
 };
 
 pub(crate) struct PyClassTypeObject {
@@ -700,7 +699,9 @@ impl GetSetDefType {
                     (
                         Some(getset_getter),
                         Some(getset_setter),
-                        ptr_from_ref::<GetterAndSetter>(closure) as *mut _,
+                        NonNull::<GetterAndSetter>::from(closure.as_ref())
+                            .cast()
+                            .as_ptr(),
                     )
                 }
             };