Makes Clippy beta happy (#5032)

* Use std::ptr::eq where relevant

* allow(clippy::ptr_eq) in pyo3-ffi

* Add ref for allow(clippy::large_enum_variant)

Author: Tpt

pyo3-ffi/src/lib.rs

@@ -327,7 +327,8 @@
     non_snake_case,
     non_upper_case_globals,
     clippy::upper_case_acronyms,
-    clippy::missing_safety_doc
+    clippy::missing_safety_doc,
+    clippy::ptr_eq
 )]
 #![warn(elided_lifetimes_in_paths, unused_lifetimes)]
 // This crate is a hand-maintained translation of CPython's headers, so requiring "unsafe"

pyo3-macros-backend/src/method.rs

@@ -53,6 +53,7 @@ pub struct PyArg<'a> {
     pub ty: &'a syn::Type,
 }
 
+#[allow(clippy::large_enum_variant)] // See #5039
 #[derive(Clone, Debug)]
 pub enum FnArg<'a> {
     Regular(RegularArg<'a>),

src/err/mod.rs

@@ -22,6 +22,7 @@ mod impls;
 use crate::conversion::IntoPyObject;
 use err_state::{PyErrState, PyErrStateLazyFnOutput, PyErrStateNormalized};
 use std::convert::Infallible;
+use std::ptr;
 
 /// Represents a Python exception.
 ///
@@ -364,7 +365,10 @@ impl PyErr {
     pub fn take(py: Python<'_>) -> Option<PyErr> {
         let state = PyErrStateNormalized::take(py)?;
         let pvalue = state.pvalue.bind(py);
-        if pvalue.get_type().as_ptr() == PanicException::type_object_raw(py).cast() {
+        if ptr::eq(
+            pvalue.get_type().as_ptr(),
+            PanicException::type_object_raw(py).cast(),
+        ) {
             let msg: String = pvalue
                 .str()
                 .map(|py_str| py_str.to_string_lossy().into())

src/impl_/pyclass.rs

@@ -19,6 +19,7 @@ use std::{
     ffi::{CStr, CString},
     marker::PhantomData,
     os::raw::{c_int, c_void},
+    ptr,
     ptr::NonNull,
     sync::Mutex,
     thread,
@@ -950,7 +951,7 @@ pub unsafe extern "C" fn alloc_with_freelist<T: PyClassWithFreeList>(
     let self_type = T::type_object_raw(py);
     // If this type is a variable type or the subtype is not equal to this type, we cannot use the
     // freelist
-    if nitems == 0 && subtype == self_type {
+    if nitems == 0 && ptr::eq(subtype, self_type) {
         let mut free_list = T::get_free_list(py).lock().unwrap();
         if let Some(obj) = free_list.pop() {
             drop(free_list);
@@ -1143,7 +1144,6 @@ impl<T> PyClassThreadChecker<T> for ThreadCheckerImpl {
 }
 
 /// Trait denoting that this class is suitable to be used as a base type for PyClass.
-
 #[cfg_attr(
     all(diagnostic_namespace, Py_LIMITED_API),
     diagnostic::on_unimplemented(

src/impl_/pyclass_init.rs

@@ -5,6 +5,7 @@ use crate::types::PyType;
 use crate::{ffi, Borrowed, PyErr, PyResult, Python};
 use crate::{ffi::PyTypeObject, sealed::Sealed, type_object::PyTypeInfo};
 use std::marker::PhantomData;
+use std::ptr;
 
 /// Initializer for Python types.
 ///
@@ -38,7 +39,7 @@ impl<T: PyTypeInfo> PyObjectInit<T> for PyNativeTypeInitializer<T> {
             subtype: *mut PyTypeObject,
         ) -> PyResult<*mut ffi::PyObject> {
             // HACK (due to FIXME below): PyBaseObject_Type's tp_new isn't happy with NULL arguments
-            let is_base_object = type_object == std::ptr::addr_of_mut!(ffi::PyBaseObject_Type);
+            let is_base_object = ptr::eq(type_object, ptr::addr_of!(ffi::PyBaseObject_Type));
             let subtype_borrowed: Borrowed<'_, '_, PyType> = unsafe {
                 subtype
                     .cast::<ffi::PyObject>()

src/instance.rs

@@ -16,6 +16,7 @@ use crate::{IntoPy, ToPyObject};
 use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
 use std::ops::Deref;
+use std::ptr;
 use std::ptr::NonNull;
 
 /// Owned or borrowed gil-bound Python smart pointer
@@ -1335,7 +1336,7 @@ impl<T> Py<T> {
     /// This is equivalent to the Python expression `self is other`.
     #[inline]
     pub fn is<U: AsPyPointer>(&self, o: &U) -> bool {
-        self.as_ptr() == o.as_ptr()
+        ptr::eq(self.as_ptr(), o.as_ptr())
     }
 
     /// Gets the reference count of the `ffi::PyObject` pointer.
@@ -1407,7 +1408,7 @@ impl<T> Py<T> {
     ///
     /// This is equivalent to the Python expression `self is None`.
     pub fn is_none(&self, _py: Python<'_>) -> bool {
-        unsafe { ffi::Py_None() == self.as_ptr() }
+        unsafe { ptr::eq(ffi::Py_None(), self.as_ptr()) }
     }
 
     /// Returns whether the object is considered to be true.

src/internal_tricks.rs

@@ -34,6 +34,7 @@ pub(crate) fn ptr_from_mut<T>(t: &mut T) -> *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)]
+    #[allow(clippy::incompatible_msrv)]
     {
         let Some(f) = f else { return false };
         std::ptr::fn_addr_eq(f, g)
@@ -48,6 +49,7 @@ pub(crate) fn clear_eq(f: Option<ffi::inquiry>, g: ffi::inquiry) -> bool {
 // TODO: use ptr::fn_addr_eq on MSRV 1.85
 pub(crate) fn traverse_eq(f: Option<ffi::traverseproc>, g: ffi::traverseproc) -> bool {
     #[cfg(fn_ptr_eq)]
+    #[allow(clippy::incompatible_msrv)]
     {
         let Some(f) = f else { return false };
         std::ptr::fn_addr_eq(f, g)

src/pycell/impl_.rs

@@ -241,7 +241,7 @@ where
             let actual_type = PyType::from_borrowed_type_ptr(py, ffi::Py_TYPE(slf));
 
             // For `#[pyclass]` types which inherit from PyAny, we can just call tp_free
-            if type_ptr == std::ptr::addr_of_mut!(ffi::PyBaseObject_Type) {
+            if std::ptr::eq(type_ptr, std::ptr::addr_of!(ffi::PyBaseObject_Type)) {
                 let tp_free = actual_type
                     .get_slot(TP_FREE)
                     .expect("PyBaseObject_Type should have tp_free");

src/type_object.rs

@@ -4,6 +4,7 @@ use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::types::any::PyAnyMethods;
 use crate::types::{PyAny, PyType};
 use crate::{ffi, Bound, Python};
+use std::ptr;
 
 /// `T: PyLayout<U>` represents that `T` is a concrete representation of `U` in the Python heap.
 /// E.g., `PyClassObject` is a concrete representation of all `pyclass`es, and `ffi::PyObject`
@@ -85,7 +86,12 @@ pub unsafe trait PyTypeInfo: Sized {
     /// Checks if `object` is an instance of this type.
     #[inline]
     fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
-        unsafe { ffi::Py_TYPE(object.as_ptr()) == Self::type_object_raw(object.py()) }
+        unsafe {
+            ptr::eq(
+                ffi::Py_TYPE(object.as_ptr()),
+                Self::type_object_raw(object.py()),
+            )
+        }
     }
 
     /// Deprecated name for [`PyTypeInfo::is_exact_type_of`].

src/types/any.rs

@@ -16,6 +16,7 @@ use crate::{err, ffi, Borrowed, BoundObject, IntoPyObjectExt, Python};
 use std::cell::UnsafeCell;
 use std::cmp::Ordering;
 use std::os::raw::c_int;
+use std::ptr;
 
 /// Represents any Python object.
 ///
@@ -964,7 +965,7 @@ macro_rules! implement_binop {
 impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     #[inline]
     fn is<T: AsPyPointer>(&self, other: &T) -> bool {
-        self.as_ptr() == other.as_ptr()
+        ptr::eq(self.as_ptr(), other.as_ptr())
     }
 
     fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>
@@ -1368,7 +1369,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     #[inline]
     fn is_none(&self) -> bool {
-        unsafe { ffi::Py_None() == self.as_ptr() }
+        unsafe { ptr::eq(ffi::Py_None(), self.as_ptr()) }
     }
 
     fn is_ellipsis(&self) -> bool {