Apply clippy --fix

spacejam · spacejam · commit 73792aa5c27f · 2022-10-01T21:00:50.000+02:00
diff --git a/src/cache_padded.rs b/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,
 }
diff --git a/src/db.rs b/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);
diff --git a/src/ebr/list.rs b/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.
diff --git a/src/ivec.rs b/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 {
diff --git a/src/node.rs b/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();
 
diff --git a/src/pagecache/disk_pointer.rs b/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),
diff --git a/src/pagecache/logger.rs b/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);
 
diff --git a/src/pagecache/mod.rs b/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)?
                 }
diff --git a/src/pagecache/snapshot.rs b/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");
diff --git a/src/transaction.rs b/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
     }
 

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ use core::ops::{Deref, DerefMut};`
`21`	`21`	`not(any(target_arch = "x86_64", target_arch = "aarch64")),`
`22`	`22`	`repr(align(64))`
`23`	`23`	`)]`
`24`		`-#[derive(Default, PartialEq)]`
	`24`	`+#[derive(Default, PartialEq, Eq)]`
`25`	`25`	`pub struct CachePadded<T> {`
`26`	`26`	`value: T,`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ pub struct Iter<'g, T, C: IsElement<T>> {`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`/// An error that occurs during iteration over the list.`
`86`		`-#[derive(Debug, Clone, Copy, PartialEq)]`
	`86`	`+#[derive(Debug, Clone, Copy, PartialEq, Eq)]`
`87`	`87`	`pub enum IterError {`
`88`	`88`	`/// A concurrent thread modified the state of the list at the same place that this iterator`
`89`	`89`	`/// was inspecting. Subsequent iteration will restart from the beginning of the list.`
Original file line number	Diff line number	Diff line change
`@@ -534,7 +534,7 @@ impl Drop for Log {`
`534`	`534`	`}`
`535`	`535`
`536`	`536`	`/// All log messages are prepended with this header`
`537`		`-#[derive(Debug, Copy, Clone, PartialEq)]`
	`537`	`+#[derive(Debug, Copy, Clone, PartialEq, Eq)]`
`538`	`538`	`pub struct MessageHeader {`
`539`	`539`	`pub crc32: u32,`
`540`	`540`	`pub kind: MessageKind,`
`@@ -544,7 +544,7 @@ pub struct MessageHeader {`
`544`	`544`	`}`
`545`	`545`
`546`	`546`	`/// A number representing a segment number.`
`547`		`-#[derive(Copy, Clone, PartialEq, Debug)]`
	`547`	`+#[derive(Copy, Clone, PartialEq, Eq, Debug)]`
`548`	`548`	`#[repr(transparent)]`
`549`	`549`	`pub struct SegmentNumber(pub u64);`
`550`	`550`
Original file line number	Diff line number	Diff line change
`@@ -290,7 +290,7 @@ impl<'g> Deref for PageView<'g> {`
`290`	`290`	`}`
`291`	`291`	`}`
`292`	`292`
`293`		`-#[derive(Clone, Copy, Debug, PartialEq)]`
	`293`	`+#[derive(Clone, Copy, Debug, PartialEq, Eq)]`
`294`	`294`	`pub struct CacheInfo {`
`295`	`295`	`pub ts: u64,`
`296`	`296`	`pub lsn: Lsn,`
`@@ -1523,7 +1523,7 @@ impl PageCacheInner {`
`1523`	`1523`
`1524`	`1524`	`loop {`
`1525`	`1525`	`let mut page_ptr = new_page.take().unwrap();`
`1526`		`- let log_reservation = match &*page_ptr.update.as_ref().unwrap() {`
	`1526`	`+ let log_reservation = match page_ptr.update.as_ref().unwrap() {`
`1527`	`1527`	`Update::Counter(ref c) => {`
`1528`	`1528`	`self.log.reserve(log_kind, pid, c, guard)?`
`1529`	`1529`	`}`