Merge pull request #1422 from spacejam/tyler_clippy

Apply clippy --fix

Author: spacejam

src/cache_padded.rs

@@ -21,7 +21,7 @@ use core::ops::{Deref, DerefMut};
     not(any(target_arch = "x86_64", target_arch = "aarch64")),
     repr(align(64))
 )]
-#[derive(Default, PartialEq)]
+#[derive(Default, PartialEq, Eq)]
 pub struct CachePadded<T> {
     value: T,
 }

src/db.rs

@@ -143,7 +143,7 @@ impl Db {
 
         let mut tenants = self.tenants.write();
 
-        let tree = if let Some(tree) = tenants.remove(&*name_ref) {
+        let tree = if let Some(tree) = tenants.remove(name_ref) {
             tree
         } else {
             return Ok(false);

src/ebr/list.rs

@@ -83,7 +83,7 @@ pub struct Iter<'g, T, C: IsElement<T>> {
 }
 
 /// An error that occurs during iteration over the list.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum IterError {
     /// A concurrent thread modified the state of the list at the same place that this iterator
     /// was inspecting. Subsequent iteration will restart from the beginning of the list.

src/ivec.rs

@@ -327,9 +327,9 @@ mod qc {
     fn ivec_as_mut_identity() {
         let initial = &[1];
         let mut iv = IVec::from(initial);
-        assert_eq!(&*initial, &*iv);
-        assert_eq!(&*initial, &mut *iv);
-        assert_eq!(&*initial, iv.as_mut());
+        assert_eq!(initial, &*iv);
+        assert_eq!(initial, &mut *iv);
+        assert_eq!(initial, iv.as_mut());
     }
 
     fn prop_identity(ivec: &IVec) -> bool {

src/node.rs

@@ -413,7 +413,7 @@ impl<'a> Iterator for Iter<'a> {
                     log::trace!("src/node.rs:114");
                     log::trace!("iterator returning {:?}", self.next_a);
                     return self.next_a.take().map(|(k, v)| {
-                        (KeyRef::Slice(&*k), v.unwrap().as_ref())
+                        (KeyRef::Slice(k), v.unwrap().as_ref())
                     });
                 }
                 (Some((k_a, v_a_opt)), Some((k_b, _))) => {
@@ -425,7 +425,7 @@ impl<'a> Iterator for Iter<'a> {
                             log::trace!("src/node.rs:133");
                             log::trace!("iterator returning {:?}", self.next_a);
                             return self.next_a.take().map(|(k, v)| {
-                                (KeyRef::Slice(&*k), v.unwrap().as_ref())
+                                (KeyRef::Slice(k), v.unwrap().as_ref())
                             });
                         }
                         (Equal, None) => {
@@ -437,7 +437,7 @@ impl<'a> Iterator for Iter<'a> {
                         (Less, Some(_)) => {
                             log::trace!("iterator returning {:?}", self.next_a);
                             return self.next_a.take().map(|(k, v)| {
-                                (KeyRef::Slice(&*k), v.unwrap().as_ref())
+                                (KeyRef::Slice(k), v.unwrap().as_ref())
                             });
                         }
                         (Less, None) => {
@@ -512,7 +512,7 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
                     log::trace!("src/node.rs:483");
                     log::trace!("iterator returning {:?}", self.next_back_a);
                     return self.next_back_a.take().map(|(k, v)| {
-                        (KeyRef::Slice(&*k), v.unwrap().as_ref())
+                        (KeyRef::Slice(k), v.unwrap().as_ref())
                     });
                 }
                 (Some((k_a, Some(_))), Some((k_b, _))) if k_b > *k_a => {
@@ -523,7 +523,7 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
                 (Some((k_a, Some(_))), Some((k_b, _))) if k_b < *k_a => {
                     log::trace!("iterator returning {:?}", self.next_back_a);
                     return self.next_back_a.take().map(|(k, v)| {
-                        (KeyRef::Slice(&*k), v.unwrap().as_ref())
+                        (KeyRef::Slice(k), v.unwrap().as_ref())
                     });
                 }
                 (Some((k_a, Some(_))), Some((k_b, _))) if k_b == *k_a => {
@@ -532,7 +532,7 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
                     log::trace!("src/node.rs:520");
                     log::trace!("iterator returning {:?}", self.next_back_a);
                     return self.next_back_a.take().map(|(k, v)| {
-                        (KeyRef::Slice(&*k), v.unwrap().as_ref())
+                        (KeyRef::Slice(k), v.unwrap().as_ref())
                     });
                 }
                 _ => unreachable!(
@@ -713,10 +713,10 @@ impl Node {
                 for (k, v) in &self.overlay {
                     length_and_stride_matches &=
                         v.is_some() && v.as_ref().unwrap().is_empty();
-                    length_and_stride_matches &= KeyRef::Slice(&*k) > prev
-                        && is_linear(&prev, &KeyRef::Slice(&*k), stride);
+                    length_and_stride_matches &= KeyRef::Slice(k) > prev
+                        && is_linear(&prev, &KeyRef::Slice(k), stride);
 
-                    prev = KeyRef::Slice(&*k);
+                    prev = KeyRef::Slice(k);
 
                     if !length_and_stride_matches {
                         break;
@@ -2398,8 +2398,8 @@ impl Inner {
     pub(crate) fn contains_upper_bound(&self, bound: &Bound<IVec>) -> bool {
         if let Some(hi) = self.hi() {
             match bound {
-                Bound::Excluded(b) if hi >= &*b => true,
-                Bound::Included(b) if hi > &*b => true,
+                Bound::Excluded(b) if hi >= b => true,
+                Bound::Included(b) if hi > b => true,
                 _ => false,
             }
         } else {
@@ -2414,8 +2414,8 @@ impl Inner {
     ) -> bool {
         let lo = self.lo();
         match bound {
-            Bound::Excluded(b) if lo < &*b || (is_forward && *b == lo) => true,
-            Bound::Included(b) if lo <= &*b => true,
+            Bound::Excluded(b) if lo < b || (is_forward && *b == lo) => true,
+            Bound::Included(b) if lo <= b => true,
             Bound::Unbounded if !is_forward => self.hi().is_none(),
             _ => lo.is_empty(),
         }
@@ -2630,7 +2630,7 @@ mod test {
 
         let key_ref = KeyRef::Computed { base: &[2, 253], distance: 8 };
         let mut buf = &mut [0, 0][..];
-        key_ref.write_into(&mut buf);
+        key_ref.write_into(buf);
         assert_eq!(buf, &[3, 5]);
     }
 
@@ -2730,7 +2730,7 @@ mod test {
                 .collect();
 
             let mut ret =
-                Inner::new(&lo, hi.map(|h| &*h), 0, false, None, &children_ref);
+                Inner::new(&lo, hi.map(|h| h), 0, false, None, &children_ref);
 
             ret.activity_sketch = g.gen();
 

src/pagecache/disk_pointer.rs

@@ -4,7 +4,7 @@ use super::{HeapId, LogOffset};
 use crate::*;
 
 /// A pointer to a location on disk or an off-log heap item.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DiskPtr {
     /// Points to a value stored in the single-file log.
     Inline(LogOffset),

src/pagecache/logger.rs

@@ -534,7 +534,7 @@ impl Drop for Log {
 }
 
 /// All log messages are prepended with this header
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct MessageHeader {
     pub crc32: u32,
     pub kind: MessageKind,
@@ -544,7 +544,7 @@ pub struct MessageHeader {
 }
 
 /// A number representing a segment number.
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 #[repr(transparent)]
 pub struct SegmentNumber(pub u64);
 

src/pagecache/mod.rs

@@ -290,7 +290,7 @@ impl<'g> Deref for PageView<'g> {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct CacheInfo {
     pub ts: u64,
     pub lsn: Lsn,
@@ -1523,7 +1523,7 @@ impl PageCacheInner {
 
         loop {
             let mut page_ptr = new_page.take().unwrap();
-            let log_reservation = match &*page_ptr.update.as_ref().unwrap() {
+            let log_reservation = match page_ptr.update.as_ref().unwrap() {
                 Update::Counter(ref c) => {
                     self.log.reserve(log_kind, pid, c, guard)?
                 }

src/pagecache/snapshot.rs

@@ -23,7 +23,7 @@ pub struct Snapshot {
     pub pt: Vec<PageState>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PageState {
     /// Present signifies a page that has some data.
     ///
@@ -611,7 +611,7 @@ pub(in crate::pagecache) fn write_snapshot(
     let candidates = config.get_snapshot_files()?;
     for path in candidates {
         let path_str = path.file_name().unwrap().to_str().unwrap();
-        if !path_2.to_string_lossy().ends_with(&*path_str) {
+        if !path_2.to_string_lossy().ends_with(path_str) {
             debug!("removing old snapshot file {:?}", path);
 
             io_fail!(config, "snap write rm old");

src/transaction.rs

@@ -99,7 +99,7 @@ pub struct TransactionalTree {
 
 /// An error type that is returned from the closure
 /// passed to the `transaction` method.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum UnabortableTransactionError {
     /// An internal conflict has occurred and the `transaction` method will
     /// retry the passed-in closure until it succeeds. This should never be
@@ -155,7 +155,7 @@ impl<E> From<UnabortableTransactionError> for ConflictableTransactionError<E> {
 
 /// An error type that is returned from the closure
 /// passed to the `transaction` method.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ConflictableTransactionError<T = Error> {
     /// A user-provided error type that indicates the transaction should abort.
     /// This is passed into the return value of `transaction` as a direct Err
@@ -198,7 +198,7 @@ impl<E: std::error::Error> std::error::Error
 
 /// An error type that is returned from the closure
 /// passed to the `transaction` method.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TransactionError<T = Error> {
     /// A user-provided error type that indicates the transaction should abort.
     /// This is passed into the return value of `transaction` as a direct Err
@@ -266,7 +266,7 @@ impl TransactionalTree {
     {
         let old = self.get(key.as_ref())?;
         let mut writes = self.writes.borrow_mut();
-        let _last_write = writes.insert(key, value.into());
+        writes.insert(key, value.into());
         Ok(old)
     }
 
@@ -280,7 +280,7 @@ impl TransactionalTree {
     {
         let old = self.get(key.as_ref());
         let mut writes = self.writes.borrow_mut();
-        let _last_write = writes.remove(key);
+        writes.remove(key);
         old
     }