update rustc edition=2024

Signed-off-by: zhangjinpeng87 <zzzhangjinpeng@gmail.com>

Author: zhangjinpeng87

Cargo.toml

@@ -2,8 +2,8 @@
 name = "raft-engine"
 version = "0.4.2"
 authors = ["The TiKV Project Developers"]
-edition = "2018"
-rust-version = "1.75.0"
+edition = "2024"
+rust-version = "1.85.0"
 description = "A persistent storage engine for Multi-Raft logs"
 readme = "README.md"
 repository = "https://github.com/tikv/raft-engine"

src/file_pipe_log/log_file.rs

@@ -107,13 +107,12 @@ impl<F: FileSystem> LogFileWriter<F> {
             }
             self.capacity += alloc;
         }
-        self.writer.write_all(buf).map_err(|e| {
+        self.writer.write_all(buf).inspect_err(|_| {
             self.writer
                 .seek(SeekFrom::Start(self.written as u64))
                 .unwrap_or_else(|e| {
                     panic!("failed to reseek after write failure: {}", e);
                 });
-            e
         })?;
         self.written = new_written;
         Ok(())

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);
@@ -1631,13 +1631,13 @@ mod tests {
         fn details(log_batch: &mut LogBatch, entries: &[Entry], regions: usize) {
             for _ in 0..regions {
                 log_batch
-                    .add_entries::<Entry>(thread_rng().gen(), entries)
+                    .add_entries::<Entry>(thread_rng().r#gen(), entries)
                     .unwrap();
             }
             log_batch.finish_populate(0, None).unwrap();
             let _ = log_batch.drain();
         }
-        let data: Vec<u8> = (0..128).map(|_| thread_rng().gen()).collect();
+        let data: Vec<u8> = (0..128).map(|_| thread_rng().r#gen()).collect();
         let entries = generate_entries(1, 11, Some(&data));
         let mut log_batch = LogBatch::default();
         // warm up

src/memtable.rs

@@ -228,7 +228,7 @@ impl<A: AllocatorTrait> MemTable<A> {
         }
 
         if let Some(g) = rhs.atomic_group.take() {
-            assert!(self.atomic_group.map_or(true, |(_, end)| end <= g.0));
+            assert!(self.atomic_group.is_none_or(|(_, end)| end <= g.0));
             self.atomic_group = Some(g);
         }
 
@@ -545,7 +545,7 @@ impl<A: AllocatorTrait> MemTable<A> {
     }
 
     pub fn apply_rewrite_atomic_group(&mut self, start: FileSeq, end: FileSeq) {
-        assert!(self.atomic_group.map_or(true, |(_, b)| b <= start));
+        assert!(self.atomic_group.is_none_or(|(_, b)| b <= start));
         self.atomic_group = Some((start, end));
     }
 

src/swappy_allocator.rs

@@ -120,9 +120,8 @@ unsafe impl<A: Allocator + Send + Sync> Allocator for SwappyAllocator<A> {
                 return swap_r;
             }
         }
-        self.0.mem_allocator.allocate(layout).map_err(|e| {
+        self.0.mem_allocator.allocate(layout).inspect_err(|_| {
             self.0.mem_usage.fetch_sub(layout.size(), Ordering::Relaxed);
-            e
         })
     }
 
@@ -145,7 +144,9 @@ 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]
@@ -188,13 +189,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)
-                .map_err(|e| {
-                    self.0.mem_usage.fetch_sub(diff, Ordering::Relaxed);
-                    e
-                })
+            unsafe { self.0.mem_allocator.grow(ptr, old_layout, new_layout) }.inspect_err(|_| {
+                self.0.mem_usage.fetch_sub(diff, Ordering::Relaxed);
+            })
         }
     }
 
@@ -205,8 +202,10 @@ 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)
     }
 
@@ -245,20 +244,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)
-                .map(|p| {
-                    self.0
-                        .mem_usage
-                        .fetch_sub(old_layout.size() - new_layout.size(), Ordering::Relaxed);
-                    p
-                })
+            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);
+            })
         }
     }
 }
@@ -411,7 +406,9 @@ mod tests {
         }
         unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
             self.dealloc.fetch_add(1, Ordering::Relaxed);
-            std::alloc::Global.deallocate(ptr, layout)
+            unsafe {
+                std::alloc::Global.deallocate(ptr, layout);
+            }
         }
         unsafe fn grow(
             &self,
@@ -423,7 +420,7 @@ mod tests {
             if self.err_mode.load(Ordering::Relaxed) {
                 Err(AllocError)
             } else {
-                std::alloc::Global.grow(ptr, old_layout, new_layout)
+                unsafe { std::alloc::Global.grow(ptr, old_layout, new_layout) }
             }
         }
         unsafe fn shrink(
@@ -436,7 +433,7 @@ mod tests {
             if self.err_mode.load(Ordering::Relaxed) {
                 Err(AllocError)
             } else {
-                std::alloc::Global.shrink(ptr, old_layout, new_layout)
+                unsafe { std::alloc::Global.shrink(ptr, old_layout, new_layout) }
             }
         }
     }

src/test_util.rs

@@ -1,6 +1,7 @@
 // Copyright (c) 2017-present, PingCAP, Inc. Licensed under Apache-2.0.
 
 use std::panic::{self, AssertUnwindSafe};
+use std::sync::Arc;
 
 use raft::eraftpb::Entry;
 
@@ -62,34 +63,33 @@ where
     result
 }
 
+type PanicHook = dyn Fn(&panic::PanicHookInfo<'_>) + Sync + Send + 'static;
+
 pub struct PanicGuard {
-    prev_hook: *mut (dyn Fn(&panic::PanicHookInfo<'_>) + Sync + Send + 'static),
+    prev_hook: Option<Arc<PanicHook>>,
 }
 
-struct PointerHolder<T: ?Sized>(*mut T);
-
-unsafe impl<T: Send + ?Sized> Send for PointerHolder<T> {}
-unsafe impl<T: Sync + ?Sized> Sync for PointerHolder<T> {}
-
 impl PanicGuard {
     pub fn with_prompt(s: String) -> Self {
-        let prev_hook = Box::into_raw(panic::take_hook());
-        let sendable_prev_hook = PointerHolder(prev_hook);
+        let prev_hook: Arc<PanicHook> = panic::take_hook().into();
+        let hook = Arc::clone(&prev_hook);
         // FIXME: Use thread local hook.
         panic::set_hook(Box::new(move |info| {
             eprintln!("{s}");
-            unsafe { (*sendable_prev_hook.0)(info) };
+            hook(info);
         }));
-        PanicGuard { prev_hook }
+        PanicGuard {
+            prev_hook: Some(prev_hook),
+        }
     }
 }
 
 impl Drop for PanicGuard {
     fn drop(&mut self) {
         if !std::thread::panicking() {
             let _ = panic::take_hook();
-            unsafe {
-                panic::set_hook(Box::from_raw(self.prev_hook));
+            if let Some(prev_hook) = self.prev_hook.take() {
+                panic::set_hook(Box::new(move |info| prev_hook(info)));
             }
         }
     }