Remove an implementation of PartialEq in RawShared

src/ebr_impl/pointers.rs

@@ -252,18 +252,6 @@ impl<'g, T> From<Tagged<T>> for RawShared<'g, T> {
     }
 }
 
-impl<'g, T> PartialEq for RawShared<'g, T> {
-    /// Returns `true` if the two pointer values, including the tag values set by `with_tag`,
-    /// are identical.
-    fn eq(&self, other: &Self) -> bool {
-        // Instead of using a direct equality comparison (`==`), we use `ptr_eq`, which ignores
-        // the epoch tag in the high bits. This is because the epoch tags hold no significance
-        // for clients; they are only used internally by the CIRC engine to track the last
-        // accessed epoch for the pointer.
-        self.inner.ptr_eq(other.inner)
-    }
-}
-
 impl<'g, T> RawShared<'g, T> {
     pub fn null() -> Self {
         Self {
@@ -310,4 +298,14 @@ impl<'g, T> RawShared<'g, T> {
     pub fn is_null(self) -> bool {
         self.inner.is_null()
     }
+
+    /// Returns `true` if the two pointer values, including the tag values set by `with_tag`,
+    /// are identical.
+    pub fn ptr_eq(&self, other: Self) -> bool {
+        // Instead of using a direct equality comparison (`==`), we use `ptr_eq`, which ignores
+        // the epoch tag in the high bits. This is because the epoch tags hold no significance
+        // for clients; they are only used internally by the CIRC engine to track the last
+        // accessed epoch for the pointer.
+        self.inner.ptr_eq(other.inner)
+    }
 }

src/ebr_impl/sync/queue.rs

@@ -122,7 +122,7 @@ impl<T> Queue<T> {
                     .map(|_| {
                         let tail = self.tail.load(Relaxed, guard);
                         // Advance the tail so that we don't retire a pointer to a reachable node.
-                        if head == tail {
+                        if head.ptr_eq(tail) {
                             let _ = self
                                 .tail
                                 .compare_exchange(tail, next, Release, Relaxed, guard);
@@ -154,7 +154,7 @@ impl<T> Queue<T> {
                     .map(|_| {
                         let tail = self.tail.load(Relaxed, guard);
                         // Advance the tail so that we don't retire a pointer to a reachable node.
-                        if head == tail {
+                        if head.ptr_eq(tail) {
                             let _ = self
                                 .tail
                                 .compare_exchange(tail, next, Release, Relaxed, guard);