Remove Send impl from Entry/LruEntry, relax Sync bounds, bump version to 0.2.1

Entry and LruEntry are RAII lock guards that should not be Send (similar to
MutexGuard). The Sync impl only needs K: Sync + V: Sync since sharing &Entry
only involves shared references, not ownership transfer.

Co-authored-by: SF-Zhou <7477599+SF-Zhou@users.noreply.github.com>

Author: Copilot

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lockmap"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 
 authors = ["SF-Zhou <sfzhou.scut@gmail.com>"]

src/lockmap.rs

@@ -699,8 +699,10 @@ pub struct Entry<'a, K: Eq + Hash, V> {
 }
 
 // SAFETY: The guard holds a per-key mutex lock and a valid, ref-counted pointer.
-unsafe impl<K: Eq + Hash + Send, V: Send> Send for Entry<'_, K, V> {}
-unsafe impl<K: Eq + Hash + Send + Sync, V: Send + Sync> Sync for Entry<'_, K, V> {}
+// Entry is intentionally !Send — like MutexGuard, it should not be moved across threads.
+// For Sync, only K: Sync and V: Sync are needed: sharing &Entry across threads only
+// requires shared references (&K, &Option<V>) to be safe to share, not ownership transfer.
+unsafe impl<K: Eq + Hash + Sync, V: Sync> Sync for Entry<'_, K, V> {}
 
 impl<K: Eq + Hash, V> Entry<'_, K, V> {
     /// Returns a reference to the entry's key.
@@ -1199,4 +1201,12 @@ mod tests {
             assert_eq!(lock_map.get(&(i as u32)), Some(i as u32));
         }
     }
+
+    // Compile-time trait assertions: Entry must be !Send but Sync when K, V: Sync.
+    const _: () = {
+        fn assert_sync<T: Sync>() {}
+        fn assert_entry_sync() {
+            assert_sync::<Entry<'_, String, String>>();
+        }
+    };
 }

src/lru_lockmap.rs

@@ -809,8 +809,10 @@ pub struct LruEntry<'a, K: Eq + Hash, V> {
 }
 
 // SAFETY: The guard holds a per-key mutex lock and a valid, ref-counted pointer.
-unsafe impl<K: Eq + Hash + Send, V: Send> Send for LruEntry<'_, K, V> {}
-unsafe impl<K: Eq + Hash + Send + Sync, V: Send + Sync> Sync for LruEntry<'_, K, V> {}
+// LruEntry is intentionally !Send — like MutexGuard, it should not be moved across threads.
+// For Sync, only K: Sync and V: Sync are needed: sharing &LruEntry across threads only
+// requires shared references (&K, &Option<V>) to be safe to share, not ownership transfer.
+unsafe impl<K: Eq + Hash + Sync, V: Sync> Sync for LruEntry<'_, K, V> {}
 
 impl<K: Eq + Hash, V> LruEntry<'_, K, V> {
     /// Returns a reference to the entry's key.
@@ -1627,4 +1629,12 @@ mod tests {
             THREADS as u32 * OPS_PER_THREAD as u32
         );
     }
+
+    // Compile-time trait assertions: LruEntry must be !Send but Sync when K, V: Sync.
+    const _: () = {
+        fn assert_sync<T: Sync>() {}
+        fn assert_lru_entry_sync() {
+            assert_sync::<LruEntry<'_, String, String>>();
+        }
+    };
 }