Fix clippy issues

Author: gnzlbg

.travis.yml

@@ -8,7 +8,7 @@ matrix:
       env: TARGET=x86_64-unknown-linux-gnu
       script: sh ci/miri.sh
     - name: "rustfmt/clippy"
-      env: TARGET=x86_64-unknown-linux-gnu
+      env: TARGET=i586-unknown-linux-gnu
       script: sh ci/tools.sh
     - name: "docs"
       env: TARGET=x86_64-unknown-linux-gnu
@@ -34,21 +34,35 @@ matrix:
     - name: "x86_64-unknown-linux-gnu (Rust 1.29.0)"
       rust: stable
       env: TARGET=x86_64-unknown-linux-gnu
+    - name: "i686-unknown-linux-gnu"
+      env: TARGET=i686-unknown-linux-gnu CROSS=1
     - name: "x86_64-apple-darwin"
       env: TARGET=x86_64-apple-darwin
       os: osx
       osx_image: xcode10
+    - name: "i686-apple-darwin"
+      env: TARGET=i686-apple-darwin
+      os: osx
+      osx_image: xcode10
     - name: "x86_64-pc-windows-msvc"
       env: TARGET=x86_64-pc-windows-msvc
       os: windows
     - name: "x86_64-pc-windows-gnu"
       env: TARGET=x86_64-pc-windows-gnu CROSS=1
+    - name: "i686-pc-windows-gnu"
+      env: TARGET=i686-pc-windows-gnu CROSS=1
 
     # Tier 2/3 targets:
     - name: "i586-unknown-linux-gnu (no SSE2)"
       env: TARGET=i586-unknown-linux-gnu CROSS=1
+    - name: "armv7-unknown-linux-gnueabihf"
+      env: TARGET=armv7-unknown-linux-gnueabihf CROSS=1
     - name: "aarch64-unknown-linux-gnu"
       env: TARGET=aarch64-unknown-linux-gnu CROSS=1
+
+  allow_failure:
+    # FIXME:
+    - name: "armv7-unknown-linux-gnueabihf"
 
 install: travis_retry rustup target add "${TARGET}"
 script: sh ci/run.sh

ci/tools.sh

@@ -33,6 +33,12 @@ if retry rustup component add clippy ; then
     cargo clippy --all -- -D clippy::pedantic
 fi
 
