replace Guard::belongs_to with Guard::collector and Collector::eq

Author: ibraheemdev

src/collector.rs

@@ -228,10 +228,15 @@ impl Collector {
     pub unsafe fn reclaim_all(&self) {
         unsafe { self.raw.reclaim_all() };
     }
+}
+
+impl Eq for Collector {}
 
+impl PartialEq for Collector {
+    /// Checks if both references point to the same collector.
     #[inline]
-    pub(crate) fn id_eq(this: &Collector, other: &Collector) -> bool {
-        this.id == other.id
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
     }
 }
 

src/guard.rs

@@ -87,11 +87,8 @@ pub trait Guard {
     /// this thread.
     fn thread_id(&self) -> usize;
 
-    /// Returns `true` if this guard belongs to the given collector.
-    ///
-    /// This can be used to verify that user-provided guards are valid
-    /// for the expected collector.
-    fn belongs_to(&self, collector: &Collector) -> bool;
+    /// Returns the collector this guard was created from.
+    fn collector(&self) -> &Collector;
 }
 
 /// A guard that keeps the current thread marked as active.
@@ -186,10 +183,9 @@ impl Guard for LocalGuard<'_> {
         self.thread.id
     }
 
-    /// Returns `true` if this guard belongs to the given collector.
-    #[inline]
-    fn belongs_to(&self, collector: &Collector) -> bool {
-        Collector::id_eq(self.collector, collector)
+    /// Returns the collector this guard was created from.
+    fn collector(&self) -> &Collector {
+        self.collector
     }
 }
 
@@ -313,10 +309,9 @@ impl Guard for OwnedGuard<'_> {
         Thread::current().id
     }
 
-    /// Returns `true` if this guard belongs to the given collector.
-    #[inline]
-    fn belongs_to(&self, collector: &Collector) -> bool {
-        Collector::id_eq(self.collector, collector)
+    /// Returns the collector this guard was created from.
+    fn collector(&self) -> &Collector {
+        self.collector
     }
 }
 

tests/lib.rs

@@ -415,14 +415,19 @@ fn owned_guard_concurrent() {
 }
 
 #[test]
-fn belongs_to() {
+fn collector_equality() {
     let a = Collector::new();
     let b = Collector::new();
 
-    assert!(a.enter().belongs_to(&a));
-    assert!(!a.enter().belongs_to(&b));
-    assert!(b.enter().belongs_to(&b));
-    assert!(!b.enter().belongs_to(&a));
+    assert_eq!(a, a);
+    assert_eq!(b, b);
+    assert_ne!(a, b);
+
+    assert_eq!(*a.enter().collector(), a);
+    assert_ne!(*a.enter().collector(), b);
+
+    assert_eq!(*b.enter().collector(), b);
+    assert_ne!(*b.enter().collector(), a);
 }
 
 #[test]