Fixed most warnings

src/lib.rs

@@ -124,6 +124,7 @@ impl PartialEq for TipToe {
 
 impl Eq for TipToe {}
 
+#[allow(clippy::non_canonical_partial_ord_impl)]
 impl PartialOrd for TipToe {
 	fn partial_cmp(&self, _: &Self) -> Option<cmp::Ordering> {
 		Some(cmp::Ordering::Equal)
@@ -152,6 +153,7 @@ pub mod ref_counter_api {
 	mod private {
 		#[cfg(not(feature = "sync"))]
 		use core::cell::Cell;
+		use core::ptr;
 		#[cfg(feature = "sync")]
 		use core::sync::atomic::AtomicUsize;
 
@@ -165,7 +167,7 @@ pub mod ref_counter_api {
 
 			fn refcount_ptr(&self) -> *mut usize {
 				#[cfg(feature = "sync")]
-				return self.refcount() as *const AtomicUsize as *mut usize;
+				return ptr::from_ref::<AtomicUsize>(self.refcount()) as *mut usize;
 				#[cfg(not(feature = "sync"))]
 				return self.refcount().as_ptr();
 			}
@@ -266,6 +268,7 @@ pub mod ref_counter_api {
 		/// and then dropping the resulting instance.
 		#[inline]
 		unsafe fn decrement(&self) -> DecrementFollowup {
+			#[allow(clippy::blocks_in_conditions)]
 			match {
 				#[cfg(feature = "sync")]
 				{
@@ -303,6 +306,7 @@ pub mod ref_counter_api {
 		/// Calling this method is equivalent to calling [`Rc::from_raw`](`crate::Rc::from_raw`)
 		/// and then dropping the resulting instance.
 		unsafe fn decrement_relaxed(&self) -> DecrementFollowup {
+			#[allow(clippy::blocks_in_conditions)]
 			match {
 				#[cfg(feature = "sync")]
 				{
@@ -329,6 +333,7 @@ pub mod ref_counter_api {
 		///
 		/// Dropping the [`Exclusivity`] performs a write to a remembered address, so **the borrowed instance must not be moved** until then.
 		unsafe fn acquire(&self) -> Option<Exclusivity> {
+			#[allow(clippy::blocks_in_conditions)]
 			match {
 				#[cfg(feature = "sync")]
 				{
@@ -358,6 +363,7 @@ pub mod ref_counter_api {
 		/// This is only suitable for synchronous reference-counting.
 		#[must_use]
 		fn acquire_relaxed(&self) -> Option<Exclusivity> {
+			#[allow(clippy::blocks_in_conditions)]
 			match {
 				#[cfg(feature = "sync")]
 				{

src/sync.rs

@@ -14,7 +14,7 @@ use core::{
 	mem::{self, ManuallyDrop},
 	ops::Deref,
 	pin::Pin,
-	ptr::NonNull,
+	ptr::{self, NonNull},
 };
 use tap::{Pipe, Tap};
 
@@ -335,7 +335,7 @@ impl<T: ?Sized + IntrusivelyCountable> Arc<T> {
 	/// `inner` must be a reference to a reference to an instance managed by [`Arc`].
 	#[must_use]
 	pub unsafe fn borrow_from_inner_ref<'a>(inner: &'a &'a T) -> &'a Self {
-		&*(inner as *const &T).cast::<Self>()
+		&*ptr::from_ref::<&T>(inner).cast::<Self>()
 	}
 
 	/// Unsafely borrows a shared reference to a [`Pin<Arc>`]-managed instance as [`Pin<Arc>`].
@@ -347,7 +347,7 @@ impl<T: ?Sized + IntrusivelyCountable> Arc<T> {
 	/// `inner` must be a reference to a reference to an instance managed by [`Pin<Arc>`].
 	#[must_use]
 	pub unsafe fn borrow_pin_from_inner_ref<'a>(inner: &'a &'a T) -> &'a Pin<Self> {
-		&*(inner as *const &T).cast::<Pin<Self>>()
+		&*ptr::from_ref::<&T>(inner).cast::<Pin<Self>>()
 	}
 
 	/// Unwraps the payload pointer contained in the current instance.
@@ -378,7 +378,7 @@ impl<T: ?Sized + IntrusivelyCountable> Arc<T> {
 	/// Checks whether two instances of [`Arc<T>`] point to the same instance.
 	#[must_use]
 	pub fn ptr_eq(this: &Self, other: &Self) -> bool {
-		this.pointer == other.pointer
+		ptr::addr_eq(this.pointer.as_ptr(), other.pointer.as_ptr())
 	}
 
 	/// Ensures the payload is exclusively pointed to by this [`Arc<T>`], cloning it if necessary,
@@ -392,7 +392,7 @@ impl<T: ?Sized + IntrusivelyCountable> Arc<T> {
 				// Safety:
 				// No effective encapsulation change happens.
 				// `Self::pin` does call `IntrusivelyCountable::ref_counter`, but this is legal as that method is not allowed to have effects.
-				(&**this).managed_clone().pipe(Self::pin)
+				(**this).managed_clone().pipe(Self::pin)
 			};
 
 			// This could be done faster, but whether that's significant is up to benchmarking it.
@@ -401,7 +401,7 @@ impl<T: ?Sized + IntrusivelyCountable> Arc<T> {
 
 		ExclusivePin::new(exclusivity, unsafe {
 			Pin::new_unchecked(
-				(*(this as *mut Pin<Self>).cast::<Arc<T>>())
+				(*ptr::from_mut::<Pin<Self>>(this).cast::<Arc<T>>())
 					.pointer
 					.as_mut(),
 			)
@@ -415,7 +415,7 @@ impl<T: ?Sized + IntrusivelyCountable> Arc<T> {
 		unsafe { this.ref_counter().acquire() }.map(|exclusivity| {
 			ExclusivePin::new(exclusivity, unsafe {
 				Pin::new_unchecked(
-					(*(this as *mut Pin<Self>).cast::<Arc<T>>())
+					(*ptr::from_mut::<Pin<Self>>(this).cast::<Arc<T>>())
 						.pointer
 						.as_mut(),
 				)