Clippy fix

Author: Lucas Paixão

src/buf/fixed/handle.rs

@@ -38,7 +38,7 @@ impl Drop for FixedBuf {
   fn drop(&mut self) {
     let registry = Rc::get_mut(&mut self.registry);
 
-    if let None = registry { return; }
+    if registry.is_none() { return; }
 
     let registry = registry.unwrap();
     // Safety: the length of the initialized data in the buffer has been

src/buf/fixed/pool.rs

@@ -228,10 +228,10 @@ impl<T: IoBufMut> FixedBufPool<T> {
   pub fn try_next(&mut self, cap: usize) -> Option<FixedBuf> {
     let inner = Rc::get_mut(&mut self.inner);
 
-    if let None = inner { return None }
+    if inner.is_none() { return None }
 
     inner.unwrap().try_next(cap).map(|data| {
-      let pool = Rc::clone(&mut self.inner);
+      let pool = Rc::clone(&self.inner);
       // Safety: the validity of buffer data is ensured by
       // plumbing::Pool::try_next
       unsafe { FixedBuf::new(pool, data) }

src/lib.rs

@@ -57,7 +57,7 @@
 //! call `close()`.
 
 #![warn(missing_docs)]
-#![allow(clippy::thread_local_initializer_can_be_made_const)]
+#![allow(clippy::missing_const_for_thread_local)]
 
 macro_rules! syscall {
     ($fn: ident ( $($arg: expr),* $(,)* ) ) => {{

src/runtime/driver/mod.rs

@@ -205,7 +205,7 @@ impl Driver {
       }
       Lifecycle::CompletionList(list) => {
         // Deallocate list entries, recording if more CQE's are expected
-        let more = cqueue::more(list.into_iter().last().unwrap().flags);
+        let more = cqueue::more(list.into_iter().next_back().unwrap().flags);
 
         if more {
           // If more are expected, we have to keep the op around
@@ -240,14 +240,13 @@ impl Driver {
     Ok(op)
   }
 
-  pub(crate) fn submit_op<T: Unpin, S: Unpin, F>(
+  pub(crate) fn submit_op<T: Unpin + Completable, S: Unpin, F>(
     &self,
     mut data: T,
     f: F,
     handle: WeakHandle,
   ) -> io::Result<Pin<Box<Op<T, S>>>>
   where
-    T: Completable,
     F: FnOnce(&mut T) -> squeue::Entry,
   {
     // Configure the SQE

src/runtime/driver/op/mod.rs

@@ -97,7 +97,7 @@ pub struct ArcMonitorGuard<'a, T> {
   arc_monitor: &'a ArcMonitor<T>,
 }
 
-impl<'a, T> Drop for ArcMonitorGuard<'a, T> {
+impl<T> Drop for ArcMonitorGuard<'_, T> {
   fn drop(&mut self) {
     self.arc_monitor.leave();
   }
@@ -162,7 +162,7 @@ impl<T> ArcMonitor<T> {
 
     if old_uses > 0 {
       return Some(ArcMonitorGuard {
-        arc_monitor: &self,
+        arc_monitor: self,
       });
     }
 
@@ -176,7 +176,7 @@ impl<T> ArcMonitor<T> {
     }
 
     Some(ArcMonitorGuard {
-      arc_monitor: &self,
+      arc_monitor: self,
     })
   }
 
@@ -222,13 +222,10 @@ impl<T> ArcMonitor<T> {
       }
     }
 
-    let is_recycled =
-      self
-        .status
-        .compare_exchange(ArcMonitorStatus::Live, ArcMonitorStatus::Dropped, Ordering::Release, Ordering::Relaxed)
-        .is_ok();
-
-    is_recycled
+    self
+      .status
+      .compare_exchange(ArcMonitorStatus::Live, ArcMonitorStatus::Dropped, Ordering::Release, Ordering::Relaxed)
+      .is_ok()
   }
 }
 
@@ -247,20 +244,12 @@ impl<T> DerefMut for ArcMonitor<T> {
   }
 }
 
+#[derive(Default)]
 pub(crate) struct Location {
   pub(crate) address: usize,
   pub(crate) vtable: usize,
 }
 
-impl Default for Location {
-  fn default() -> Location {
-    Location {
-      address: 0,
-      vtable: 0
-    }
-  }
-}
-
 /// In-flight operation
 pub struct Op<T: 'static, CqeType = SingleCQE>
 where
@@ -379,7 +368,7 @@ impl<T: Unpin, CqeType: Unpin> Op<T, CqeType> {
   fn initialize(mut self: Pin<Box<Self>>) -> Pin<Box<Self>> {
     let location = ArcMonitor::<Location>::new(Default::default(), 2);
 
-    let this: *mut Self = unsafe { mem::transmute(&*self) };
+    let this = &*self as *const Op<T, CqeType> as *mut Op<T, CqeType>;
     let notifiable: *mut dyn Notifiable = this as *mut _;
 
     //SAFETY: Converting current address and vtable to a tuple

src/runtime/mod.rs

@@ -68,7 +68,7 @@ pub struct Runtime {
 ///     handle.await.unwrap();
 /// });
 /// ```
-pub fn spawn<F: Future + 'static>(task: F) -> tokio::task::JoinHandle<F::Output>
+pub fn spawn<F>(task: F) -> tokio::task::JoinHandle<F::Output>
 where F: Future + Send + 'static,
       F::Output: Send + 'static
 {
@@ -98,7 +98,7 @@ impl Runtime {
   /// Creates a new tokio_uring runtime on the current thread.
   ///
   /// This takes the tokio-uring [`Builder`](crate::Builder) as a parameter.
-  pub fn new<'a>() -> io::Result<Runtime> {
+  pub fn new() -> io::Result<Runtime> {
     let mut runtime = Runtime {
       local: ManuallyDrop::new(LocalSet::new()),
       tokio_rt: MaybeUninit::zeroed(),
@@ -138,10 +138,9 @@ impl Runtime {
     let is_unique = |item: &Arc<RuntimeContext>, list: LinkedList<Arc<RuntimeContext>>| {
       let item_fd = item.handle().as_raw_fd();
 
-      list
+      !list
         .iter()
-        .find(|i| i.handle().as_raw_fd() == item_fd)
-        .is_none()
+        .any(|i| i.handle().as_raw_fd() == item_fd)
     };
 
     let contexts = self.contexts.clone();