Clippy feedback

Author: spacejam

src/node.rs

@@ -1437,7 +1437,7 @@ impl Inner {
         };
 
         let total_node_storage_size = size_of::<Header>()
-            + hi.map(|hi| hi.len()).unwrap_or(0)
+            + hi.map(|h| h.len()).unwrap_or(0)
             + lo.len()
             + key_storage_size
             + value_storage_size
@@ -1454,7 +1454,7 @@ impl Inner {
         header.fixed_key_length = fixed_key_length;
         header.fixed_value_length = fixed_value_length;
         header.lo_len = lo.len() as u64;
-        header.hi_len = hi.map(|hi| hi.len() as u64).unwrap_or(0);
+        header.hi_len = hi.map(|h| h.len() as u64).unwrap_or(0);
         header.fixed_key_stride = fixed_key_stride;
         header.offset_bytes = offset_bytes;
         header.children = tf!(items.len(), u32);
@@ -1958,7 +1958,7 @@ impl Inner {
             .map(|(k, v)| (IVec::from(k), v))
             .collect();
 
-        let left_items: Vec<_> = left_items
+        let left_items2: Vec<_> = left_items
             .iter()
             .map(|(k, v)| (KeyRef::Slice(&k[additional_left_prefix..]), *v))
             .collect();
@@ -1987,7 +1987,7 @@ impl Inner {
             self.prefix_len + tf!(additional_left_prefix, u8),
             self.is_index,
             self.next,
-            &left_items,
+            &left_items2,
         );
 
         left.rewrite_generations =
@@ -2055,7 +2055,7 @@ impl Inner {
             && other.fixed_value_length() == Some(0)
             && self.fixed_key_length == other.fixed_key_length
             && self.lo().len() == other.lo().len()
-            && self.hi().map(|h| h.len()) == other.hi().map(|h| h.len());
+            && self.hi().map(<[_]>::len) == other.hi().map(<[_]>::len);
 
         if can_seamlessly_absorb {
             let mut ret = self.clone();
@@ -2390,8 +2390,8 @@ impl Inner {
     pub(crate) fn contains_upper_bound(&self, bound: &Bound<IVec>) -> bool {
         if let Some(hi) = self.hi() {
             match bound {
-                Bound::Excluded(bound) if hi >= &*bound => true,
-                Bound::Included(bound) if hi > &*bound => true,
+                Bound::Excluded(b) if hi >= &*b => true,
+                Bound::Included(b) if hi > &*b => true,
                 _ => false,
             }
         } else {
@@ -2406,12 +2406,8 @@ impl Inner {
     ) -> bool {
         let lo = self.lo();
         match bound {
-            Bound::Excluded(bound)
-                if lo < &*bound || (is_forward && *bound == lo) =>
-            {
-                true
-            }
-            Bound::Included(bound) if lo <= &*bound => 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(),
         }

src/oneshot.rs

@@ -78,12 +78,7 @@ impl<T> OneShot<T> {
             if res.timed_out() {
                 return Err(std::sync::mpsc::RecvTimeoutError::Disconnected);
             }
-            timeout =
-                if let Some(timeout) = timeout.checked_sub(start.elapsed()) {
-                    timeout
-                } else {
-                    Duration::from_nanos(0)
-                };
+            timeout = timeout.checked_sub(start.elapsed()).unwrap_or_default();
         }
         if let Some(item) = inner.item.take() {
             Ok(item)

src/pagecache/disk_pointer.rs

@@ -53,7 +53,7 @@ impl DiskPtr {
         }
     }
 
-    pub(crate) fn original_lsn(&self) -> Lsn {
+    pub(crate) const fn original_lsn(&self) -> Lsn {
         match self {
             DiskPtr::Heap(_, heap_id) => heap_id.original_lsn,
             DiskPtr::Inline(_) => panic!("called original_lsn on non-Heap"),

src/pagecache/heap.rs

@@ -185,14 +185,14 @@ pub(crate) struct Heap {
 
 impl Heap {
     pub fn start<P: AsRef<Path>>(p: P) -> Result<Heap> {
-        let mut slabs = vec![];
+        let mut slabs_vec = vec![];
 
         for slab_id in 0..32 {
             let slab = Slab::start(&p, slab_id)?;
-            slabs.push(slab);
+            slabs_vec.push(slab);
         }
 
-        let slabs: [Slab; 32] = slabs.try_into().unwrap();
+        let slabs: [Slab; 32] = slabs_vec.try_into().unwrap();
 
         Ok(Heap { slabs })
     }
@@ -332,12 +332,12 @@ impl Slab {
                 return Err(Error::corruption(None));
             }
             let buf = heap_buf[13..].to_vec();
-            let buf = if use_compression {
+            let buf2 = if use_compression {
                 crate::pagecache::decompress(buf)
             } else {
                 buf
             };
-            Ok((MessageKind::from(heap_buf[0]), buf))
+            Ok((MessageKind::from(heap_buf[0]), buf2))
         } else {
             log::debug!(
                 "heap message CRC does not match contents. stored: {} actual: {}",

src/pagecache/iobuf.rs

@@ -561,7 +561,7 @@ impl IoBufs {
         item: &T,
         header: MessageHeader,
         mut out_buf: &mut [u8],
-        heap_reservation: Option<super::heap::Reservation>,
+        heap_reservation_opt: Option<super::heap::Reservation>,
     ) -> Result<()> {
         // we create this double ref to allow scooting
         // the slice forward without doing anything
@@ -573,7 +573,7 @@ impl IoBufs {
             header.serialize_into(out_buf_ref);
         }
 
-        if let Some(heap_reservation) = heap_reservation {
+        if let Some(heap_reservation) = heap_reservation_opt {
             // write blob to file
             io_fail!(self, "blob blob write");
             let mut heap_buf = vec![
@@ -676,17 +676,17 @@ impl IoBufs {
                     / u64::try_from(self.config.segment_size).unwrap(),
             );
 
-            let header = MessageHeader {
+            let cap_header = MessageHeader {
                 kind: MessageKind::Cap,
                 pid: PageId::max_value(),
                 segment_number,
                 len: u64::try_from(pad_len).unwrap(),
                 crc32: 0,
             };
 
-            trace!("writing segment cap {:?}", header);
+            trace!("writing segment cap {:?}", cap_header);
 
-            let header_bytes = header.serialize();
+            let header_bytes = cap_header.serialize();
 
             // initialize the remainder of this buffer (only pad_len of this
             // will be part of the Cap message)
@@ -1282,9 +1282,9 @@ pub(in crate::pagecache) fn maybe_seal_and_write_iobuf(
             "asynchronously writing iobuf with lsn {} to log from maybe_seal",
             lsn
         );
-        let iobufs = iobufs.clone();
-        let iobuf = iobuf.clone();
-        let _result = threadpool::write_to_log(iobuf, iobufs);
+        let iobufs2 = iobufs.clone();
+        let iobuf2 = iobuf.clone();
+        let _result = threadpool::write_to_log(iobuf2, iobufs2);
 
         #[cfg(feature = "event_log")]
         _result.wait();

src/pagecache/iterator.rs

@@ -339,8 +339,8 @@ fn scan_segment_headers_and_tail(
             // let config = config.clone();
             move |idx| {
                 threadpool::spawn({
-                    let config = config.clone();
-                    move || fetch(idx, min, &config)
+                    let config2 = config.clone();
+                    move || fetch(idx, min, &config2)
                 })
             }
         })
@@ -497,8 +497,6 @@ pub fn raw_segment_iter_from(
         normalized_lsn,
     );
 
-    let ordering = ordering;
-
     let segments = ordering
         .into_iter()
         .filter(move |&(l, _)| l >= normalized_lsn)

src/pagecache/logger.rs

@@ -422,7 +422,7 @@ impl Log {
                 reservation_lsn + inline_buf_len as Lsn - 1,
             );
 
-            let (heap_reservation, heap_id) = if over_heap_threshold {
+            let (heap_reservation, heap_id_opt) = if over_heap_threshold {
                 let heap_reservation = self
                     .config
                     .heap
@@ -443,7 +443,7 @@ impl Log {
             #[cfg(feature = "metrics")]
             M.log_reservation_success();
 
-            let pointer = if let Some(heap_id) = heap_id {
+            let pointer = if let Some(heap_id) = heap_id_opt {
                 DiskPtr::new_heap_item(reservation_lid, heap_id)
             } else if let Some(heap_id) = heap_rewrite {
                 DiskPtr::new_heap_item(reservation_lid, heap_id)
@@ -504,9 +504,9 @@ impl Log {
                  to log from exit_reservation",
                 lsn
             );
-            let iobufs = self.iobufs.clone();
-            let iobuf = iobuf.clone();
-            threadpool::write_to_log(iobuf, iobufs);
+            let iobufs2 = self.iobufs.clone();
+            let iobuf2 = iobuf.clone();
+            threadpool::write_to_log(iobuf2, iobufs2);
 
             Ok(())
         } else {
@@ -862,15 +862,15 @@ pub(crate) fn read_message<R: ReadAt>(
             let heap_id = HeapId::deserialize(&mut &buf[..]).unwrap();
 
             match config.heap.read(heap_id, config.use_compression) {
-                Ok((kind, buf)) => {
+                Ok((kind, buf2)) => {
                     assert_eq!(header.kind, kind);
                     trace!(
                         "read a successful heap message for heap {:?} in segment number {:?}",
                         heap_id,
                         header.segment_number,
                     );
 
-                    Ok(LogRead::Heap(header, buf, heap_id, inline_len))
+                    Ok(LogRead::Heap(header, buf2, heap_id, inline_len))
                 }
                 Err(e) => {
                     debug!("failed to read heap: {:?}", e);
@@ -884,10 +884,10 @@ pub(crate) fn read_message<R: ReadAt>(
         | MessageKind::Free
         | MessageKind::Counter => {
             trace!("read a successful inline message");
-            let buf =
+            let buf2 =
                 if config.use_compression { decompress(buf) } else { buf };
 
-            Ok(LogRead::Inline(header, buf, inline_len))
+            Ok(LogRead::Inline(header, buf2, inline_len))
         }
         MessageKind::BatchManifest => {
             assert_eq!(buf.len(), std::mem::size_of::<Lsn>());