New take: use MaybeUninit

Here is a new take on fixing the soundness bugs with `ShallowCopy`: get
rid of `ShallowCopy` entirely and instead store the aliased `T` in a
`MaybeUninit` that we keep two copies of and access unsafely.

Author: jonhoo

evmap/src/inner.rs

@@ -7,12 +7,10 @@ pub(crate) use indexmap::IndexMap as MapImpl;
 pub(crate) use std::collections::HashMap as MapImpl;
 
 use crate::values::Values;
-use crate::ShallowCopy;
 
 pub(crate) struct Inner<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     pub(crate) data: MapImpl<K, Values<V, S>, S>,
@@ -24,8 +22,7 @@ impl<K, V, M, S> fmt::Debug for Inner<K, V, M, S>
 where
     K: Eq + Hash + fmt::Debug,
     S: BuildHasher,
-    V: ShallowCopy,
-    V::Target: fmt::Debug,
+    V: fmt::Debug,
     M: fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -41,7 +38,6 @@ impl<K, V, M, S> Clone for Inner<K, V, M, S>
 where
     K: Eq + Hash + Clone,
     S: BuildHasher + Clone,
-    V: ShallowCopy,
     M: Clone,
 {
     fn clone(&self) -> Self {
@@ -60,7 +56,6 @@ where
 impl<K, V, M, S> Inner<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     pub fn with_hasher(m: M, hash_builder: S) -> Self {

evmap/src/lib.rs

@@ -214,9 +214,8 @@ pub use crate::write::WriteHandle;
 mod read;
 pub use crate::read::{MapReadRef, ReadGuardIter, ReadHandle, ReadHandleFactory};
 
-pub mod shallow_copy;
-pub use crate::shallow_copy::ShallowCopy;
-use shallow_copy::MaybeShallowCopied;
+mod shallow_copy;
+use shallow_copy::ForwardThroughAliased;
 
 // Expose `ReadGuard` since it has useful methods the user will likely care about.
 #[doc(inline)]
@@ -256,14 +255,11 @@ impl<V: ?Sized> fmt::Debug for Predicate<V> {
 
 /// A pending map operation.
 #[non_exhaustive]
-pub(crate) enum Operation<K, V, M>
-where
-    V: ShallowCopy,
-{
+pub(crate) enum Operation<K, V, M> {
     /// Replace the set of entries for this key with this value.
-    Replace(K, MaybeShallowCopied<V>),
+    Replace(K, ForwardThroughAliased<V>),
     /// Add this value to the set of entries for this key.
-    Add(K, MaybeShallowCopied<V>),
+    Add(K, ForwardThroughAliased<V>),
     /// Remove this value from the set of entries for this key.
     RemoveValue(K, V),
     /// Remove the value set for this key.
@@ -280,29 +276,30 @@ where
     /// Note that this will iterate once over all the keys internally.
     Purge,
     /// Retains all values matching the given predicate.
-    Retain(K, Predicate<V::Target>),
-    /// Shrinks [`MaybeShallowCopied<V>alues`] to their minimum necessary size, freeing memory
+    Retain(K, Predicate<V>),
+    /// Shrinks [`Values`] to their minimum necessary size, freeing memory
     /// and potentially improving cache locality.
     ///
-    /// If no key is given, all `MaybeShallowCopied<V>alues` will shrink to fit.
+    /// If no key is given, all `Values` will shrink to fit.
     Fit(Option<K>),
-    /// Reserves capacity for some number of additional elements in [`MaybeShallowCopied<V>alues`]
+    /// Reserves capacity for some number of additional elements in [`Values`]
     /// for the given key. If the given key does not exist, allocate an empty
-    /// `MaybeShallowCopied<V>alues` with the given capacity.
+    /// `Values` with the given capacity.
     ///
     /// This can improve performance by pre-allocating space for large bags of values.
     Reserve(K, usize),
     /// Mark the map as ready to be consumed for readers.
     MarkReady,
     /// Set the value of the map meta.
     SetMeta(M),
+    /// Copy over the contents of the read map wholesale as the write map is empty.
+    JustCloneRHandle,
 }
 
 impl<K, V, M> fmt::Debug for Operation<K, V, M>
 where
     K: fmt::Debug,
-    V: ShallowCopy + fmt::Debug,
-    V::Target: fmt::Debug,
+    V: fmt::Debug,
     M: fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -320,6 +317,7 @@ where
             Operation::Reserve(ref a, ref b) => f.debug_tuple("Reserve").field(a).field(b).finish(),
             Operation::MarkReady => f.debug_tuple("MarkReady").finish(),
             Operation::SetMeta(ref a) => f.debug_tuple("SetMeta").field(a).finish(),
+            Operation::JustCloneRHandle => f.debug_tuple("JustCloneRHandle").finish(),
         }
     }
 }
@@ -400,8 +398,7 @@ where
     where
         K: Eq + Hash + Clone,
         S: BuildHasher + Clone,
-        V: ShallowCopy,
-        V::Target: Eq + Hash,
+        V: Eq + Hash,
         M: 'static + Clone,
     {
         let inner = if let Some(cap) = self.capacity {
@@ -427,8 +424,7 @@ pub fn new<K, V>() -> (
 )
 where
     K: Eq + Hash + Clone,
-    V: ShallowCopy,
-    V::Target: Eq + Hash,
+    V: Eq + Hash,
 {
     Options::default().construct()
 }
@@ -445,8 +441,7 @@ pub fn with_meta<K, V, M>(
 )
 where
     K: Eq + Hash + Clone,
-    V: ShallowCopy,
-    V::Target: Eq + Hash,
+    V: Eq + Hash,
     M: 'static + Clone,
 {
     Options::default().with_meta(meta).construct()
@@ -462,8 +457,7 @@ pub fn with_hasher<K, V, M, S>(
 ) -> (WriteHandle<K, V, M, S>, ReadHandle<K, V, M, S>)
 where
     K: Eq + Hash + Clone,
-    V: ShallowCopy,
-    V::Target: Eq + Hash,
+    V: Eq + Hash,
     M: 'static + Clone,
     S: BuildHasher + Clone,
 {

evmap/src/read.rs

@@ -1,6 +1,6 @@
 use crate::inner::Inner;
+use crate::shallow_copy::ForwardThroughAliased;
 use crate::values::Values;
-use crate::ShallowCopy;
 use left_right::ReadGuard;
 
 use std::borrow::Borrow;
@@ -23,7 +23,6 @@ pub use factory::ReadHandleFactory;
 pub struct ReadHandle<K, V, M = (), S = RandomState>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     pub(crate) handle: left_right::ReadHandle<Inner<K, V, M, S>>,
@@ -32,7 +31,6 @@ where
 impl<K, V, M, S> fmt::Debug for ReadHandle<K, V, M, S>
 where
     K: Eq + Hash + fmt::Debug,
-    V: ShallowCopy,
     S: BuildHasher,
     M: fmt::Debug,
 {
@@ -46,7 +44,6 @@ where
 impl<K, V, M, S> Clone for ReadHandle<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     fn clone(&self) -> Self {
@@ -59,7 +56,6 @@ where
 impl<K, V, M, S> ReadHandle<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     pub(crate) fn new(handle: left_right::ReadHandle<Inner<K, V, M, S>>) -> Self {
@@ -70,8 +66,7 @@ where
 impl<K, V, M, S> ReadHandle<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
-    V::Target: Eq + Hash,
+    V: Eq + Hash,
     S: BuildHasher,
     M: Clone,
 {
@@ -156,7 +151,7 @@ where
     /// refreshed by the writer. If no refresh has happened, or the map has been destroyed, this
     /// function returns `None`.
     #[inline]
-    pub fn get_one<'rh, Q: ?Sized>(&'rh self, key: &'_ Q) -> Option<ReadGuard<'rh, V::Target>>
+    pub fn get_one<'rh, Q: ?Sized>(&'rh self, key: &'_ Q) -> Option<ReadGuard<'rh, V>>
     where
         K: Borrow<Q>,
         Q: Hash + Eq,
@@ -210,12 +205,15 @@ where
 
     /// Returns true if the map contains the specified value for the specified key.
     ///
-    /// The key may be any borrowed form of the map's key type, but `Hash` and
+    /// The key and value may be any borrowed form of the map's respective types, but `Hash` and
     /// `Eq` on the borrowed form *must* match.
-    pub fn contains_value<Q: ?Sized>(&self, key: &Q, value: &V::Target) -> bool
+    pub fn contains_value<Q: ?Sized, W: ?Sized>(&self, key: &Q, value: &W) -> bool
     where
         K: Borrow<Q>,
+        ForwardThroughAliased<V>: Borrow<W>,
         Q: Hash + Eq,
+        W: Hash + Eq,
+        V: Hash + Eq,
     {
         self.get_raw(key.borrow())
             .map(|x| x.contains(value))

evmap/src/read/factory.rs

@@ -1,6 +1,5 @@
 use super::ReadHandle;
 use crate::inner::Inner;
-use crate::ShallowCopy;
 use std::collections::hash_map::RandomState;
 use std::fmt;
 use std::hash::{BuildHasher, Hash};
@@ -14,7 +13,6 @@ use std::hash::{BuildHasher, Hash};
 pub struct ReadHandleFactory<K, V, M, S = RandomState>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     pub(super) factory: left_right::ReadHandleFactory<Inner<K, V, M, S>>,
@@ -23,7 +21,6 @@ where
 impl<K, V, M, S> fmt::Debug for ReadHandleFactory<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -36,7 +33,6 @@ where
 impl<K, V, M, S> Clone for ReadHandleFactory<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     fn clone(&self) -> Self {
@@ -49,7 +45,6 @@ where
 impl<K, V, M, S> ReadHandleFactory<K, V, M, S>
 where
     K: Eq + Hash,
-    V: ShallowCopy,
     S: BuildHasher,
 {
     /// Produce a new [`ReadHandle`] to the same left-right data structure as this factory was