Use table iterators (requires rust-lang#667)

Author: clarfonthey

src/map.rs

@@ -1,5 +1,5 @@
-use crate::raw::{Allocator, Bucket, Global, RawDrain, RawExtractIf, RawIntoIter, RawIter};
-use crate::{DefaultHashBuilder, Equivalent, HashTable, TryReserveError};
+use crate::raw::{Allocator, Bucket, Global, RawExtractIf};
+use crate::{hash_table, DefaultHashBuilder, Equivalent, HashTable, TryReserveError};
 use core::borrow::Borrow;
 use core::fmt::{self, Debug};
 use core::hash::{BuildHasher, Hash};
@@ -750,12 +750,8 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn iter(&self) -> Iter<'_, K, V> {
-        // Here we tie the lifetime of self to the iter.
-        unsafe {
-            Iter {
-                inner: self.table.raw.iter(),
-                marker: PhantomData,
-            }
+        Iter {
+            inner: self.table.iter(),
         }
     }
 
@@ -795,10 +791,10 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
-        // Here we tie the lifetime of self to the iter.
+        // We need iter_unsafe_mut to make the keys variant
         unsafe {
             IterMut {
-                inner: self.table.raw.iter(),
+                inner: self.table.iter_unsafe_mut(),
                 marker: PhantomData,
             }
         }
@@ -885,7 +881,7 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn drain(&mut self) -> Drain<'_, K, V, A> {
         Drain {
-            inner: self.table.raw.drain(),
+            inner: self.table.drain(),
         }
     }
 
@@ -2196,8 +2192,7 @@ where
 /// assert_eq!(iter.next(), None);
 /// ```
 pub struct Iter<'a, K, V> {
-    inner: RawIter<(K, V)>,
-    marker: PhantomData<(&'a K, &'a V)>,
+    inner: hash_table::Iter<'a, (K, V)>,
 }
 
 // FIXME(#26925) Remove in favor of `#[derive(Clone)]`
@@ -2206,7 +2201,6 @@ impl<K, V> Clone for Iter<'_, K, V> {
     fn clone(&self) -> Self {
         Iter {
             inner: self.inner.clone(),
-            marker: PhantomData,
         }
     }
 }
@@ -2245,7 +2239,7 @@ impl<K: Debug, V: Debug> fmt::Debug for Iter<'_, K, V> {
 /// assert_eq!(map.get(&2).unwrap(), &"Two Mississippi".to_owned());
 /// ```
 pub struct IterMut<'a, K, V> {
-    inner: RawIter<(K, V)>,
+    inner: hash_table::IterUnsafeMut<'a, (K, V)>,
     // To ensure invariance with respect to V
     marker: PhantomData<(&'a K, &'a mut V)>,
 }
@@ -2260,8 +2254,7 @@ impl<K, V> IterMut<'_, K, V> {
     #[cfg_attr(feature = "inline-more", inline)]
     pub(super) fn iter(&self) -> Iter<'_, K, V> {
         Iter {
-            inner: self.inner.clone(),
-            marker: PhantomData,
+            inner: self.inner.iter(),
         }
     }
 }
@@ -2297,7 +2290,7 @@ impl<K, V> IterMut<'_, K, V> {
 /// assert_eq!(iter.next(), None);
 /// ```
 pub struct IntoIter<K, V, A: Allocator = Global> {
-    inner: RawIntoIter<(K, V), A>,
+    inner: hash_table::IntoIter<(K, V), A>,
 }
 
 impl<K, V, A: Allocator> IntoIter<K, V, A> {
@@ -2306,7 +2299,6 @@ impl<K, V, A: Allocator> IntoIter<K, V, A> {
     pub(super) fn iter(&self) -> Iter<'_, K, V> {
         Iter {
             inner: self.inner.iter(),
-            marker: PhantomData,
         }
     }
 }
@@ -2593,7 +2585,7 @@ impl<K, V: Debug> fmt::Debug for Values<'_, K, V> {
 /// assert_eq!(drain_iter.next(), None);
 /// ```
 pub struct Drain<'a, K, V, A: Allocator = Global> {
-    inner: RawDrain<'a, (K, V), A>,
+    inner: hash_table::Drain<'a, (K, V), A>,
 }
 
 impl<K, V, A: Allocator> Drain<'_, K, V, A> {
@@ -2602,7 +2594,6 @@ impl<K, V, A: Allocator> Drain<'_, K, V, A> {
     pub(super) fn iter(&self) -> Iter<'_, K, V> {
         Iter {
             inner: self.inner.iter(),
-            marker: PhantomData,
         }
     }
 }
@@ -3190,7 +3181,7 @@ impl<K, V, S, A: Allocator> IntoIterator for HashMap<K, V, S, A> {
     #[cfg_attr(feature = "inline-more", inline)]
     fn into_iter(self) -> IntoIter<K, V, A> {
         IntoIter {
-            inner: self.table.raw.into_iter(),
+            inner: self.table.into_iter(),
         }
     }
 }
@@ -3200,21 +3191,17 @@ impl<K, V> Default for Iter<'_, K, V> {
     fn default() -> Self {
         Self {
             inner: Default::default(),
-            marker: PhantomData,
         }
     }
 }
-impl<'a, K, V> Iterator for Iter<'a, K, V> {
+impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> {
     type Item = (&'a K, &'a V);
 
     #[cfg_attr(feature = "inline-more", inline)]
     fn next(&mut self) -> Option<(&'a K, &'a V)> {
         // Avoid `Option::map` because it bloats LLVM IR.
         match self.inner.next() {
-            Some(x) => unsafe {
-                let r = x.as_ref();
-                Some((&r.0, &r.1))
-            },
+            Some(x) => Some((&x.0, &x.1)),
             None => None,
         }
     }
@@ -3228,20 +3215,17 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> {
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,
     {
-        self.inner.fold(init, |acc, x| unsafe {
-            let (k, v) = x.as_ref();
-            f(acc, (k, v))
-        })
+        self.inner.fold(init, |acc, (k, v)| f(acc, (k, v)))
     }
 }
-impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
+impl<'a, K: 'a, V: 'a> ExactSizeIterator for Iter<'a, K, V> {
     #[cfg_attr(feature = "inline-more", inline)]
     fn len(&self) -> usize {
         self.inner.len()
     }
 }
 
-impl<K, V> FusedIterator for Iter<'_, K, V> {}
+impl<'a, K: 'a, V: 'a> FusedIterator for Iter<'a, K, V> {}
 
 impl<K, V> Default for IterMut<'_, K, V> {
     #[cfg_attr(feature = "inline-more", inline)]
@@ -3259,10 +3243,7 @@ impl<'a, K, V> Iterator for IterMut<'a, K, V> {
     fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
         // Avoid `Option::map` because it bloats LLVM IR.
         match self.inner.next() {
-            Some(x) => unsafe {
-                let r = x.as_mut();
-                Some((&r.0, &mut r.1))
-            },
+            Some(x) => Some((&x.0, &mut x.1)),
             None => None,
         }
     }
@@ -3276,10 +3257,7 @@ impl<'a, K, V> Iterator for IterMut<'a, K, V> {
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,
     {
-        self.inner.fold(init, |acc, x| unsafe {
-            let (k, v) = x.as_mut();
-            f(acc, (k, v))
-        })
+        self.inner.fold(init, |acc, (k, v)| f(acc, (k, v)))
     }
 }
 impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {