Minor cleanups

* queue: remove final unprotected.

* list: stricter send/sync bounds.

* lock/api: remove unnessecary API for LockGuard & test cleanup

src/lock/api.rs

@@ -1,5 +1,5 @@
 use core::cell::UnsafeCell;
-use core::mem::{self, ManuallyDrop};
+use core::mem::ManuallyDrop;
 use core::ops::{Deref, DerefMut};
 
 /// Raw lock interface.
@@ -151,40 +151,18 @@ impl<L: RawLock, T> DerefMut for LockGuard<'_, L, T> {
     }
 }
 
-impl<L: RawLock, T> LockGuard<'_, L, T> {
-    /// Transforms a lock guard to an address.
-    pub fn into_raw(self) -> usize {
-        let ret = self.lock as *const _ as usize;
-        mem::forget(self);
-        ret
-    }
-
-    /// # Safety
-    ///
-    /// The given arguments should be the data of a forgotten lock guard.
-    pub unsafe fn from_raw(data: usize, token: L::Token) -> Self {
-        Self {
-            // SAFETY: data is from a `lock` that was forgotten.
-            lock: &*(data as *const _),
-            token: ManuallyDrop::new(token),
-        }
-    }
-}
-
 #[cfg(test)]
 pub mod tests {
-
-    use std::thread::scope;
-
     use super::{Lock, RawLock};
+    use std::thread::scope;
 
     pub fn smoke<L: RawLock>() {
         const LENGTH: usize = 1024;
         let d = Lock::<L, Vec<usize>>::default();
 
         scope(|s| {
+            let d = &d;
             for i in 1..LENGTH {
-                let d = &d;
                 s.spawn(move || {
                     let mut d = d.lock();
                     d.push(i);

src/lockfree/list.rs

@@ -24,6 +24,11 @@ pub struct List<K, V> {
     head: Atomic<Node<K, V>>,
 }
 
+// Unlike stack and queue, we need `K` and `V` to be `Sync` for the list to be `Sync`,
+// as both `K` and `V` are accessed concurrently in `find` and `delete`, respectively.
+unsafe impl<K: Sync, V: Sync> Sync for List<K, V> {}
+unsafe impl<K: Send, V: Send> Send for List<K, V> {}
+
 impl<K, V> Default for List<K, V>
 where
     K: Ord,

src/lockfree/queue.rs

@@ -8,7 +8,7 @@
 use core::mem::{self, MaybeUninit};
 use core::sync::atomic::Ordering::*;
 
-use crossbeam_epoch::{unprotected, Atomic, Guard, Owned, Shared};
+use crossbeam_epoch::{Atomic, Guard, Owned, Shared};
 use crossbeam_utils::CachePadded;
 
 /// Michael-Scott queue.
@@ -39,21 +39,16 @@ unsafe impl<T: Send> Send for Queue<T> {}
 
 impl<T> Default for Queue<T> {
     fn default() -> Self {
-        let q = Self {
-            head: CachePadded::new(Atomic::null()),
-            tail: CachePadded::new(Atomic::null()),
-        };
-
-        // SAFETY: We are creating a new queue, hence have sole ownership of it.
-        let sentinel = Owned::new(Node {
+        let sentinel = Box::into_raw(Box::new(Node {
             data: MaybeUninit::uninit(),
             next: Atomic::null(),
-        })
-        .into_shared(unsafe { unprotected() });
+        }))
+        .cast_const();
 
-        q.head.store(sentinel, Relaxed);
-        q.tail.store(sentinel, Relaxed);
-        q
+        Self {
+            head: CachePadded::new(sentinel.into()),
+            tail: CachePadded::new(sentinel.into()),
+        }
     }
 }