rust: deny rust_2018_idioms warnings

Signed-off-by: Gary Guo <[email protected]>

Author: nbdd0121

rust/kernel/lib.rs

@@ -27,6 +27,7 @@
 #![deny(clippy::correctness)]
 #![deny(clippy::perf)]
 #![deny(clippy::style)]
+#![deny(rust_2018_idioms)]
 
 // Ensure conditional compilation based on the kernel configuration works;
 // otherwise we may silently break things like initcall handling.

rust/kernel/pages.rs

@@ -132,7 +132,7 @@ impl<const ORDER: u32> Pages<ORDER> {
     }
 
     /// Maps the page at index `index`.
-    fn kmap(&self, index: usize) -> Option<PageMapping> {
+    fn kmap(&self, index: usize) -> Option<PageMapping<'_>> {
         if index >= 1usize << ORDER {
             return None;
         }

rust/kernel/sync/condvar.rs

@@ -65,7 +65,7 @@ impl CondVar {
     ///
     /// Returns whether there is a signal pending.
     #[must_use = "wait returns if a signal is pending, so the caller must check the return value"]
-    pub fn wait<L: Lock>(&self, guard: &mut Guard<L>) -> bool {
+    pub fn wait<L: Lock>(&self, guard: &mut Guard<'_, L>) -> bool {
         let lock = guard.lock;
         let mut wait = MaybeUninit::<bindings::wait_queue_entry>::uninit();
 

rust/kernel/sync/locked_by.rs

@@ -78,7 +78,7 @@ impl<T, L: Lock + ?Sized> LockedBy<T, L> {
 impl<T: ?Sized, L: Lock + ?Sized> LockedBy<T, L> {
     /// Returns a reference to the protected data when the caller provides evidence (via a
     /// [`Guard`]) that the owner is locked.
-    pub fn access<'a>(&'a self, guard: &'a Guard<L>) -> &'a T {
+    pub fn access<'a>(&'a self, guard: &'a Guard<'_, L>) -> &'a T {
         if !ptr::eq(guard.deref(), self.owner) {
             panic!("guard does not match owner");
         }
@@ -89,7 +89,7 @@ impl<T: ?Sized, L: Lock + ?Sized> LockedBy<T, L> {
 
     /// Returns a mutable reference to the protected data when the caller provides evidence (via a
     /// mutable [`Guard`]) that the owner is locked mutably.
-    pub fn access_mut<'a>(&'a self, guard: &'a mut Guard<L>) -> &'a mut T {
+    pub fn access_mut<'a>(&'a self, guard: &'a mut Guard<'_, L>) -> &'a mut T {
         if !ptr::eq(guard.deref().deref(), self.owner) {
             panic!("guard does not match owner");
         }

rust/kernel/sync/mutex.rs

@@ -64,7 +64,7 @@ impl<T> Mutex<T> {
 impl<T: ?Sized> Mutex<T> {
     /// Locks the mutex and gives the caller access to the data protected by it. Only one thread at
     /// a time is allowed to access the protected data.
-    pub fn lock(&self) -> Guard<Self> {
+    pub fn lock(&self) -> Guard<'_, Self> {
         self.lock_noguard();
         // SAFETY: The mutex was just acquired.
         unsafe { Guard::new(self) }

rust/kernel/sync/spinlock.rs

@@ -78,7 +78,7 @@ impl<T> SpinLock<T> {
 impl<T: ?Sized> SpinLock<T> {
     /// Locks the spinlock and gives the caller access to the data protected by it. Only one thread
     /// at a time is allowed to access the protected data.
-    pub fn lock(&self) -> Guard<Self> {
+    pub fn lock(&self) -> Guard<'_, Self> {
         self.lock_noguard();
         // SAFETY: The spinlock was just acquired.
         unsafe { Guard::new(self) }