make explicit

xacrimon · xacrimon · commit f01fc7580bac · 2022-02-06T17:19:45.000+01:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -993,9 +993,7 @@ impl<'a, K: 'a + Eq + Hash, V: 'a, S: 'a + BuildHasher + Clone> Map<'a, K, V, S>
         if let Some((kptr, vptr)) = shard.get_key_value(&key) {
             unsafe {
                 let kptr = util::change_lifetime_const(kptr);
-
                 let vptr = &mut *vptr.as_ptr();
-
                 Entry::Occupied(OccupiedEntry::new(shard, key, (kptr, vptr)))
             }
         } else {
diff --git a/src/mapref/entry.rs b/src/mapref/entry.rs
@@ -132,7 +132,7 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> VacantEntry<'a, K, V, S> {
 
 pub struct OccupiedEntry<'a, K, V, S> {
     shard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
-    elem: (&'a K, &'a mut V),
+    elem: (*const K, *mut V),
     key: K,
 }
 
@@ -147,21 +147,21 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> OccupiedEntry<'a, K, V, S> {
     pub(crate) fn new(
         shard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
         key: K,
-        elem: (&'a K, &'a mut V),
+        elem: (*const K, *mut V),
     ) -> Self {
         Self { shard, elem, key }
     }
 
     pub fn get(&self) -> &V {
-        self.elem.1
+        unsafe { &*self.elem.1 }
     }
 
     pub fn get_mut(&mut self) -> &mut V {
-        self.elem.1
+        unsafe { &mut *self.elem.1 }
     }
 
     pub fn insert(&mut self, value: V) -> V {
-        mem::replace(self.elem.1, value)
+        mem::replace(self.get_mut(), value)
     }
 
     pub fn into_ref(self) -> RefMut<'a, K, V, S> {
@@ -173,26 +173,25 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> OccupiedEntry<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.elem.0
+        unsafe { &*self.elem.0 }
     }
 
     pub fn remove(mut self) -> V {
-        self.shard.remove(self.elem.0).unwrap().into_inner()
+        let key = unsafe { &*self.elem.0 };
+        self.shard.remove(key).unwrap().into_inner()
     }
 
     pub fn remove_entry(mut self) -> (K, V) {
-        let (k, v) = self.shard.remove_entry(self.elem.0).unwrap();
-
+        let key = unsafe { &*self.elem.0 };
+        let (k, v) = self.shard.remove_entry(key).unwrap();
         (k, v.into_inner())
     }
 
     pub fn replace_entry(mut self, value: V) -> (K, V) {
         let nk = self.key;
-
-        let (k, v) = self.shard.remove_entry(self.elem.0).unwrap();
-
+        let key = unsafe { &*self.elem.0 };
+        let (k, v) = self.shard.remove_entry(key).unwrap();
         self.shard.insert(nk, SharedValue::new(value));
-
         (k, v.into_inner())
     }
 }
diff --git a/src/mapref/multiple.rs b/src/mapref/multiple.rs
@@ -8,8 +8,8 @@ use std::sync::Arc;
 
 pub struct RefMulti<'a, K, V, S = RandomState> {
     _guard: Arc<RwLockReadGuard<'a, HashMap<K, V, S>>>,
