fixed some clippy warnings in libcollections

Author: llogiq

src/libcollections/binary_heap.rs

@@ -941,7 +941,7 @@ impl<'a, T> Hole<'a, T> {
     /// Unsafe because index must be within the data slice and not equal to pos.
     #[inline]
     unsafe fn get(&self, index: usize) -> &T {
-        debug_assert!(index != self.pos);
+        debug_assert_ne!(index, self.pos);
         debug_assert!(index < self.data.len());
         self.data.get_unchecked(index)
     }
@@ -951,7 +951,7 @@ impl<'a, T> Hole<'a, T> {
     /// Unsafe because index must be within the data slice and not equal to pos.
     #[inline]
     unsafe fn move_to(&mut self, index: usize) {
-        debug_assert!(index != self.pos);
+        debug_assert_ne!(index, self.pos);
         debug_assert!(index < self.data.len());
         let index_ptr: *const _ = self.data.get_unchecked(index);
         let hole_ptr = self.data.get_unchecked_mut(self.pos);
@@ -1194,8 +1194,8 @@ impl<T: Ord, I: IntoIterator<Item = T>> SpecExtend<I> for BinaryHeap<T> {
 }
 
 impl<T: Ord> SpecExtend<BinaryHeap<T>> for BinaryHeap<T> {
-    fn spec_extend(&mut self, ref mut other: BinaryHeap<T>) {
-        self.append(other);
+    fn spec_extend(&mut self, mut other: BinaryHeap<T>) {
+        self.append(&mut other);
     }
 }
 

src/libcollections/borrow.rs

@@ -254,7 +254,7 @@ impl<'a, B: ?Sized> fmt::Debug for Cow<'a, B>
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Borrowed(ref b) => fmt::Debug::fmt(b, f),
+            Borrowed(b) => fmt::Debug::fmt(b, f),
             Owned(ref o) => fmt::Debug::fmt(o, f),
         }
     }
@@ -267,7 +267,7 @@ impl<'a, B: ?Sized> fmt::Display for Cow<'a, B>
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Borrowed(ref b) => fmt::Display::fmt(b, f),
+            Borrowed(b) => fmt::Display::fmt(b, f),
             Owned(ref o) => fmt::Display::fmt(o, f),
         }
     }

src/libcollections/btree/map.rs

@@ -141,7 +141,7 @@ pub struct BTreeMap<K, V> {
 unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap<K, V> {
     fn drop(&mut self) {
         unsafe {
-            for _ in ptr::read(self).into_iter() {
+            for _ in ptr::read(self) {
             }
         }
     }
@@ -263,7 +263,7 @@ impl<K, Q: ?Sized> super::Recover<Q> for BTreeMap<K, ()>
     }
 }
 
-/// An iterator over a BTreeMap's entries.
+/// An iterator over a `BTreeMap`'s entries.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Iter<'a, K: 'a, V: 'a> {
     range: Range<'a, K, V>,
@@ -277,15 +277,15 @@ impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Iter<'a, K, V> {
     }
 }
 
-/// A mutable iterator over a BTreeMap's entries.
+/// A mutable iterator over a `BTreeMap`'s entries.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Debug)]
 pub struct IterMut<'a, K: 'a, V: 'a> {
     range: RangeMut<'a, K, V>,
     length: usize,
 }
 
-/// An owning iterator over a BTreeMap's entries.
+/// An owning iterator over a `BTreeMap`'s entries.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct IntoIter<K, V> {
     front: Handle<NodeRef<marker::Owned, K, V, marker::Leaf>, marker::Edge>,
@@ -304,7 +304,7 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
     }
 }
 
-/// An iterator over a BTreeMap's keys.
+/// An iterator over a `BTreeMap`'s keys.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Keys<'a, K: 'a, V: 'a> {
     inner: Iter<'a, K, V>,
@@ -317,7 +317,7 @@ impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Keys<'a, K, V> {
     }
 }
 
-/// An iterator over a BTreeMap's values.
+/// An iterator over a `BTreeMap`'s values.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Values<'a, K: 'a, V: 'a> {
     inner: Iter<'a, K, V>,
