Use if-let guards in some match expressions

8 files changed, 79 insertions, 84 deletions

diff --git a/android/translations-converter/src/main.rs b/android/translations-converter/src/main.rs
index ca88408ebb..741bc40743 100644
--- a/android/translations-converter/src/main.rs
+++ b/android/translations-converter/src/main.rs
@@ -406,25 +406,26 @@ fn generate_translations(
 
     for translation in translations {
         match translation.value {
-            MsgValue::Invariant(translation_value, arg_ordering) => {
-                if let Some(android_key) = known_strings.remove(&translation.id.normalize()) {
-                    localized_strings.push(StringResource::new(
-                        android_key.name,
-                        &translation_value.normalize(),
-                        arg_ordering.as_ref(),
-                    ));
-                }
+            MsgValue::Invariant(translation_value, arg_ordering)
+                if let Some(android_key) = known_strings.remove(&translation.id.normalize()) =>
+            {
+                localized_strings.push(StringResource::new(
+                    android_key.name,
+                    &translation_value.normalize(),
+                    arg_ordering.as_ref(),
+                ));
             }
-            MsgValue::Plural { values, .. } => {
-                if let Some(android_key) = known_plurals.remove(&translation.id.normalize()) {
-                    let values = values.into_iter().map(|message| message.normalize());
+            MsgValue::Plural { values, .. }
+                if let Some(android_key) = known_plurals.remove(&translation.id.normalize()) =>
+            {
+                let values = values.into_iter().map(|message| message.normalize());
 
-                    localized_plurals.push(PluralResource::new(
-                        android_key.name.clone(),
-                        plural_quantities.clone().zip(values),
-                    ));
-                }
+                localized_plurals.push(PluralResource::new(
+                    android_key.name.clone(),
+                    plural_quantities.clone().zip(values),
+                ));
             }
+            _ => {}
         }
     }
 
diff --git a/mullvad-api/src/rest.rs b/mullvad-api/src/rest.rs
index e4eb012833..94a3a4cf0f 100644
--- a/mullvad-api/src/rest.rs
+++ b/mullvad-api/src/rest.rs
@@ -100,14 +100,12 @@ impl Error {
     /// Return true if there was no route to the destination
     pub fn is_offline(&self) -> bool {
         match self {
-            Error::LegacyHyperError(error) if error.is_connect() => {
-                if let Some(cause) = error.source()
-                    && let Some(err) = cause.downcast_ref::<std::io::Error>()
-                {
-                    return err.raw_os_error() == Some(libc::ENETUNREACH);
-                }
-
-                false
+            Error::LegacyHyperError(error)
+                if error.is_connect()
+                    && let Some(cause) = error.source()
+                    && let Some(err) = cause.downcast_ref::<std::io::Error>() =>
+            {
+                err.raw_os_error() == Some(libc::ENETUNREACH)
             }
             // TODO: Currently, we use the legacy hyper client for all REST requests. If this
             // changes in the future, we likely need to match on `Error::HyperError` here and
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index d26adb2812..5de38f50b4 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -1412,11 +1412,10 @@ impl ManagementInterfaceServer {
             Err(timeout) => {
                 log::error!("Timed out while shutting down management server: {timeout}");
             }
-            Ok(join_result) => {
-                if let Err(_error) = join_result {
-                    log::error!("Management server task failed to execute until completion");
-                }
+            Ok(join_result) if let Err(_error) = &join_result => {
+                log::error!("Management server task failed to execute until completion");
             }
+            Ok(_) => {}
         }
     }
 
diff --git a/mullvad-leak-checker/src/util.rs b/mullvad-leak-checker/src/util.rs
index 677a63a807..c8aa6fb85e 100644
--- a/mullvad-leak-checker/src/util.rs
+++ b/mullvad-leak-checker/src/util.rs
@@ -71,16 +71,13 @@ pub fn get_interface_ip(interface: &Interface, ip_version: Ip) -> anyhow::Result
         };
 
         match ip_version {
-            Ip::V4(()) => {
-                if let Some(address) = address.as_sockaddr_in() {
-                    return Ok(IpAddr::V4(address.ip()));
-                };
+            Ip::V4(()) if let Some(address) = address.as_sockaddr_in() => {
+                return Ok(IpAddr::V4(address.ip()));
             }
-            Ip::V6(()) => {
-                if let Some(address) = address.as_sockaddr_in6() {
-                    return Ok(IpAddr::V6(address.ip()));
-                };
+            Ip::V6(()) if let Some(address) = address.as_sockaddr_in6() => {
+                return Ok(IpAddr::V6(address.ip()));
             }
+            _ => {}
         }
     }
 
diff --git a/talpid-core/src/split_tunnel/macos/tun.rs b/talpid-core/src/split_tunnel/macos/tun.rs
index 8e0ca069fd..e53acf114e 100644
--- a/talpid-core/src/split_tunnel/macos/tun.rs
+++ b/talpid-core/src/split_tunnel/macos/tun.rs
@@ -744,25 +744,25 @@ fn fix_ipv4_checksums(
     let destination_ip = ip.get_destination();
 
     match ip.get_next_level_protocol() {
-        IpNextHeaderProtocols::Tcp => {
-            if let Some(mut tcp) = MutableTcpPacket::new(ip.payload_mut()) {
-                use pnet_packet::tcp::ipv4_checksum;
-                tcp.set_checksum(ipv4_checksum(
-                    &tcp.to_immutable(),
-                    &source_ip,
-                    &destination_ip,
-                ));
-            }
+        IpNextHeaderProtocols::Tcp
+            if let Some(mut tcp) = MutableTcpPacket::new(ip.payload_mut()) =>
+        {
+            use pnet_packet::tcp::ipv4_checksum;
+            tcp.set_checksum(ipv4_checksum(
+                &tcp.to_immutable(),
+                &source_ip,
+                &destination_ip,
+            ));
         }
-        IpNextHeaderProtocols::Udp => {
-            if let Some(mut udp) = MutableUdpPacket::new(ip.payload_mut()) {
-                use pnet_packet::udp::ipv4_checksum;
-                udp.set_checksum(ipv4_checksum(
-                    &udp.to_immutable(),
-                    &source_ip,
-                    &destination_ip,
-                ));
-            }
+        IpNextHeaderProtocols::Udp
+            if let Some(mut udp) = MutableUdpPacket::new(ip.payload_mut()) =>
+        {
+            use pnet_packet::udp::ipv4_checksum;
+            udp.set_checksum(ipv4_checksum(
+                &udp.to_immutable(),
+                &source_ip,
+                &destination_ip,
+            ));
         }
         _ => (),
     }
@@ -788,25 +788,25 @@ fn fix_ipv6_checksums(
     let destination_ip = ip.get_destination();
 
     match ip.get_next_header() {
-        IpNextHeaderProtocols::Tcp => {
-            if let Some(mut tcp) = MutableTcpPacket::new(ip.payload_mut()) {
-                use pnet_packet::tcp::ipv6_checksum;
-                tcp.set_checksum(ipv6_checksum(
-                    &tcp.to_immutable(),
-                    &source_ip,
-                    &destination_ip,
-                ));
-            }
+        IpNextHeaderProtocols::Tcp
+            if let Some(mut tcp) = MutableTcpPacket::new(ip.payload_mut()) =>
+        {
+            use pnet_packet::tcp::ipv6_checksum;
+            tcp.set_checksum(ipv6_checksum(
+                &tcp.to_immutable(),
+                &source_ip,
+                &destination_ip,
+            ));
         }
-        IpNextHeaderProtocols::Udp => {
-            if let Some(mut udp) = MutableUdpPacket::new(ip.payload_mut()) {
-                use pnet_packet::udp::ipv6_checksum;
-                udp.set_checksum(ipv6_checksum(
-                    &udp.to_immutable(),
-                    &source_ip,
-                    &destination_ip,
-                ));
-            }
+        IpNextHeaderProtocols::Udp
+            if let Some(mut udp) = MutableUdpPacket::new(ip.payload_mut()) =>
+        {
+            use pnet_packet::udp::ipv6_checksum;
+            udp.set_checksum(ipv6_checksum(
+                &udp.to_immutable(),
+                &source_ip,
+                &destination_ip,
+            ));
         }
         _ => (),
     }
diff --git a/talpid-routing/src/windows/mod.rs b/talpid-routing/src/windows/mod.rs
index e52af75b12..21baf03979 100644
--- a/talpid-routing/src/windows/mod.rs
+++ b/talpid-routing/src/windows/mod.rs
@@ -206,11 +206,12 @@ impl RouteManagerHandle {
                     };
                     let _ = tx.send(res);
                 }
-                RouteManagerCommand::ClearRoutes => {
-                    if let Err(e) = internal.delete_applied_routes() {
-                        log::error!("{}", e.display_chain_with_msg("Could not clear routes"));
-                    }
+                RouteManagerCommand::ClearRoutes
+                    if let Err(e) = internal.delete_applied_routes() =>
+                {
+                    log::error!("{}", e.display_chain_with_msg("Could not clear routes"));
                 }
+                RouteManagerCommand::ClearRoutes => {}
                 RouteManagerCommand::RegisterDefaultRouteChangeCallback(callback, tx) => {
                     let _ = tx.send(internal.register_default_route_changed_callback(callback));
                 }
diff --git a/talpid-wireguard/src/ephemeral.rs b/talpid-wireguard/src/ephemeral.rs
index d031f5e926..a87ddcbde9 100644
--- a/talpid-wireguard/src/ephemeral.rs
+++ b/talpid-wireguard/src/ephemeral.rs
@@ -65,11 +65,10 @@ pub async fn config_ephemeral_peers(
 fn try_set_ipv4_mtu(alias: &str, mtu: u16) {
     use talpid_windows::net::*;
     match luid_from_alias(alias) {
-        Ok(luid) => {
-            if let Err(error) = set_mtu(u32::from(mtu), luid, AddressFamily::Ipv4) {
-                log::error!("Failed to set tunnel interface MTU: {error}");
-            }
+        Ok(luid) if let Err(error) = set_mtu(u32::from(mtu), luid, AddressFamily::Ipv4) => {
+            log::error!("Failed to set tunnel interface MTU: {error}");
         }
+        Ok(_) => {}
         Err(error) => {
             log::error!("Failed to obtain tunnel interface LUID: {error}")
         }
diff --git a/talpid-wireguard/src/wireguard_kernel/stats.rs b/talpid-wireguard/src/wireguard_kernel/stats.rs
index 4c19e162f3..2529646399 100644
--- a/talpid-wireguard/src/wireguard_kernel/stats.rs
+++ b/talpid-wireguard/src/wireguard_kernel/stats.rs
@@ -17,10 +17,10 @@ impl Stats {
                         match nla {
                             PeerNla::TxBytes(bytes) => tx_bytes = *bytes,
                             PeerNla::RxBytes(bytes) => rx_bytes = *bytes,
-                            PeerNla::LastHandshakeTime(timestamp) => {
-                                if let Some(timestamp) = timestamp.as_systemtime() {
-                                    last_handshake_time = Some(timestamp)
-                                }
+                            PeerNla::LastHandshakeTime(timestamp)
+                                if let Some(timestamp) = timestamp.as_systemtime() =>
+                            {
+                                last_handshake_time = Some(timestamp)
                             }
                             PeerNla::PublicKey(key) => pub_key = Some(*key),
                             _ => continue,