Merge pull request #53 from dtolnay/clippy

Add clippy feature

Author: reem

.travis.yml

@@ -5,7 +5,7 @@ matrix:
         - rust: beta
           env: FEATURES="serde_impl"
         - rust: nightly
-          env: FEATURES="serde_impl nightly"
+          env: FEATURES="serde_impl nightly clippy"
 script:
     - cargo build --features "$FEATURES"
     - cargo test --features "$FEATURES"

Cargo.toml

@@ -20,5 +20,6 @@ nightly = []
 serde_impl = ["serde", "serde_json"]
 
 [dependencies]
+clippy = { version = "0.*", optional = true }
 serde = { version = "^0.7", optional = true }
 serde_json = { version = "^0.7", optional = true }

src/lib.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! A HashMap wrapper that holds key-value pairs in insertion order.
+//! A `HashMap` wrapper that holds key-value pairs in insertion order.
 //!
 //! # Examples
 //!
@@ -30,6 +30,10 @@
 #![forbid(missing_docs)]
 #![cfg_attr(all(feature = "nightly", test), feature(test))]
 
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
+#![cfg_attr(feature = "clippy", deny(clippy))]
+
 // Optional Serde support
 #[cfg(feature = "serde_impl")]
 pub mod serde;
@@ -302,7 +306,7 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
             self.detach(node_ptr);
             self.attach(node_ptr);
         }
-        return value;
+        value
     }
 
     /// Removes and returns the value corresponding to the key from the map.
@@ -367,14 +371,14 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// ```
     #[inline]
     pub fn pop_front(&mut self) -> Option<(K, V)> {
-        if self.len() > 0 {
-            let lru = unsafe { (*self.head).prev };
-            self.detach(lru);
-            return self.map
-                .remove(&KeyRef{k: unsafe { &(*lru).key }})
-                .map(|e| { let e = *e; (e.key, e.value) })
+        if self.is_empty() {
+            return None
         }
-        None
+        let lru = unsafe { (*self.head).prev };
+        self.detach(lru);
+        self.map
+            .remove(&KeyRef{k: unsafe { &(*lru).key }})
+            .map(|e| { let e = *e; (e.key, e.value) })
     }
 
     /// Gets the first entry.
@@ -390,12 +394,12 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// ```
     #[inline]
     pub fn front(&self) -> Option<(&K, &V)> {
-        if self.len() > 0 {
-            let lru = unsafe { (*self.head).prev };
-            return self.map.get(&KeyRef{k: unsafe { &(*lru).key }})
-                .map(|e| (&e.key, &e.value))
+        if self.is_empty() {
+            return None
         }
-        None
+        let lru = unsafe { (*self.head).prev };
+        self.map.get(&KeyRef{k: unsafe { &(*lru).key }})
+            .map(|e| (&e.key, &e.value))
     }
 
     /// Removes the last entry.
@@ -413,14 +417,14 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// ```
     #[inline]
     pub fn pop_back(&mut self) -> Option<(K, V)> {
-        if self.len() > 0 {
-            let mru = unsafe { (*self.head).next };
-            self.detach(mru);
-            return self.map
-                .remove(&KeyRef{k: unsafe { &(*mru).key }})
-                .map(|e| { let e = *e; (e.key, e.value) })
+        if self.is_empty() {
+            return None
         }
-        None
+        let mru = unsafe { (*self.head).next };
+        self.detach(mru);
+        self.map
+            .remove(&KeyRef{k: unsafe { &(*mru).key }})
+            .map(|e| { let e = *e; (e.key, e.value) })
     }
 
     /// Gets the last entry.
@@ -436,12 +440,12 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// ```
     #[inline]
     pub fn back(&mut self) -> Option<(&K, &V)> {
-        if self.len() > 0 {
-            let mru = unsafe { (*self.head).next };
-            return self.map.get(&KeyRef{k: unsafe { &(*mru).key }})
-                .map(|e| (&e.key, &e.value))
+        if self.is_empty() {
+            return None
         }
-        None
+        let mru = unsafe { (*self.head).next };
+        self.map.get(&KeyRef{k: unsafe { &(*mru).key }})
+            .map(|e| (&e.key, &e.value))
     }
 
     /// Returns the number of key-value pairs in the map.
@@ -481,10 +485,10 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// assert_eq!(None, iter.next());
     /// ```
     pub fn iter(&self) -> Iter<K, V> {
-        let head = if ! self.head.is_null() {
-            unsafe { (*self.head).prev }
-        } else {
+        let head = if self.head.is_null() {
             ptr::null_mut()
+        } else {
+            unsafe { (*self.head).prev }
         };
         Iter {
             head: head,
@@ -515,10 +519,10 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// assert_eq!(&17, map.get(&"a").unwrap());
     /// ```
     pub fn iter_mut(&mut self) -> IterMut<K, V> {
-        let head = if ! self.head.is_null() {
-            unsafe { (*self.head).prev }
-        } else {
+        let head = if self.head.is_null() {
             ptr::null_mut()
+        } else {
+            unsafe { (*self.head).prev }
         };
         IterMut {
             head: head,
@@ -545,6 +549,7 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// assert_eq!(&'b', keys.next().unwrap());
     /// assert_eq!(None, keys.next());
     /// ```
+    #[cfg_attr(feature = "clippy", allow(needless_lifetimes))] // false positive
     pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
         fn first<A, B>((a, _): (A, B)) -> A { a }
         let first: fn((&'a K, &'a V)) -> &'a K = first; // coerce to fn ptr
@@ -569,6 +574,7 @@ impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     /// assert_eq!(&20, values.next().unwrap());
     /// assert_eq!(None, values.next());
     /// ```
+    #[cfg_attr(feature = "clippy", allow(needless_lifetimes))] // false positive
     pub fn values<'a>(&'a self) -> Values<'a, K, V> {
         fn second<A, B>((_, b): (A, B)) -> B { b }
         let second: fn((&'a K, &'a V)) -> &'a V = second; // coerce to fn ptr
@@ -808,8 +814,7 @@ impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
             self.remaining -= 1;
             unsafe {
                 self.tail = (*self.tail).next;
-                let r = Some((&(*self.tail).key, &(*self.tail).value));
-                r
+                Some((&(*self.tail).key, &(*self.tail).value))
             }
         }
     }
@@ -823,8 +828,7 @@ impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
             self.remaining -= 1;
             unsafe {
                 self.tail = (*self.tail).next;
-                let r = Some((&(*self.tail).key, &mut (*self.tail).value));
-                r
+                Some((&(*self.tail).key, &mut (*self.tail).value))
             }
         }
     }
@@ -840,6 +844,7 @@ impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {
 
 /// An insertion-order iterator over a `LinkedHashMap`'s keys.
 pub struct Keys<'a, K: 'a, V: 'a> {
+    #[cfg_attr(feature = "clippy", allow(type_complexity))]
     inner: iter::Map<Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a K>
 }
 
@@ -864,6 +869,7 @@ impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {
 
 /// An insertion-order iterator over a `LinkedHashMap`'s values.
 pub struct Values<'a, K: 'a, V: 'a> {
+    #[cfg_attr(feature = "clippy", allow(type_complexity))]
     inner: iter::Map<Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V>
 }