fix clippy

Signed-off-by: Yang Zhang <yang.zhang@pingcap.com>

Author: v01dstar

src/file_pipe_log/pipe_builder.rs

@@ -240,9 +240,9 @@ impl<F: FileSystem> DualPipesBuilder<F> {
             self.scan_dir(&dir, lock)?;
         }
 
-        self.append_file_names.sort_by(|a, b| a.seq.cmp(&b.seq));
-        self.rewrite_file_names.sort_by(|a, b| a.seq.cmp(&b.seq));
-        self.recycled_file_names.sort_by(|a, b| a.seq.cmp(&b.seq));
+        self.append_file_names.sort_by_key(|a| a.seq);
+        self.rewrite_file_names.sort_by_key(|a| a.seq);
+        self.recycled_file_names.sort_by_key(|a| a.seq);
         Ok(())
     }
 

src/lib.rs

@@ -16,10 +16,6 @@
 #![cfg_attr(feature = "nightly", feature(test))]
 #![cfg_attr(feature = "swap", feature(allocator_api))]
 #![cfg_attr(feature = "swap", feature(slice_ptr_get))]
-// Though the new nightly rust stablized this feature, keep it anyway
-// because some other project (like TiKV) is still using the old.
-#![cfg_attr(feature = "swap", feature(nonnull_slice_from_raw_parts))]
-#![cfg_attr(feature = "swap", feature(slice_ptr_len))]
 #![cfg_attr(feature = "swap", feature(alloc_layout_extra))]
 #![cfg_attr(all(test, feature = "swap"), feature(alloc_error_hook))]
 #![cfg_attr(all(test, feature = "swap"), feature(cfg_sanitize))]

src/log_batch.rs

@@ -372,11 +372,11 @@ impl LogItemBatch {
         self.items
     }
 
-    pub fn iter(&self) -> std::slice::Iter<LogItem> {
+    pub fn iter(&self) -> std::slice::Iter<'_, LogItem> {
         self.items.iter()
     }
 
-    pub fn drain(&mut self) -> LogItemDrain {
+    pub fn drain(&mut self) -> LogItemDrain<'_> {
         self.item_size = 0;
         self.entries_size = 0;
         self.checksum = 0;
@@ -882,7 +882,7 @@ impl LogBatch {
     }
 
     /// Consumes log items into an iterator.
-    pub(crate) fn drain(&mut self) -> LogItemDrain {
+    pub(crate) fn drain(&mut self) -> LogItemDrain<'_> {
         debug_assert!(!matches!(self.buf_state, BufState::Incomplete));
 
         self.buf.shrink_to(MAX_LOG_BATCH_BUFFER_CAP);

src/swappy_allocator.rs

@@ -144,7 +144,7 @@ unsafe impl<A: Allocator + Send + Sync> Allocator for SwappyAllocator<A> {
             }
         }
         self.0.mem_usage.fetch_sub(layout.size(), Ordering::Relaxed);
-        self.0.mem_allocator.deallocate(ptr, layout)
+        unsafe { self.0.mem_allocator.deallocate(ptr, layout) }
     }
 
     #[inline]
@@ -187,12 +187,9 @@ unsafe impl<A: Allocator + Send + Sync> Allocator for SwappyAllocator<A> {
 
             Ok(new_ptr)
         } else {
-            self.0
-                .mem_allocator
-                .grow(ptr, old_layout, new_layout)
-                .inspect_err(|_| {
-                    self.0.mem_usage.fetch_sub(diff, Ordering::Relaxed);
-                })
+            unsafe { self.0.mem_allocator.grow(ptr, old_layout, new_layout) }.inspect_err(|_| {
+                self.0.mem_usage.fetch_sub(diff, Ordering::Relaxed);
+            })
         }
     }
 
@@ -203,8 +200,8 @@ unsafe impl<A: Allocator + Send + Sync> Allocator for SwappyAllocator<A> {
         old_layout: Layout,
         new_layout: Layout,
     ) -> Result<NonNull<[u8]>, AllocError> {
-        let ptr = self.grow(ptr, old_layout, new_layout)?;
-        ptr.as_non_null_ptr().as_ptr().write_bytes(0, ptr.len());
+        let ptr = unsafe { self.grow(ptr, old_layout, new_layout)? };
+        unsafe { ptr.as_non_null_ptr().as_ptr().write_bytes(0, ptr.len()) };
         Ok(ptr)
     }
 
@@ -243,19 +240,16 @@ unsafe impl<A: Allocator + Send + Sync> Allocator for SwappyAllocator<A> {
             } else {
                 // The new layout should still be mapped to disk. Reuse old pointer.
                 Ok(NonNull::slice_from_raw_parts(
-                    NonNull::new_unchecked(ptr.as_ptr()),
+                    unsafe { NonNull::new_unchecked(ptr.as_ptr()) },
                     new_layout.size(),
                 ))
             }
         } else {
-            self.0
-                .mem_allocator
-                .shrink(ptr, old_layout, new_layout)
-                .inspect(|_| {
-                    self.0
-                        .mem_usage
-                        .fetch_sub(old_layout.size() - new_layout.size(), Ordering::Relaxed);
-                })
+            unsafe { self.0.mem_allocator.shrink(ptr, old_layout, new_layout) }.inspect(|_| {
+                self.0
+                    .mem_usage
+                    .fetch_sub(old_layout.size() - new_layout.size(), Ordering::Relaxed);
+            })
         }
     }
 }