Replace as_mut with deref impl for MutCircEnt

crates/tor-proto/src/channel/circmap.rs

@@ -14,6 +14,7 @@ use futures::channel::{mpsc, oneshot};
 use rand::distributions::Distribution;
 use rand::Rng;
 use std::collections::{hash_map::Entry, HashMap};
+use std::ops::{Deref, DerefMut};
 
 /// Which group of circuit IDs are we allowed to allocate in this map?
 ///
@@ -91,20 +92,27 @@ pub(super) struct MutCircEnt<'a> {
     was_open: bool,
 }
 
-impl<'a> AsMut<CircEnt> for MutCircEnt<'a> {
-    fn as_mut(&mut self) -> &mut CircEnt {
-        self.value
-    }
-}
-
 impl<'a> Drop for MutCircEnt<'a> {
     fn drop(&mut self) {
         let is_open = !matches!(self.value, CircEnt::DestroySent(_));
         match (self.was_open, is_open) {
-            (false, true) => *self.open_count += 1,
-            (true, false) => *self.open_count -= 1,
-            (_, _) => {}
-        }
+            (false, true) => *self.open_count = self.open_count.saturating_add(1),
+            (true, false) => *self.open_count = self.open_count.saturating_sub(1),
+            (_, _) => (),
+        };
+    }
+}
+
+impl<'a> Deref for MutCircEnt<'a> {
+    type Target = CircEnt;
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+impl<'a> DerefMut for MutCircEnt<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.value
     }
 }
 
@@ -255,8 +263,8 @@ mod test {
             ids_low.push(id_low);
 
             assert!(matches!(
-                map_low.get_mut(id_low).unwrap().as_mut(),
-                &mut CircEnt::Opening(_, _)
+                *map_low.get_mut(id_low).unwrap(),
+                CircEnt::Opening(_, _)
             ));
 
             let (csnd, _) = oneshot::channel();
@@ -286,14 +294,14 @@ mod test {
         // Good case.
         assert!(map_high.get_mut(ids_high[0]).is_some());
         assert!(matches!(
-            map_high.get_mut(ids_high[0]).unwrap().as_mut(),
-            &mut CircEnt::Opening(_, _)
+            *map_high.get_mut(ids_high[0]).unwrap(),
+            CircEnt::Opening(_, _)
         ));
         let adv = map_high.advance_from_opening(ids_high[0]);
         assert!(adv.is_ok());
         assert!(matches!(
-            map_high.get_mut(ids_high[0]).unwrap().as_mut(),
-            &mut CircEnt::Open(_)
+            *map_high.get_mut(ids_high[0]).unwrap(),
+            CircEnt::Open(_)
         ));
 
         // Can't double-advance.

crates/tor-proto/src/channel/reactor.rs

@@ -288,12 +288,12 @@ impl Reactor {
 
     /// Give the RELAY cell `msg` to the appropriate circuit.
     async fn deliver_relay(&mut self, circid: CircId, msg: ChanMsg) -> Result<()> {
-        let opt_ent = self.circs.get_mut(circid);
-        if opt_ent.is_none() {
-            return Err(Error::ChanProto("Relay cell on nonexistent circuit".into()));
-        }
-        let mut ent = opt_ent.expect("None entry should have been checked.");
-        match ent.as_mut() {
+        let mut ent = self
+            .circs
+            .get_mut(circid)
+            .ok_or_else(|| Error::ChanProto("Relay cell on nonexistent circuit".into()))?;
+
+        match &mut *ent {
             CircEnt::Open(s) => {
                 // There's an open circuit; we can give it the RELAY cell.
                 if s.send(msg.try_into()?).await.is_err() {
@@ -495,7 +495,7 @@ pub(crate) mod test {
             let id = pending.peek_circid();
 
             let ent = reactor.circs.get_mut(id);
-            assert!(matches!(ent.unwrap().as_mut(), CircEnt::Opening(_, _)));
+            assert!(matches!(*ent.unwrap(), CircEnt::Opening(_, _)));
             assert!(chan.duration_unused().is_none()); // in use
 
             // Now drop the circuit; this should tell the reactor to remove
@@ -504,7 +504,7 @@ pub(crate) mod test {
 
             reactor.run_once().await.unwrap();
             let ent = reactor.circs.get_mut(id);
-            assert!(matches!(ent.unwrap().as_mut(), CircEnt::DestroySent(_)));
+            assert!(matches!(*ent.unwrap(), CircEnt::DestroySent(_)));
             let cell = output.next().await.unwrap();
             assert_eq!(cell.circid(), id);
             assert!(matches!(cell.msg(), ChanMsg::Destroy(_)));
@@ -536,7 +536,7 @@ pub(crate) mod test {
             let id = pending.peek_circid();
 
             let ent = reactor.circs.get_mut(id);
-            assert!(matches!(ent.unwrap().as_mut(), CircEnt::Opening(_, _)));
+            assert!(matches!(*ent.unwrap(), CircEnt::Opening(_, _)));
 
             #[allow(clippy::clone_on_copy)]
             let rtc = rt.clone();
@@ -563,7 +563,7 @@ pub(crate) mod test {
 
             // But the next run if the reactor will make the circuit get closed.
             let ent = reactor.circs.get_mut(id);
-            assert!(matches!(ent.unwrap().as_mut(), CircEnt::DestroySent(_)));
+            assert!(matches!(*ent.unwrap(), CircEnt::DestroySent(_)));
         });
     }