-    k: &'a K,
-    v: &'a V,
+    k: *const K,
+    v: *const V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMulti<'a, K, V, S> {}
@@ -22,8 +22,8 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMulti<'a, K, V, S> {
     pub(crate) fn new(
         guard: Arc<RwLockReadGuard<'a, HashMap<K, V, S>>>,
-        k: &'a K,
-        v: &'a V,
+        k: *const K,
+        v: *const V,
     ) -> Self {
         Self {
             _guard: guard,
@@ -33,15 +33,15 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMulti<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 }
 
@@ -55,8 +55,8 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for RefMulti<'a, K, V, S> {
 
 pub struct RefMutMulti<'a, K, V, S = RandomState> {
     _guard: Arc<RwLockWriteGuard<'a, HashMap<K, V, S>>>,
-    k: &'a K,
-    v: &'a mut V,
+    k: *const K,
+    v: *mut V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMutMulti<'a, K, V, S> {}
@@ -69,8 +69,8 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMutMulti<'a, K, V, S> {
     pub(crate) fn new(
         guard: Arc<RwLockWriteGuard<'a, HashMap<K, V, S>>>,
-        k: &'a K,
-        v: &'a mut V,
+        k: *const K,
+        v: *mut V,
     ) -> Self {
         Self {
             _guard: guard,
@@ -80,23 +80,23 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMutMulti<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn value_mut(&mut self) -> &mut V {
-        self.v
+        self.pair_mut().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 
     pub fn pair_mut(&mut self) -> (&K, &mut V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &mut *self.v) }
     }
 }
 
diff --git a/src/mapref/one.rs b/src/mapref/one.rs
@@ -6,8 +6,8 @@ use std::collections::hash_map::RandomState;
 
 pub struct Ref<'a, K, V, S = RandomState> {
     _guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
-    k: &'a K,
-    v: &'a V,
+    k: *const K,
+    v: *const V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for Ref<'a, K, V, S> {}
@@ -18,7 +18,11 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 }
 
 impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {
-    pub(crate) fn new(guard: RwLockReadGuard<'a, HashMap<K, V, S>>, k: &'a K, v: &'a V) -> Self {
+    pub(crate) fn new(
+        guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
+        k: *const K,
+        v: *const V,
+    ) -> Self {
         Self {
             _guard: guard,
             k,
@@ -27,15 +31,15 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 }
 
@@ -49,8 +53,8 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for Ref<'a, K, V, S> {
 
 pub struct RefMut<'a, K, V, S = RandomState> {
     guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
-    k: &'a K,
-    v: &'a mut V,
+    k: *const K,
+    v: *mut V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMut<'a, K, V, S> {}
@@ -63,30 +67,30 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMut<'a, K, V, S> {
     pub(crate) fn new(
         guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
-        k: &'a K,
-        v: &'a mut V,
+        k: *const K,
+        v: *mut V,
     ) -> Self {
         Self { guard, k, v }
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn value_mut(&mut self) -> &mut V {
-        self.v
+        self.pair_mut().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 
     pub fn pair_mut(&mut self) -> (&K, &mut V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &mut *self.v) }
     }
 
     pub fn downgrade(self) -> Ref<'a, K, V, S> {

Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> VacantEntry<'a, K, V, S> {`
`132`	`132`
`133`	`133`	`pub struct OccupiedEntry<'a, K, V, S> {`
`134`	`134`	`shard: RwLockWriteGuard<'a, HashMap<K, V, S>>,`
`135`		`- elem: (&'a K, &'a mut V),`
	`135`	`+ elem: (const K, mut V),`
`136`	`136`	`key: K,`
`137`	`137`	`}`
`138`	`138`
`@@ -147,21 +147,21 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> OccupiedEntry<'a, K, V, S> {`
`147`	`147`	`pub(crate) fn new(`
`148`	`148`	`shard: RwLockWriteGuard<'a, HashMap<K, V, S>>,`
`149`	`149`	`key: K,`
`150`		`- elem: (&'a K, &'a mut V),`
	`150`	`+ elem: (const K, mut V),`
`151`	`151`	`) -> Self {`
`152`	`152`	`Self { shard, elem, key }`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`pub fn get(&self) -> &V {`
`156`		`- self.elem.1`
	`156`	`+ unsafe { &*self.elem.1 }`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`pub fn get_mut(&mut self) -> &mut V {`
`160`		`- self.elem.1`
	`160`	`+ unsafe { &mut *self.elem.1 }`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`pub fn insert(&mut self, value: V) -> V {`
`164`		`- mem::replace(self.elem.1, value)`
	`164`	`+ mem::replace(self.get_mut(), value)`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`pub fn into_ref(self) -> RefMut<'a, K, V, S> {`
`@@ -173,26 +173,25 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> OccupiedEntry<'a, K, V, S> {`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`pub fn key(&self) -> &K {`
`176`		`- self.elem.0`
	`176`	`+ unsafe { &*self.elem.0 }`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`pub fn remove(mut self) -> V {`
`180`		`- self.shard.remove(self.elem.0).unwrap().into_inner()`
	`180`	`+ let key = unsafe { &*self.elem.0 };`
	`181`	`+ self.shard.remove(key).unwrap().into_inner()`
`181`	`182`	`}`
`182`	`183`
`183`	`184`	`pub fn remove_entry(mut self) -> (K, V) {`
`184`		`- let (k, v) = self.shard.remove_entry(self.elem.0).unwrap();`
`185`		`-`
	`185`	`+ let key = unsafe { &*self.elem.0 };`
	`186`	`+ let (k, v) = self.shard.remove_entry(key).unwrap();`
`186`	`187`	`(k, v.into_inner())`
`187`	`188`	`}`
`188`	`189`
`189`	`190`	`pub fn replace_entry(mut self, value: V) -> (K, V) {`
`190`	`191`	`let nk = self.key;`
`191`		`-`
`192`		`- let (k, v) = self.shard.remove_entry(self.elem.0).unwrap();`
`193`		`-`
	`192`	`+ let key = unsafe { &*self.elem.0 };`
	`193`	`+ let (k, v) = self.shard.remove_entry(key).unwrap();`
`194`	`194`	`self.shard.insert(nk, SharedValue::new(value));`
`195`		`-`
`196`	`195`	`(k, v.into_inner())`
`197`	`196`	`}`
`198`	`197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ use std::sync::Arc;`
`8`	`8`
`9`	`9`	`pub struct RefMulti<'a, K, V, S = RandomState> {`
`10`	`10`	`_guard: Arc<RwLockReadGuard<'a, HashMap<K, V, S>>>,`
`11`		`- k: &'a K,`
`12`		`- v: &'a V,`
	`11`	`+ k: *const K,`
	`12`	`+ v: *const V,`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMulti<'a, K, V, S> {}`
`@@ -22,8 +22,8 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync`
`22`	`22`	`impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMulti<'a, K, V, S> {`
`23`	`23`	`pub(crate) fn new(`
`24`	`24`	`guard: Arc<RwLockReadGuard<'a, HashMap<K, V, S>>>,`
`25`		`- k: &'a K,`
`26`		`- v: &'a V,`
	`25`	`+ k: *const K,`
	`26`	`+ v: *const V,`
`27`	`27`	`) -> Self {`
`28`	`28`	`Self {`
`29`	`29`	`_guard: guard,`
`@@ -33,15 +33,15 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMulti<'a, K, V, S> {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`pub fn key(&self) -> &K {`
`36`		`- self.k`
	`36`	`+ self.pair().0`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`pub fn value(&self) -> &V {`
`40`		`- self.v`
	`40`	`+ self.pair().1`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`pub fn pair(&self) -> (&K, &V) {`
`44`		`- (self.k, self.v)`
	`44`	`+ unsafe { (&self.k, &self.v) }`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`@@ -55,8 +55,8 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for RefMulti<'a, K, V, S> {`
`55`	`55`
`56`	`56`	`pub struct RefMutMulti<'a, K, V, S = RandomState> {`
`57`	`57`	`_guard: Arc<RwLockWriteGuard<'a, HashMap<K, V, S>>>,`
`58`		`- k: &'a K,`
`59`		`- v: &'a mut V,`
	`58`	`+ k: *const K,`
	`59`	`+ v: *mut V,`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMutMulti<'a, K, V, S> {}`
`@@ -69,8 +69,8 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync`
`69`	`69`	`impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMutMulti<'a, K, V, S> {`
`70`	`70`	`pub(crate) fn new(`
`71`	`71`	`guard: Arc<RwLockWriteGuard<'a, HashMap<K, V, S>>>,`
`72`		`- k: &'a K,`
`73`		`- v: &'a mut V,`
	`72`	`+ k: *const K,`
	`73`	`+ v: *mut V,`
`74`	`74`	`) -> Self {`
`75`	`75`	`Self {`
`76`	`76`	`_guard: guard,`
`@@ -80,23 +80,23 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMutMulti<'a, K, V, S> {`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`pub fn key(&self) -> &K {`
`83`		`- self.k`
	`83`	`+ self.pair().0`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`pub fn value(&self) -> &V {`
`87`		`- self.v`
	`87`	`+ self.pair().1`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`pub fn value_mut(&mut self) -> &mut V {`
`91`		`- self.v`
	`91`	`+ self.pair_mut().1`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`pub fn pair(&self) -> (&K, &V) {`
`95`		`- (self.k, self.v)`
	`95`	`+ unsafe { (&self.k, &self.v) }`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`pub fn pair_mut(&mut self) -> (&K, &mut V) {`
`99`		`- (self.k, self.v)`
	`99`	`+ unsafe { (&self.k, &mut self.v) }`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
Original file line number	Diff line number	Diff line change
`@@ -6,8 +6,8 @@ use std::collections::hash_map::RandomState;`
`6`	`6`
`7`	`7`	`pub struct Ref<'a, K, V, S = RandomState> {`
`8`	`8`	`_guard: RwLockReadGuard<'a, HashMap<K, V, S>>,`
`9`		`- k: &'a K,`
`10`		`- v: &'a V,`
	`9`	`+ k: *const K,`
	`10`	`+ v: *const V,`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for Ref<'a, K, V, S> {}`
`@@ -18,7 +18,11 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {`
`21`		`- pub(crate) fn new(guard: RwLockReadGuard<'a, HashMap<K, V, S>>, k: &'a K, v: &'a V) -> Self {`
	`21`	`+ pub(crate) fn new(`
	`22`	`+ guard: RwLockReadGuard<'a, HashMap<K, V, S>>,`
	`23`	`+ k: *const K,`
	`24`	`+ v: *const V,`
	`25`	`+ ) -> Self {`
`22`	`26`	`Self {`
`23`	`27`	`_guard: guard,`
`24`	`28`	`k,`
`@@ -27,15 +31,15 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {`
`27`	`31`	`}`
`28`	`32`
`29`	`33`	`pub fn key(&self) -> &K {`
`30`		`- self.k`
	`34`	`+ self.pair().0`
`31`	`35`	`}`
`32`	`36`
`33`	`37`	`pub fn value(&self) -> &V {`
`34`		`- self.v`
	`38`	`+ self.pair().1`
`35`	`39`	`}`
`36`	`40`
`37`	`41`	`pub fn pair(&self) -> (&K, &V) {`
`38`		`- (self.k, self.v)`
	`42`	`+ unsafe { (&self.k, &self.v) }`
`39`	`43`	`}`
`40`	`44`	`}`
`41`	`45`
`@@ -49,8 +53,8 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for Ref<'a, K, V, S> {`
`49`	`53`
`50`	`54`	`pub struct RefMut<'a, K, V, S = RandomState> {`
`51`	`55`	`guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,`
`52`		`- k: &'a K,`
`53`		`- v: &'a mut V,`
	`56`	`+ k: *const K,`
	`57`	`+ v: *mut V,`
`54`	`58`	`}`
`55`	`59`
`56`	`60`	`unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMut<'a, K, V, S> {}`
`@@ -63,30 +67,30 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync`
`63`	`67`	`impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMut<'a, K, V, S> {`
`64`	`68`	`pub(crate) fn new(`
`65`	`69`	`guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,`
`66`		`- k: &'a K,`
`67`		`- v: &'a mut V,`
	`70`	`+ k: *const K,`
	`71`	`+ v: *mut V,`
`68`	`72`	`) -> Self {`
`69`	`73`	`Self { guard, k, v }`
`70`	`74`	`}`
`71`	`75`
`72`	`76`	`pub fn key(&self) -> &K {`
`73`		`- self.k`
	`77`	`+ self.pair().0`
`74`	`78`	`}`
`75`	`79`
`76`	`80`	`pub fn value(&self) -> &V {`
`77`		`- self.v`
	`81`	`+ self.pair().1`
`78`	`82`	`}`
`79`	`83`
`80`	`84`	`pub fn value_mut(&mut self) -> &mut V {`
`81`		`- self.v`
	`85`	`+ self.pair_mut().1`
`82`	`86`	`}`
`83`	`87`
`84`	`88`	`pub fn pair(&self) -> (&K, &V) {`
`85`		`- (self.k, self.v)`
	`89`	`+ unsafe { (&self.k, &self.v) }`
`86`	`90`	`}`
`87`	`91`
`88`	`92`	`pub fn pair_mut(&mut self) -> (&K, &mut V) {`
`89`		`- (self.k, self.v)`
	`93`	`+ unsafe { (&self.k, &mut self.v) }`
`90`	`94`	`}`
`91`	`95`
`92`	`96`	`pub fn downgrade(self) -> Ref<'a, K, V, S> {`