Misc code cleanup

Author: Amanieu

src/map.rs

@@ -898,7 +898,6 @@ where
         unsafe {
             let hash = make_hash(&self.hash_builder, &k);
             if let Some(item) = self.table.find(hash, |x| k.eq(x.0.borrow())) {
-                // Erase the element from the table first since drop might panic.
                 self.table.erase_no_drop(&item);
                 Some(item.read())
             } else {
@@ -1568,7 +1567,6 @@ impl<'a, K, V> RawOccupiedEntryMut<'a, K, V> {
     /// Take the ownership of the key and value from the map.
     pub fn remove_entry(self) -> (K, V) {
         unsafe {
-            // Erase the element from the table first since drop might panic.
             self.table.erase_no_drop(&self.elem);
             self.elem.read()
         }
@@ -1656,7 +1654,7 @@ pub enum Entry<'a, K: 'a, V: 'a, S: 'a> {
     Vacant(VacantEntry<'a, K, V, S>),
 }
 
-impl<'a, K: 'a + Debug + Eq + Hash, V: 'a + Debug, S: BuildHasher> Debug for Entry<'a, K, V, S> {
+impl<'a, K: 'a + Debug + Eq + Hash, V: 'a + Debug, S: 'a> Debug for Entry<'a, K, V, S> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Vacant(ref v) => f.debug_tuple("Entry").field(v).finish(),
@@ -1709,7 +1707,7 @@ pub struct VacantEntry<'a, K: 'a, V: 'a, S: 'a> {
     table: &'a mut HashMap<K, V, S>,
 }
 
-impl<'a, K: 'a + Debug + Eq + Hash, V: 'a, S: 'a + BuildHasher> Debug for VacantEntry<'a, K, V, S> {
+impl<'a, K: 'a + Debug + Eq + Hash, V: 'a, S> Debug for VacantEntry<'a, K, V, S> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_tuple("VacantEntry").field(self.key()).finish()
     }
@@ -1959,7 +1957,7 @@ where
     }
 }
 
-impl<'a, K: Eq + Hash, V, S: BuildHasher> Entry<'a, K, V, S> {
+impl<'a, K, V, S> Entry<'a, K, V, S> {
     /// Ensures a value is in the entry by inserting the default if empty, and returns
     /// a mutable reference to the value in the entry.
     ///
@@ -1977,7 +1975,11 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Entry<'a, K, V, S> {
     /// assert_eq!(map["poneyland"], 6);
     /// ```
     #[inline]
-    pub fn or_insert(self, default: V) -> &'a mut V {
+    pub fn or_insert(self, default: V) -> &'a mut V
+    where
+        K: Hash,
+        S: BuildHasher,
+    {
         match self {
             Occupied(entry) => entry.into_mut(),
             Vacant(entry) => entry.insert(default),
@@ -2000,7 +2002,11 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Entry<'a, K, V, S> {
     /// assert_eq!(map["poneyland"], "hoho".to_string());
     /// ```
     #[inline]
-    pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
+    pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V
+    where
+        K: Hash,
+        S: BuildHasher,
+    {
         match self {
             Occupied(entry) => entry.into_mut(),
             Vacant(entry) => entry.insert(default()),
@@ -2060,7 +2066,7 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Entry<'a, K, V, S> {
     }
 }
 
-impl<'a, K: Eq + Hash, V: Default, S: BuildHasher> Entry<'a, K, V, S> {
+impl<'a, K, V: Default, S> Entry<'a, K, V, S> {
     /// Ensures a value is in the entry by inserting the default value if empty,
     /// and returns a mutable reference to the value in the entry.
     ///
@@ -2077,7 +2083,11 @@ impl<'a, K: Eq + Hash, V: Default, S: BuildHasher> Entry<'a, K, V, S> {
     /// # }
     /// ```
     #[inline]
-    pub fn or_default(self) -> &'a mut V {
+    pub fn or_default(self) -> &'a mut V
+    where
+        K: Hash,
+        S: BuildHasher,
+    {
         match self {
             Occupied(entry) => entry.into_mut(),
             Vacant(entry) => entry.insert(Default::default()),
@@ -2123,7 +2133,6 @@ impl<'a, K, V, S> OccupiedEntry<'a, K, V, S> {
     #[inline]
     pub fn remove_entry(self) -> (K, V) {
         unsafe {
-            // Erase the element from the table first since drop might panic.
             self.table.table.erase_no_drop(&self.elem);
             self.elem.read()
         }
@@ -2316,7 +2325,7 @@ impl<'a, K, V, S> OccupiedEntry<'a, K, V, S> {
     }
 }
 
-impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher> VacantEntry<'a, K, V, S> {
+impl<'a, K: 'a, V: 'a, S> VacantEntry<'a, K, V, S> {
     /// Gets a reference to the key that would be used when inserting a value
     /// through the `VacantEntry`.
     ///
@@ -2369,7 +2378,11 @@ impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher> VacantEntry<'a, K, V, S> {
     /// assert_eq!(map["poneyland"], 37);
     /// ```
     #[inline]
-    pub fn insert(self, value: V) -> &'a mut V {
+    pub fn insert(self, value: V) -> &'a mut V
+    where
+        K: Hash,
+        S: BuildHasher,
+    {
         let hash_builder = &self.table.hash_builder;
         let bucket = self.table.table.insert(self.hash, (self.key, value), |x| {
             make_hash(hash_builder, &x.0)
@@ -2424,6 +2437,7 @@ where
     V: Copy,
     S: BuildHasher,
 {
+    #[inline]
     fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T) {
         self.extend(iter.into_iter().map(|(&key, &value)| (key, value)));
     }

src/raw/bitmask.rs

@@ -1,6 +1,6 @@
+use super::imp::{BitMaskWord, BITMASK_MASK, BITMASK_SHIFT};
 #[cfg(feature = "nightly")]
 use core::intrinsics;
-use raw::imp::{BitMaskWord, BITMASK_MASK, BITMASK_SHIFT};
 
 /// A bit mask which contains the result of a `Match` operation on a `Group` and
 /// allows iterating through them.

src/raw/generic.rs

@@ -1,6 +1,6 @@
+use super::bitmask::BitMask;
+use super::EMPTY;
 use core::{mem, ptr};
-use raw::bitmask::BitMask;
-use raw::EMPTY;
 
 // Use the native word size as the group size. Using a 64-bit group size on
 // a 32-bit architecture will just end up being more expensive because

src/raw/mod.rs

@@ -52,8 +52,8 @@ mod imp;
 
 mod bitmask;
 
-use raw::bitmask::BitMask;
-use raw::imp::Group;
+use self::bitmask::BitMask;
+use self::imp::Group;
 
 /// Control byte value for an empty bucket.
 const EMPTY: u8 = 0b11111111;

src/raw/sse2.rs

@@ -1,6 +1,6 @@
+use super::bitmask::BitMask;
+use super::EMPTY;
 use core::mem;
-use raw::bitmask::BitMask;
-use raw::EMPTY;
 
 #[cfg(target_arch = "x86")]
 use core::arch::x86;

src/set.rs

@@ -1438,8 +1438,8 @@ fn assert_covariance() {
 
 #[cfg(test)]
 mod test_set {
-    use super::HashSet;
     use super::super::map::DefaultHashBuilder;
+    use super::HashSet;
     use std::vec::Vec;
 
     #[test]

tests/set.rs

@@ -2,7 +2,7 @@ extern crate hashbrown;
 extern crate rand;
 
 use hashbrown::HashSet;
-use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::{Rng, SeedableRng, XorShiftRng, distributions::Alphanumeric};
 
 #[test]
 fn test_hashset_insert_remove() {
@@ -16,7 +16,7 @@ fn test_hashset_insert_remove() {
     let mut rng: XorShiftRng = SeedableRng::from_seed(seed);
     //let mut rng: XorShiftRng = XorShiftRng::new_unseeded();
     let tx: Vec<Vec<char>> = (0..4096)
-        .map(|_| (rng.gen_ascii_chars().take(32).collect()))
+        .map(|_| (rng.sample_iter(&Alphanumeric).take(32).collect()))
         .collect();
 
     for _ in 0..32 {