+if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
+    if retry rustup component add clippy ; then
+        cargo clippy --all --target=i586-unknown-linux-gnu -- -D clippy::pedantic
+    fi
+fi
+
 if command -v shellcheck ; then
     shellcheck --version
     shellcheck ci/*.sh

clippy.toml

@@ -0,0 +1 @@
+doc-valid-idents = [ "CppCon", "SwissTable", "SipHash", "HashDoS" ]

src/fx.rs

@@ -26,14 +26,14 @@ pub struct FxHasher {
 }
 
 #[cfg(target_pointer_width = "32")]
-const K: usize = 0x9e3779b9;
+const K: usize = 0x9e37_79b9;
 #[cfg(target_pointer_width = "64")]
-const K: usize = 0x517cc1b727220a95;
+const K: usize = 0x517c_c1b7_2722_0a95;
 
 impl Default for FxHasher {
     #[inline]
-    fn default() -> FxHasher {
-        FxHasher { hash: 0 }
+    fn default() -> Self {
+        Self { hash: 0 }
     }
 }
 
@@ -48,14 +48,16 @@ impl Hasher for FxHasher {
     #[inline]
     fn write(&mut self, mut bytes: &[u8]) {
         #[cfg(target_pointer_width = "32")]
-        let read_usize = |bytes| NativeEndian::read_u32(bytes);
+        #[allow(clippy::cast_possible_truncation)]
+        let read_usize = |bytes| NativeEndian::read_u32(bytes) as usize;
         #[cfg(target_pointer_width = "64")]
-        let read_usize = |bytes| NativeEndian::read_u64(bytes);
+        #[allow(clippy::cast_possible_truncation)]
+        let read_usize = |bytes| NativeEndian::read_u64(bytes) as usize;
 
-        let mut hash = FxHasher { hash: self.hash };
+        let mut hash = Self { hash: self.hash };
         assert!(size_of::<usize>() <= 8);
         while bytes.len() >= size_of::<usize>() {
-            hash.add_to_hash(read_usize(bytes) as usize);
+            hash.add_to_hash(read_usize(bytes));
             bytes = &bytes[size_of::<usize>()..];
         }
         if (size_of::<usize>() > 4) && (bytes.len() >= 4) {
@@ -66,7 +68,7 @@ impl Hasher for FxHasher {
             hash.add_to_hash(NativeEndian::read_u16(bytes) as usize);
             bytes = &bytes[2..];
         }
-        if (size_of::<usize>() > 1) && bytes.len() >= 1 {
+        if (size_of::<usize>() > 1) && !bytes.is_empty() {
             hash.add_to_hash(bytes[0] as usize);
         }
         self.hash = hash.hash;
@@ -89,13 +91,15 @@ impl Hasher for FxHasher {
 
     #[cfg(target_pointer_width = "32")]
     #[inline]
+    #[allow(clippy::cast_possible_truncation)]
     fn write_u64(&mut self, i: u64) {
         self.add_to_hash(i as usize);
         self.add_to_hash((i >> 32) as usize);
     }
 
     #[cfg(target_pointer_width = "64")]
     #[inline]
+    #[allow(clippy::cast_possible_truncation)]
     fn write_u64(&mut self, i: u64) {
         self.add_to_hash(i as usize);
     }

src/lib.rs

@@ -2,7 +2,7 @@
 //! map, adapted to make it a drop-in replacement for Rust's standard `HashMap`
 //! and `HashSet` types.
 //!
-//! The original C++ version of SwissTable can be found [here], and this
+//! The original C++ version of [SwissTable] can be found [here], and this
 //! [CppCon talk] gives an overview of how the algorithm works.
 //!
 //! [SwissTable]: https://abseil.io/blog/20180927-swisstables
@@ -24,6 +24,7 @@
 )]
 #![warn(missing_docs)]
 #![cfg_attr(hashbrown_deny_warnings, deny(warnings))]
+#![allow(clippy::module_name_repetitions)]
 
 #[cfg(test)]
 #[macro_use]
@@ -32,7 +33,6 @@ extern crate std;
 #[cfg(test)]
 extern crate rand;
 
-
 #[cfg(feature = "nightly")]
 #[cfg_attr(test, macro_use)]
 extern crate alloc;
@@ -87,7 +87,7 @@ pub mod hash_set {
 pub use map::HashMap;
 pub use set::HashSet;
 
-/// Augments `AllocErr` with a CapacityOverflow variant.
+/// Augments `AllocErr` with a `CapacityOverflow` variant.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum CollectionAllocErr {
     /// Error due to the computed capacity exceeding the collection's maximum

src/map.rs

@@ -1,5 +1,3 @@
-use self::Entry::*;
-
 use core::borrow::Borrow;
 use core::fmt::{self, Debug};
 use core::hash::{BuildHasher, Hash, Hasher};
@@ -212,8 +210,8 @@ impl<K: Hash + Eq, V> HashMap<K, V, DefaultHashBuilder> {
     /// let mut map: HashMap<&str, i32> = HashMap::new();
     /// ```
     #[inline]
-    pub fn new() -> HashMap<K, V, DefaultHashBuilder> {
-        Default::default()
+    pub fn new() -> Self {
+        Self::default()
     }
 
     /// Creates an empty `HashMap` with the specified capacity.
@@ -228,8 +226,8 @@ impl<K: Hash + Eq, V> HashMap<K, V, DefaultHashBuilder> {
     /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);
     /// ```
     #[inline]
-    pub fn with_capacity(capacity: usize) -> HashMap<K, V, DefaultHashBuilder> {
-        HashMap::with_capacity_and_hasher(capacity, Default::default())
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self::with_capacity_and_hasher(capacity, DefaultHashBuilder::default())
     }
 }
 
@@ -259,8 +257,8 @@ where
     /// map.insert(1, 2);
     /// ```
     #[inline]
-    pub fn with_hasher(hash_builder: S) -> HashMap<K, V, S> {
-        HashMap {
+    pub fn with_hasher(hash_builder: S) -> Self {
+        Self {
             hash_builder,
             table: RawTable::new(),
         }
@@ -288,8 +286,8 @@ where
     /// map.insert(1, 2);
     /// ```
     #[inline]
-    pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap<K, V, S> {
-        HashMap {
+    pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self {
+        Self {
             hash_builder,
             table: RawTable::with_capacity(capacity),
         }
@@ -1023,7 +1021,7 @@ where
     V: PartialEq,
     S: BuildHasher,
 {
-    fn eq(&self, other: &HashMap<K, V, S>) -> bool {
+    fn eq(&self, other: &Self) -> bool {
         if self.len() != other.len() {
             return false;
         }
@@ -1059,8 +1057,8 @@ where
 {
     /// Creates an empty `HashMap<K, V, S>`, with the `Default` value for the hasher.
     #[inline]
-    fn default() -> HashMap<K, V, S> {
-        HashMap::with_hasher(Default::default())
+    fn default() -> Self {
+        Self::with_hasher(Default::default())
     }
 }
 
@@ -1245,7 +1243,7 @@ pub struct ValuesMut<'a, K: 'a, V: 'a> {
     inner: IterMut<'a, K, V>,
 }
 
-/// A builder for computing where in a HashMap a key-value pair would be stored.
+/// A builder for computing where in a [`HashMap`] a key-value pair would be stored.
 ///
 /// See the [`HashMap::raw_entry_mut`] docs for usage examples.
 ///
@@ -1288,7 +1286,7 @@ pub struct RawVacantEntryMut<'a, K: 'a, V: 'a, S: 'a> {
     hash_builder: &'a S,
 }
 
-/// A builder for computing where in a HashMap a key-value pair would be stored.
+/// A builder for computing where in a [`HashMap`] a key-value pair would be stored.
 ///
 /// See the [`HashMap::raw_entry`] docs for usage examples.
 ///
@@ -1304,6 +1302,7 @@ where
 {
     /// Create a `RawEntryMut` from the given key.
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     pub fn from_key<Q: ?Sized>(self, k: &Q) -> RawEntryMut<'a, K, V, S>
     where
         K: Borrow<Q>,
@@ -1316,6 +1315,7 @@ where
 
     /// Create a `RawEntryMut` from the given key and its hash.
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> RawEntryMut<'a, K, V, S>
     where
         K: Borrow<Q>,
@@ -1343,6 +1343,7 @@ where
 
     /// Create a `RawEntryMut` from the given hash.
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     pub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S>
     where
         for<'b> F: FnMut(&'b K) -> bool,
@@ -1357,6 +1358,7 @@ where
 {
     /// Access an entry by key.
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     pub fn from_key<Q: ?Sized>(self, k: &Q) -> Option<(&'a K, &'a V)>
     where
         K: Borrow<Q>,
@@ -1369,6 +1371,7 @@ where
 
     /// Access an entry by a key and its hash.
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> Option<(&'a K, &'a V)>
     where
         K: Borrow<Q>,
@@ -1393,6 +1396,7 @@ where
 
     /// Access an entry by hash.
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     pub fn from_hash<F>(self, hash: u64, is_match: F) -> Option<(&'a K, &'a V)>
     where
         F: FnMut(&K) -> bool,
@@ -1614,6 +1618,7 @@ impl<'a, K, V, S> RawVacantEntryMut<'a, K, V, S> {
     /// Sets the value of the entry with the VacantEntry's key,
     /// and returns a mutable reference to it.
     #[inline]
+    #[allow(clippy::shadow_unrelated)]
     pub fn insert_hashed_nocheck(self, hash: u64, key: K, value: V) -> (&'a mut K, &'a mut V)
     where
         K: Hash,
@@ -1683,8 +1688,8 @@ pub enum Entry<'a, K: 'a, V: 'a, S: 'a> {
 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(),
-            Occupied(ref o) => f.debug_tuple("Entry").field(o).finish(),
+            Entry::Vacant(ref v) => f.debug_tuple("Entry").field(v).finish(),
+            Entry::Occupied(ref o) => f.debug_tuple("Entry").field(o).finish(),
         }
     }
 }
@@ -2007,8 +2012,8 @@ impl<'a, K, V, S> Entry<'a, K, V, S> {
         S: BuildHasher,
     {
         match self {
-            Occupied(entry) => entry.into_mut(),
-            Vacant(entry) => entry.insert(default),
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(default),
         }
     }
 
@@ -2034,8 +2039,8 @@ impl<'a, K, V, S> Entry<'a, K, V, S> {
         S: BuildHasher,
     {
         match self {
-            Occupied(entry) => entry.into_mut(),
-            Vacant(entry) => entry.insert(default()),
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(default()),
         }
     }
 
@@ -2052,8 +2057,8 @@ impl<'a, K, V, S> Entry<'a, K, V, S> {
     #[inline]
     pub fn key(&self) -> &K {
         match *self {
-            Occupied(ref entry) => entry.key(),
-            Vacant(ref entry) => entry.key(),
+            Entry::Occupied(ref entry) => entry.key(),
+            Entry::Vacant(ref entry) => entry.key(),
         }
     }
 
@@ -2083,11 +2088,11 @@ impl<'a, K, V, S> Entry<'a, K, V, S> {
         F: FnOnce(&mut V),
     {
         match self {
-            Occupied(mut entry) => {
+            Entry::Occupied(mut entry) => {
                 f(entry.get_mut());
-                Occupied(entry)
+                Entry::Occupied(entry)
             }
-            Vacant(entry) => Vacant(entry),
+            Entry::Vacant(entry) => Entry::Vacant(entry),
         }
     }
 }
@@ -2115,8 +2120,8 @@ impl<'a, K, V: Default, S> Entry<'a, K, V, S> {
         S: BuildHasher,
     {
         match self {
-            Occupied(entry) => entry.into_mut(),
-            Vacant(entry) => entry.insert(Default::default()),
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(Default::default()),
         }
     }
 }
@@ -2423,9 +2428,9 @@ where
     S: BuildHasher + Default,
 {
     #[inline]
-    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> HashMap<K, V, S> {
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
         let iter = iter.into_iter();
-        let mut map = HashMap::with_capacity_and_hasher(iter.size_hint().0, Default::default());
+        let mut map = Self::with_capacity_and_hasher(iter.size_hint().0, S::default());
         for (k, v) in iter {
             map.insert(k, v);
         }