style: rename _guard to guard

Signed-off-by: Martin Kröning <martin.kroening@eonerc.rwth-aachen.de>

Author: mkroening

src/interrupt_dropper.rs

@@ -42,9 +42,10 @@ impl<T> DerefMut for InterruptDropper<T> {
 impl<T> Drop for InterruptDropper<T> {
     #[inline]
     fn drop(&mut self) {
-        let _guard = interrupts::disable();
+        let guard = interrupts::disable();
         // Drop `inner` as while we can guarentee interrupts are disabled
         // SAFETY: This is not exposed to safe code and is not called more than once
         unsafe { ManuallyDrop::drop(&mut self.inner) }
+        drop(guard);
     }
 }

src/lib.rs

@@ -266,10 +266,10 @@ impl<T: ?Sized> InterruptRefCell<T> {
     #[inline]
     #[cfg_attr(feature = "debug_interruptrefcell", track_caller)]
     pub fn try_borrow(&self) -> Result<InterruptRef<'_, T>, BorrowError> {
-        let _guard = interrupts::disable();
+        let guard = interrupts::disable();
         self.inner.try_borrow().map(|inner| {
             let inner = InterruptDropper::from(inner);
-            InterruptRef { inner, _guard }
+            InterruptRef { inner, guard }
         })
     }
 
@@ -337,10 +337,10 @@ impl<T: ?Sized> InterruptRefCell<T> {
     #[inline]
     #[cfg_attr(feature = "debug_interruptrefcell", track_caller)]
     pub fn try_borrow_mut(&self) -> Result<InterruptRefMut<'_, T>, BorrowMutError> {
-        let _guard = interrupts::disable();
+        let guard = interrupts::disable();
         self.inner.try_borrow_mut().map(|inner| {
             let inner = InterruptDropper::from(inner);
-            InterruptRefMut { inner, _guard }
+            InterruptRefMut { inner, guard }
         })
     }
 
@@ -421,8 +421,10 @@ impl<T: ?Sized> InterruptRefCell<T> {
     /// ```
     #[inline]
     pub unsafe fn try_borrow_unguarded(&self) -> Result<&T, BorrowError> {
-        let _guard = interrupts::disable();
-        self.inner.try_borrow_unguarded()
+        let guard = interrupts::disable();
+        let ret = self.inner.try_borrow_unguarded();
+        drop(guard);
+        ret
     }
 }
 
@@ -554,7 +556,7 @@ impl<T> From<T> for InterruptRefCell<T> {
 /// See the [module-level documentation](self) for more.
 pub struct InterruptRef<'b, T: ?Sized + 'b> {
     inner: InterruptDropper<Ref<'b, T>>,
-    _guard: interrupts::Guard,
+    guard: interrupts::Guard,
 }
 
 impl<T: ?Sized> Deref for InterruptRef<'_, T> {
@@ -579,9 +581,9 @@ impl<'b, T: ?Sized> InterruptRef<'b, T> {
     #[must_use]
     #[inline]
     pub fn clone(orig: &InterruptRef<'b, T>) -> InterruptRef<'b, T> {
-        let _guard = interrupts::disable();
+        let guard = interrupts::disable();
         let inner = InterruptDropper::from(Ref::clone(&orig.inner));
-        InterruptRef { inner, _guard }
+        InterruptRef { inner, guard }
     }
 
     /// Makes a new `InterruptRef` for a component of the borrowed data.
@@ -607,9 +609,9 @@ impl<'b, T: ?Sized> InterruptRef<'b, T> {
     where
         F: FnOnce(&T) -> &U,
     {
-        let InterruptRef { inner, _guard } = orig;
+        let InterruptRef { inner, guard } = orig;
         let inner = InterruptDropper::from(Ref::map(InterruptDropper::into_inner(inner), f));
-        InterruptRef { inner, _guard }
+        InterruptRef { inner, guard }
     }
 
     /// Makes a new `InterruptRef` for an optional component of the borrowed data. The
@@ -641,15 +643,15 @@ impl<'b, T: ?Sized> InterruptRef<'b, T> {
     where
         F: FnOnce(&T) -> Option<&U>,
     {
-        let InterruptRef { inner, _guard } = orig;
+        let InterruptRef { inner, guard } = orig;
         match Ref::filter_map(InterruptDropper::into_inner(inner), f) {
             Ok(inner) => {
                 let inner = InterruptDropper::from(inner);
-                Ok(InterruptRef { inner, _guard })
+                Ok(InterruptRef { inner, guard })
             }
             Err(inner) => {
                 let inner = InterruptDropper::from(inner);
-                Err(InterruptRef { inner, _guard })
+                Err(InterruptRef { inner, guard })
             }
         }
     }
@@ -682,16 +684,16 @@ impl<'b, T: ?Sized> InterruptRef<'b, T> {
     where
         F: FnOnce(&T) -> (&U, &V),
     {
-        let _guard = interrupts::disable();
+        let guard = interrupts::disable();
         let (a, b) = Ref::map_split(InterruptDropper::into_inner(orig.inner), f);
         (
             InterruptRef {
                 inner: InterruptDropper::from(a),
-                _guard,
+                guard,
             },
             InterruptRef {
                 inner: InterruptDropper::from(b),
-                _guard: orig._guard,
+                guard: orig.guard,
             },
         )
     }
@@ -738,9 +740,9 @@ impl<'b, T: ?Sized> InterruptRefMut<'b, T> {
     where
         F: FnOnce(&mut T) -> &mut U,
     {
-        let InterruptRefMut { inner, _guard } = orig;
+        let InterruptRefMut { inner, guard } = orig;
         let inner = InterruptDropper::from(RefMut::map(InterruptDropper::into_inner(inner), f));
-        InterruptRefMut { inner, _guard }
+        InterruptRefMut { inner, guard }
     }
 
     /// Makes a new `InterruptRefMut` for an optional component of the borrowed data. The
@@ -780,15 +782,15 @@ impl<'b, T: ?Sized> InterruptRefMut<'b, T> {
     where
         F: FnOnce(&mut T) -> Option<&mut U>,
     {
-        let InterruptRefMut { inner, _guard } = orig;
+        let InterruptRefMut { inner, guard } = orig;
         match RefMut::filter_map(InterruptDropper::into_inner(inner), f) {
             Ok(inner) => {
                 let inner = InterruptDropper::from(inner);
-                Ok(InterruptRefMut { inner, _guard })
+                Ok(InterruptRefMut { inner, guard })
             }
             Err(inner) => {
                 let inner = InterruptDropper::from(inner);
-                Err(InterruptRefMut { inner, _guard })
+                Err(InterruptRefMut { inner, guard })
             }
         }
     }
@@ -826,16 +828,16 @@ impl<'b, T: ?Sized> InterruptRefMut<'b, T> {
     where
         F: FnOnce(&mut T) -> (&mut U, &mut V),
     {
-        let _guard = interrupts::disable();
+        let guard = interrupts::disable();
         let (a, b) = RefMut::map_split(InterruptDropper::into_inner(orig.inner), f);
         (
             InterruptRefMut {
                 inner: InterruptDropper::from(a),
-                _guard,
+                guard,
             },
             InterruptRefMut {
                 inner: InterruptDropper::from(b),
-                _guard: orig._guard,
+                guard: orig.guard,
             },
         )
     }
@@ -846,7 +848,7 @@ impl<'b, T: ?Sized> InterruptRefMut<'b, T> {
 /// See the [module-level documentation](self) for more.
 pub struct InterruptRefMut<'b, T: ?Sized + 'b> {
     inner: InterruptDropper<RefMut<'b, T>>,
-    _guard: interrupts::Guard,
+    guard: interrupts::Guard,
 }
 
 impl<T: ?Sized> Deref for InterruptRefMut<'_, T> {