examples, tests: miscellaneous clippy fixes

Signed-off-by: Paolo Bonzini <[email protected]>

Author: bonzini

Cargo.toml

@@ -35,3 +35,7 @@ unused_attributes = "deny"
 
 [lints.rustdoc]
 unescaped_backticks = "deny"
+
+[lints.clippy]
+# allow this until the modules in examples/ and tests/ are cleaned up
+duplicate_mod = "allow"

examples/error.rs

@@ -21,4 +21,5 @@ impl From<AllocError> for Error {
     }
 }
 
+#[allow(dead_code)]
 fn main() {}

examples/mutex.rs

@@ -40,6 +40,7 @@ impl SpinLock {
     }
 
     #[inline]
+    #[allow(clippy::new_without_default)]
     pub const fn new() -> Self {
         Self {
             inner: AtomicBool::new(false),
@@ -90,6 +91,8 @@ impl<T> CMutex<T> {
                 park();
                 sguard = self.spin_lock.acquire();
             }
+            // This does have an effect, as the ListHead inside wait_entry implements Drop!
+            #[expect(clippy::drop_non_drop)]
             drop(wait_entry);
         }
         self.locked.set(true);
@@ -101,6 +104,7 @@ impl<T> CMutex<T> {
         }
     }
 
+    #[allow(dead_code)]
     pub fn get_data_mut(self: Pin<&mut Self>) -> &mut T {
         // SAFETY: we have an exclusive reference and thus nobody has access to data.
         unsafe { &mut *self.data.get() }
@@ -115,7 +119,7 @@ pub struct CMutexGuard<'a, T> {
     _pin: PhantomPinned,
 }
 
-impl<'a, T> Drop for CMutexGuard<'a, T> {
+impl<T> Drop for CMutexGuard<'_, T> {
     #[inline]
     fn drop(&mut self) {
         let sguard = self.mtx.spin_lock.acquire();
@@ -128,7 +132,7 @@ impl<'a, T> Drop for CMutexGuard<'a, T> {
     }
 }
 
-impl<'a, T> Deref for CMutexGuard<'a, T> {
+impl<T> Deref for CMutexGuard<'_, T> {
     type Target = T;
 
     #[inline]
@@ -137,7 +141,7 @@ impl<'a, T> Deref for CMutexGuard<'a, T> {
     }
 }
 
-impl<'a, T> DerefMut for CMutexGuard<'a, T> {
+impl<T> DerefMut for CMutexGuard<'_, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { &mut *self.mtx.data.get() }

examples/pthread_mutex.rs

@@ -38,6 +38,7 @@ mod pthread_mtx {
 
     #[derive(Debug)]
     pub enum Error {
+        #[expect(dead_code)]
         IO(std::io::Error),
         Alloc,
     }
@@ -109,22 +110,22 @@ mod pthread_mtx {
         mtx: &'a PThreadMutex<T>,
     }
 
-    impl<'a, T> Drop for PThreadMutexGuard<'a, T> {
+    impl<T> Drop for PThreadMutexGuard<'_, T> {
         fn drop(&mut self) {
             // SAFETY: raw is always initialized
             unsafe { libc::pthread_mutex_unlock(self.mtx.raw.get()) };
         }
     }
 
-    impl<'a, T> Deref for PThreadMutexGuard<'a, T> {
+    impl<T> Deref for PThreadMutexGuard<'_, T> {
         type Target = T;
 
         fn deref(&self) -> &Self::Target {
             unsafe { &*self.mtx.data.get() }
         }
     }
 
-    impl<'a, T> DerefMut for PThreadMutexGuard<'a, T> {
+    impl<T> DerefMut for PThreadMutexGuard<'_, T> {
         fn deref_mut(&mut self) -> &mut Self::Target {
             unsafe { &mut *self.mtx.data.get() }
         }

tests/alloc_fail.rs

@@ -3,7 +3,6 @@
 #[cfg(feature = "alloc")]
 use core::alloc::AllocError;
 
-use core::convert::Infallible;
 use pinned_init::*;
 use std::sync::Arc;
 

tests/ring_buf.rs

@@ -109,7 +109,8 @@ impl<T, const SIZE: usize> RingBuffer<T, SIZE> {
     ///
     /// TODO
     unsafe fn advance(&mut self, ptr: *mut T) -> *mut T {
-        let ptr = ptr.add(1);
+        // SAFETY: ptr's offset from buffer is < SIZE
+        let ptr = unsafe { ptr.add(1) };
         let origin: *mut _ = addr_of_mut!(self.buffer);
         let origin = origin.cast::<T>();
         let offset = unsafe { ptr.offset_from(origin) };
@@ -124,7 +125,7 @@ impl<T, const SIZE: usize> RingBuffer<T, SIZE> {
 #[test]
 fn on_stack() -> Result<(), Infallible> {
     stack_pin_init!(let buf = RingBuffer::<u8, 64>::new());
-    while let Some(elem) = buf.as_mut().pop() {
+    if let Some(elem) = buf.as_mut().pop() {
         panic!("found in empty buffer!: {elem}");
     }
     assert!(buf.as_mut().push(10));
@@ -286,6 +287,6 @@ fn with_big_struct() {
         Ok(false)
     );
     for _ in 0..63 {
-        assert!(matches!(buf.as_mut().pop_no_stack(), Some(_)));
+        assert!(buf.as_mut().pop_no_stack().is_some());
     }
 }