@@ -330,14 +330,14 @@ impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Values<'a, K, V>
     }
 }
 
-/// A mutable iterator over a BTreeMap's values.
+/// A mutable iterator over a `BTreeMap`'s values.
 #[stable(feature = "map_values_mut", since = "1.10.0")]
 #[derive(Debug)]
 pub struct ValuesMut<'a, K: 'a, V: 'a> {
     inner: IterMut<'a, K, V>,
 }
 
-/// An iterator over a sub-range of BTreeMap's entries.
+/// An iterator over a sub-range of `BTreeMap`'s entries.
 pub struct Range<'a, K: 'a, V: 'a> {
     front: Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Edge>,
     back: Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Edge>,
@@ -350,7 +350,7 @@ impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Range<'a, K, V>
     }
 }
 
-/// A mutable iterator over a sub-range of BTreeMap's entries.
+/// A mutable iterator over a sub-range of `BTreeMap`'s entries.
 pub struct RangeMut<'a, K: 'a, V: 'a> {
     front: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,
     back: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,
@@ -684,12 +684,12 @@ impl<K: Ord, V> BTreeMap<K, V> {
     #[stable(feature = "btree_append", since = "1.11.0")]
     pub fn append(&mut self, other: &mut Self) {
         // Do we have to append anything at all?
-        if other.len() == 0 {
+        if other.is_empty() {
             return;
         }
 
         // We can just swap `self` and `other` if `self` is empty.
-        if self.len() == 0 {
+        if self.is_empty() {
             mem::swap(self, other);
             return;
         }
@@ -1901,7 +1901,7 @@ impl<K, V> BTreeMap<K, V> {
     /// assert_eq!(keys, [1, 2]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
+    pub fn keys(&self) -> Keys<K, V> {
         Keys { inner: self.iter() }
     }
 
@@ -1922,7 +1922,7 @@ impl<K, V> BTreeMap<K, V> {
     /// assert_eq!(values, ["hello", "goodbye"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn values<'a>(&'a self) -> Values<'a, K, V> {
+    pub fn values(&self) -> Values<K, V> {
         Values { inner: self.iter() }
     }
 
@@ -2361,8 +2361,8 @@ enum UnderflowResult<'a, K, V> {
     Stole(NodeRef<marker::Mut<'a>, K, V, marker::Internal>),
 }
 
-fn handle_underfull_node<'a, K, V>(node: NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>)
-                                   -> UnderflowResult<'a, K, V> {
+fn handle_underfull_node<K, V>(node: NodeRef<marker::Mut, K, V, marker::LeafOrInternal>)
+                               -> UnderflowResult<K, V> {
     let parent = if let Ok(parent) = node.ascend() {
         parent
     } else {

src/libcollections/btree/node.rs

@@ -347,7 +347,7 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
     }
 
     /// Temporarily takes out another, immutable reference to the same node.
-    fn reborrow<'a>(&'a self) -> NodeRef<marker::Immut<'a>, K, V, Type> {
+    fn reborrow(&self) -> NodeRef<marker::Immut, K, V, Type> {
         NodeRef {
             height: self.height,
             node: self.node,
@@ -964,7 +964,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
     fn insert_fit(&mut self, key: K, val: V, edge: Root<K, V>) {
         // Necessary for correctness, but in an internal module
         debug_assert!(self.node.len() < CAPACITY);
-        debug_assert!(edge.height == self.node.height - 1);
+        debug_assert_eq!(edge.height, self.node.height - 1);
 
         unsafe {
             // This cast is a lie, but it allows us to reuse the key/value insertion logic.
@@ -992,7 +992,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
             -> InsertResult<'a, K, V, marker::Internal> {
 
         // Necessary for correctness, but this is an internal module
-        debug_assert!(edge.height == self.node.height - 1);
+        debug_assert_eq!(edge.height, self.node.height - 1);
 
         if self.node.len() < CAPACITY {
             self.insert_fit(key, val, edge);
@@ -1488,8 +1488,8 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, ma
             let right_new_len = left_node.len() - left_new_len;
             let mut right_node = right.reborrow_mut();
 
-            debug_assert!(right_node.len() == 0);
-            debug_assert!(left_node.height == right_node.height);
+            debug_assert_eq!(right_node.len(), 0);
+            debug_assert_eq!(left_node.height, right_node.height);
 
             let left_kv = left_node.reborrow_mut().into_kv_pointers_mut();
             let right_kv = right_node.reborrow_mut().into_kv_pointers_mut();

src/libcollections/btree/set.rs

@@ -1056,7 +1056,7 @@ impl<'a, T: Ord> Iterator for Intersection<'a, T> {
     fn next(&mut self) -> Option<&'a T> {
         loop {
             let o_cmp = match (self.a.peek(), self.b.peek()) {
-                (None, _) => None,
+                (None, _) |
                 (_, None) => None,
                 (Some(a1), Some(b1)) => Some(a1.cmp(b1)),
             };

src/libcollections/enum_set.rs

@@ -215,7 +215,7 @@ impl<E: CLike> BitXor for EnumSet<E> {
     }
 }
 
-/// An iterator over an EnumSet
+/// An iterator over an `EnumSet`
 pub struct Iter<E> {
     index: usize,
     bits: usize,

src/libcollections/lib.rs

@@ -10,7 +10,7 @@
 
 //! Collection types.
 //!
-//! See [std::collections](../std/collections/index.html) for a detailed discussion of
+//! See [`std::collections`](../std/collections/index.html) for a detailed discussion of
 //! collections in Rust.
 
 #![crate_name = "collections"]

src/libcollections/linked_list.rs

@@ -95,7 +95,7 @@ pub struct IterMut<'a, T: 'a> {
 impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_tuple("IterMut")
-         .field(self.clone())
+         .field(self)
          .finish()
     }
 }
@@ -111,7 +111,7 @@ pub struct IntoIter<T> {
 impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_tuple("IntoIter")
-         .field(self.clone())
+         .field(self)
          .finish()
     }
 }
@@ -1020,8 +1020,8 @@ impl<I: IntoIterator> SpecExtend<I> for LinkedList<I::Item> {
 }
 
 impl<T> SpecExtend<LinkedList<T>> for LinkedList<T> {
-    fn spec_extend(&mut self, ref mut other: LinkedList<T>) {
-        self.append(other);
+    fn spec_extend(&mut self, mut other: LinkedList<T>) {
+        self.append(&mut other);
     }
 }
 
@@ -1110,7 +1110,7 @@ pub struct FrontPlace<'a, T: 'a> {
 impl<'a, T: 'a + fmt::Debug> fmt::Debug for FrontPlace<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_tuple("FrontPlace")
-         .field(self.clone())
+         .field(self)
          .finish()
     }
 }
@@ -1165,7 +1165,7 @@ pub struct BackPlace<'a, T: 'a> {
 impl<'a, T: 'a + fmt::Debug> fmt::Debug for BackPlace<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_tuple("BackPlace")
-         .field(self.clone())
+         .field(self)
          .finish()
     }
 }

src/libcollections/range.rs

@@ -17,7 +17,7 @@
 use core::ops::{RangeFull, Range, RangeTo, RangeFrom, RangeInclusive, RangeToInclusive};
 use Bound::{self, Excluded, Included, Unbounded};
 
-/// **RangeArgument** is implemented by Rust's built-in range types, produced
+/// **`RangeArgument`** is implemented by Rust's built-in range types, produced
 /// by range syntax like `..`, `a..`, `..b` or `c..d`.
 pub trait RangeArgument<T: ?Sized> {
     /// Start index bound

src/libcollections/slice.rs

@@ -1538,7 +1538,7 @@ unsafe fn merge<T, F>(v: &mut [T], mid: usize, buf: *mut T, is_less: &mut F)
     }
 }
 
-/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail
+/// This merge sort borrows some (but not all) ideas from `TimSort`, which is described in detail
 /// [here](http://svn.python.org/projects/python/trunk/Objects/listsort.txt).
 ///
 /// The algorithm identifies strictly descending and non-descending subsequences, which are called