Merge branch 'clippy-non-semantic-manual-fixes'

37 files changed, 127 insertions, 163 deletions

diff --git a/mullvad-api/src/abortable_stream.rs b/mullvad-api/src/abortable_stream.rs
index af217c5768..261693eb27 100644
--- a/mullvad-api/src/abortable_stream.rs
+++ b/mullvad-api/src/abortable_stream.rs
@@ -72,7 +72,7 @@ where
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
-        if let Poll::Ready(_) = Pin::new(&mut self.shutdown_rx).poll(cx) {
+        if Pin::new(&mut self.shutdown_rx).poll(cx).is_ready() {
             return Poll::Ready(Err(io::Error::new(
                 io::ErrorKind::ConnectionReset,
                 Aborted(()),
@@ -82,7 +82,7 @@ where
     }
 
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        if let Poll::Ready(_) = Pin::new(&mut self.shutdown_rx).poll(cx) {
+        if Pin::new(&mut self.shutdown_rx).poll(cx).is_ready() {
             return Poll::Ready(Err(io::Error::new(
                 io::ErrorKind::ConnectionReset,
                 Aborted(()),
@@ -105,7 +105,7 @@ where
         cx: &mut Context<'_>,
         buf: &mut ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
-        if let Poll::Ready(_) = Pin::new(&mut self.shutdown_rx).poll(cx) {
+        if Pin::new(&mut self.shutdown_rx).poll(cx).is_ready() {
             return Poll::Ready(Err(io::Error::new(
                 io::ErrorKind::ConnectionReset,
                 Aborted(()),
diff --git a/mullvad-api/src/https_client_with_sni.rs b/mullvad-api/src/https_client_with_sni.rs
index cc7e2c1561..2920cf989d 100644
--- a/mullvad-api/src/https_client_with_sni.rs
+++ b/mullvad-api/src/https_client_with_sni.rs
@@ -215,10 +215,9 @@ impl HttpsConnectorWithSni {
     }
 
     async fn resolve_address(address_cache: AddressCache, uri: Uri) -> io::Result<SocketAddr> {
-        let hostname = uri.host().ok_or(io::Error::new(
-            io::ErrorKind::InvalidInput,
-            "invalid url, missing host",
-        ))?;
+        let hostname = uri.host().ok_or_else(|| {
+            io::Error::new(io::ErrorKind::InvalidInput, "invalid url, missing host")
+        })?;
         let port = uri.port_u16().unwrap_or(443);
         if let Ok(addr) = hostname.parse::<IpAddr>() {
             return Ok(SocketAddr::new(addr, port));
@@ -241,7 +240,7 @@ impl HttpsConnectorWithSni {
             .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
         let addr = addrs
             .next()
-            .ok_or(io::Error::new(io::ErrorKind::Other, "Empty DNS response"))?;
+            .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Empty DNS response"))?;
         Ok(SocketAddr::new(addr.ip(), port))
     }
 }
diff --git a/mullvad-api/src/rest.rs b/mullvad-api/src/rest.rs
index fbd2986b7c..8a04c62e39 100644
--- a/mullvad-api/src/rest.rs
+++ b/mullvad-api/src/rest.rs
@@ -78,17 +78,11 @@ pub enum Error {
 
 impl Error {
     pub fn is_network_error(&self) -> bool {
-        match self {
-            Error::HyperError(_) | Error::TimeoutError(_) => true,
-            _ => false,
-        }
+        matches!(self, Error::HyperError(_) | Error::TimeoutError(_))
     }
 
     pub fn is_aborted(&self) -> bool {
-        match self {
-            Error::Aborted => true,
-            _ => false,
-        }
+        matches!(self, Error::Aborted)
     }
 
     /// Returns a new instance for which `abortable_stream::Aborted` is mapped to `Self::Aborted`.
diff --git a/mullvad-cli/src/cmds/disconnect.rs b/mullvad-cli/src/cmds/disconnect.rs
index a906eed22d..2864001656 100644
--- a/mullvad-cli/src/cmds/disconnect.rs
+++ b/mullvad-cli/src/cmds/disconnect.rs
@@ -35,9 +35,8 @@ impl Command for Disconnect {
                 while let Some(state) = receiver.next().await {
                     let state = state?;
                     format::print_state(&state, false);
-                    match state.state.unwrap() {
-                        Disconnected(_) => return Ok(()),
-                        _ => {}
+                    if let Disconnected(_) = state.state.unwrap() {
+                        return Ok(());
                     }
                 }
                 return Err(Error::StatusListenerFailed);
diff --git a/mullvad-exclude/src/main.rs b/mullvad-exclude/src/main.rs
index 420075da06..02dab6635f 100644
--- a/mullvad-exclude/src/main.rs
+++ b/mullvad-exclude/src/main.rs
@@ -51,7 +51,7 @@ fn main() {
     match run() {
         Err(Error::InvalidArguments) => {
             let mut args = env::args();
-            let program = args.next().unwrap_or(PROGRAM_NAME.to_string());
+            let program = args.next().unwrap_or_else(|| PROGRAM_NAME.to_string());
             eprintln!("Usage: {} COMMAND [ARGS]", program);
             std::process::exit(1);
         }
diff --git a/mullvad-types/src/relay_constraints.rs b/mullvad-types/src/relay_constraints.rs
index 8da12d579b..4ea0a8dfc5 100644
--- a/mullvad-types/src/relay_constraints.rs
+++ b/mullvad-types/src/relay_constraints.rs
@@ -627,15 +627,13 @@ impl RelaySettingsUpdate {
             }
             RelaySettingsUpdate::Normal(update) => {
                 if let Some(constraints) = &update.openvpn_constraints {
-                    if let Constraint::Only(TransportPort {
-                        protocol: TransportProtocol::Udp,
-                        ..
-                    }) = &constraints.port
-                    {
-                        false
-                    } else {
-                        true
-                    }
+                    !matches!(
+                        &constraints.port,
+                        Constraint::Only(TransportPort {
+                            protocol: TransportProtocol::Udp,
+                            ..
+                        })
+                    )
                 } else {
                     true
                 }
diff --git a/mullvad-types/src/states.rs b/mullvad-types/src/states.rs
index 700b83582f..2d139eee3d 100644
--- a/mullvad-types/src/states.rs
+++ b/mullvad-types/src/states.rs
@@ -50,25 +50,16 @@ pub enum TunnelState {
 impl TunnelState {
     /// Returns true if the tunnel state is in the error state.
     pub fn is_in_error_state(&self) -> bool {
-        match self {
-            TunnelState::Error(_) => true,
-            _ => false,
-        }
+        matches!(self, TunnelState::Error(_))
     }
 
     /// Returns true if the tunnel state is in the connected state.
     pub fn is_connected(&self) -> bool {
-        match self {
-            TunnelState::Connected { .. } => true,
-            _ => false,
-        }
+        matches!(self, TunnelState::Connected { .. })
     }
 
     /// Returns true if the tunnel state is in the disconnected state.
     pub fn is_disconnected(&self) -> bool {
-        match self {
-            TunnelState::Disconnected => true,
-            _ => false,
-        }
+        matches!(self, TunnelState::Disconnected)
     }
 }
diff --git a/mullvad-types/src/version.rs b/mullvad-types/src/version.rs
index 16466f8259..7daf50e74b 100644
--- a/mullvad-types/src/version.rs
+++ b/mullvad-types/src/version.rs
@@ -69,10 +69,7 @@ impl ParsedAppVersion {
     }
 
     pub fn is_dev(&self) -> bool {
-        match self {
-            ParsedAppVersion::Dev(..) => true,
-            _ => false,
-        }
+        matches!(self, ParsedAppVersion::Dev(..))
     }
 }
 
diff --git a/mullvad-types/src/wireguard.rs b/mullvad-types/src/wireguard.rs
index da7f25828a..612becf010 100644
--- a/mullvad-types/src/wireguard.rs
+++ b/mullvad-types/src/wireguard.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::identity_op)]
 use chrono::{offset::Utc, DateTime};
 #[cfg(target_os = "android")]
 use jnix::IntoJava;
diff --git a/talpid-core/src/dns/linux/mod.rs b/talpid-core/src/dns/linux/mod.rs
index 3462c8adfe..5a4bfdb5da 100644
--- a/talpid-core/src/dns/linux/mod.rs
+++ b/talpid-core/src/dns/linux/mod.rs
@@ -142,7 +142,7 @@ impl DnsMonitorHolder {
                 static_resolv_conf.set_dns(servers.to_vec())?
             }
             SystemdResolved(ref mut systemd_resolved) => handle
-                .block_on(systemd_resolved.set_dns(route_manager.clone(), interface, &servers))?,
+                .block_on(systemd_resolved.set_dns(route_manager.clone(), interface, servers))?,
             NetworkManager(ref mut network_manager) => {
                 network_manager.set_dns(interface, servers)?
             }
diff --git a/talpid-core/src/dns/linux/resolvconf.rs b/talpid-core/src/dns/linux/resolvconf.rs
index a9585d4ba2..ea2f3f3704 100644
--- a/talpid-core/src/dns/linux/resolvconf.rs
+++ b/talpid-core/src/dns/linux/resolvconf.rs
@@ -141,14 +141,14 @@ impl Resolvconf {
     // Verify if dnsmasq is configured to ignore any external servers
     // by checking for the `no-resolv` config option.
     fn is_dnsmasq_configured_wrong() -> bool {
-        let mut config_paths = fs::read_dir("/etc/dnsmasq.d/")
+        let mut config_paths: Vec<_> = fs::read_dir("/etc/dnsmasq.d/")
             .map(|entries| {
                 entries
                     .into_iter()
                     .filter_map(|entry| entry.ok().map(|e| e.path()))
                     .collect()
             })
-            .unwrap_or(vec![]);
+            .unwrap_or_default();
 
         config_paths.push(PathBuf::from("/etc/dnsmasq.conf"));
         config_paths
@@ -167,7 +167,7 @@ impl Resolvconf {
             Ok(contents) => contents.contains("Generated by resolvconf"),
             Err(err) => {
                 log::error!("Couldn't read /etc/resolv.conf: {}", err);
-                return false;
+                false
             }
         }
     }
diff --git a/talpid-core/src/dns/linux/static_resolv_conf.rs b/talpid-core/src/dns/linux/static_resolv_conf.rs
index 1a867a079d..196fb31003 100644
--- a/talpid-core/src/dns/linux/static_resolv_conf.rs
+++ b/talpid-core/src/dns/linux/static_resolv_conf.rs
@@ -5,6 +5,7 @@ use resolv_conf::{Config, ScopedIp};
 use std::{
     fs, io,
     net::IpAddr,
+    path::Path,
     sync::{mpsc, Arc},
     thread,
 };
@@ -128,7 +129,7 @@ impl DnsWatcher {
             if event
                 .path
                 .as_ref()
-                .map(|p| p.as_path() == &RESOLV_CONF_PATH.as_ref())
+                .map(|p| p.as_path() == AsRef::<Path>::as_ref(RESOLV_CONF_PATH))
                 .unwrap_or(false)
             {
                 let mut locked_state = state.lock();
diff --git a/talpid-core/src/firewall/linux.rs b/talpid-core/src/firewall/linux.rs
index 4d66e94b1a..24d52eb718 100644
--- a/talpid-core/src/firewall/linux.rs
+++ b/talpid-core/src/firewall/linux.rs
@@ -334,7 +334,7 @@ impl<'a> PolicyBatch<'a> {
         {
             for server in dns_servers
                 .iter()
-                .filter(|server| !is_local_dns_address(&tunnel, server))
+                .filter(|server| !is_local_dns_address(tunnel, server))
             {
                 let chain = if server.is_ipv4() {
                     &self.mangle_chain_v4
@@ -594,8 +594,8 @@ impl<'a> PolicyBatch<'a> {
                 dns_servers,
             } => {
                 self.add_allow_tunnel_endpoint_rules(peer_endpoint);
-                self.add_allow_dns_rules(tunnel, &dns_servers, TransportProtocol::Udp)?;
-                self.add_allow_dns_rules(tunnel, &dns_servers, TransportProtocol::Tcp)?;
+                self.add_allow_dns_rules(tunnel, dns_servers, TransportProtocol::Udp)?;
+                self.add_allow_dns_rules(tunnel, dns_servers, TransportProtocol::Tcp)?;
                 // Important to block DNS *before* we allow the tunnel and allow LAN. So DNS
                 // can't leak to the wrong IPs in the tunnel or on the LAN.
                 self.add_drop_dns_rule();
@@ -945,7 +945,7 @@ fn allow_interface_rule<'a>(
     direction: Direction,
     iface: &str,
 ) -> Result<Rule<'a>> {
-    let mut rule = Rule::new(&chain);
+    let mut rule = Rule::new(chain);
     check_iface(&mut rule, direction, iface)?;
     add_verdict(&mut rule, &Verdict::Accept);
 
diff --git a/talpid-core/src/firewall/mod.rs b/talpid-core/src/firewall/mod.rs
index a72ad65b1b..c2898fe05f 100644
--- a/talpid-core/src/firewall/mod.rs
+++ b/talpid-core/src/firewall/mod.rs
@@ -84,7 +84,7 @@ const ROOT_UID: u32 = 0;
 #[cfg(any(all(unix, not(target_os = "android")), target_os = "windows"))]
 /// Returns whether an address belongs to a private subnet.
 pub fn is_local_address(address: &IpAddr) -> bool {
-    let address = address.clone();
+    let address = *address;
     (&*ALLOWED_LAN_NETS)
         .iter()
         .chain(&*LOOPBACK_NETS)
diff --git a/talpid-core/src/mktemp.rs b/talpid-core/src/mktemp.rs
index b5b5ec0719..9e5709ce1f 100644
--- a/talpid-core/src/mktemp.rs
+++ b/talpid-core/src/mktemp.rs
@@ -25,7 +25,7 @@ impl TempFile {
 
 impl AsRef<Path> for TempFile {
     fn as_ref(&self) -> &Path {
-        &self.path.as_path()
+        self.path.as_path()
     }
 }
 
diff --git a/talpid-core/src/process/openvpn.rs b/talpid-core/src/process/openvpn.rs
index 4dd594a2f2..0c4a9580f8 100644
--- a/talpid-core/src/process/openvpn.rs
+++ b/talpid-core/src/process/openvpn.rs
@@ -307,10 +307,10 @@ impl OpenVpnCommand {
     }
 
     fn tls_cipher_arguments() -> Vec<String> {
-        let mut args = vec![];
-        args.push("--tls-ciphersuites".to_owned());
-        args.push(ALLOWED_TLS1_3_CIPHERS.join(":"));
-        args
+        vec![
+            "--tls-ciphersuites".to_owned(),
+            ALLOWED_TLS1_3_CIPHERS.join(":"),
+        ]
     }
 
     fn remote_arguments(&self) -> Vec<String> {
diff --git a/talpid-core/src/routing/linux.rs b/talpid-core/src/routing/linux.rs
index 2a34de42cd..092ad6f52a 100644
--- a/talpid-core/src/routing/linux.rs
+++ b/talpid-core/src/routing/linux.rs
@@ -319,7 +319,7 @@ impl RouteManagerImpl {
 
     async fn cleanup_routes(&mut self) {
         for route in self.added_routes.drain().collect::<Vec<_>>().iter() {
-            if let Err(e) = self.delete_route_if_exists(&route).await {
+            if let Err(e) = self.delete_route_if_exists(route).await {
                 log::error!("Failed to remove route: {}: {}", route, e);
             }
         }
@@ -446,7 +446,7 @@ impl RouteManagerImpl {
         for nla in msg.nlas.iter() {
             match nla {
                 RouteNla::Oif(device_idx) => {
-                    match self.iface_map.get(&device_idx) {
+                    match self.iface_map.get(device_idx) {
                         Some(route_device) => {
                             if !route_device.is_loopback() {
                                 device = Some(route_device);
@@ -465,11 +465,11 @@ impl RouteManagerImpl {
                 }
 
                 RouteNla::Via(addr) => {
-                    node_addr = Self::parse_ip(&addr).map(Some)?;
+                    node_addr = Self::parse_ip(addr).map(Some)?;
                 }
 
                 RouteNla::Destination(addr) => {
-                    prefix = Self::parse_ip(&addr).and_then(|ip| {
+                    prefix = Self::parse_ip(addr).and_then(|ip| {
                         ipnetwork::IpNetwork::new(ip, destination_length)
                             .map_err(Error::InvalidNetworkPrefix)
                     })?;
@@ -477,7 +477,7 @@ impl RouteManagerImpl {
 
                 // gateway NLAs indicate that this is actually a default route
                 RouteNla::Gateway(gateway_ip) => {
-                    gateway = Self::parse_ip(&gateway_ip).map(Some)?;
+                    gateway = Self::parse_ip(gateway_ip).map(Some)?;
                 }
 
                 RouteNla::Priority(priority) => {
@@ -496,17 +496,16 @@ impl RouteManagerImpl {
         }
 
         let node = Node {
-            ip: node_addr.or(gateway.into()),
+            ip: node_addr.or(gateway),
             device: device.map(|dev| dev.name.clone()),
         };
 
-        let result = Ok(Some(Route {
+        Ok(Some(Route {
             node,
             prefix,
             metric,
             table_id,
-        }));
-        result
+        }))
     }
 
     fn map_interface(msg: LinkMessage) -> Option<(u32, NetworkInterface)> {
@@ -544,11 +543,9 @@ impl RouteManagerImpl {
 
     async fn delete_route_if_exists(&self, route: &Route) -> Result<()> {
         if let Err(error) = self.delete_route(route).await {
-            if let Error::NetlinkError(netlink_error) = &error {
-                if let rtnetlink::Error::NetlinkError(msg) = &netlink_error {
-                    if msg.code == -libc::ESRCH {
-                        return Ok(());
-                    }
+            if let Error::NetlinkError(rtnetlink::Error::NetlinkError(msg)) = &error {
+                if msg.code == -libc::ESRCH {
+                    return Ok(());
                 }
             }
             Err(error)
diff --git a/talpid-core/src/routing/mod.rs b/talpid-core/src/routing/mod.rs
index 3e461f3470..1eb02a206b 100644
--- a/talpid-core/src/routing/mod.rs
+++ b/talpid-core/src/routing/mod.rs
@@ -86,7 +86,7 @@ impl RequiredRoute {
             node: node.into(),
             prefix,
             #[cfg(target_os = "linux")]
-            table_id: u32::from(crate::linux::TUNNEL_TABLE_ID),
+            table_id: crate::linux::TUNNEL_TABLE_ID,
         }
     }
 
diff --git a/talpid-core/src/split_tunnel/linux.rs b/talpid-core/src/split_tunnel/linux.rs
index d11306a646..2ba63dda9e 100644
--- a/talpid-core/src/split_tunnel/linux.rs
+++ b/talpid-core/src/split_tunnel/linux.rs
@@ -74,7 +74,7 @@ impl PidManager {
 
         let net_cls_dir = env::var(NET_CLS_DIR_OVERRIDE_ENV_VAR)
             .map(PathBuf::from)
-            .unwrap_or(PathBuf::from(DEFAULT_NET_CLS_DIR));
+            .unwrap_or_else(|_| PathBuf::from(DEFAULT_NET_CLS_DIR));
 
         if !net_cls_dir.exists() {
             fs::create_dir_all(&net_cls_dir).map_err(Error::CreateCGroup)?;
diff --git a/talpid-core/src/tunnel/mod.rs b/talpid-core/src/tunnel/mod.rs
index bafc839cf6..5da3c092a4 100644
--- a/talpid-core/src/tunnel/mod.rs
+++ b/talpid-core/src/tunnel/mod.rs
@@ -121,13 +121,13 @@ impl TunnelMonitor {
             + Sync
             + 'static,
     {
-        Self::ensure_ipv6_can_be_used_if_enabled(&tunnel_parameters)?;
-        let log_file = Self::prepare_tunnel_log_file(&tunnel_parameters, log_dir)?;
+        Self::ensure_ipv6_can_be_used_if_enabled(tunnel_parameters)?;
+        let log_file = Self::prepare_tunnel_log_file(tunnel_parameters, log_dir)?;
 
         match tunnel_parameters {
             #[cfg(not(target_os = "android"))]
             TunnelParameters::OpenVpn(config) => runtime.block_on(Self::start_openvpn_tunnel(
-                &config,
+                config,
                 log_file,
                 resource_dir,
                 on_event,
diff --git a/talpid-core/src/tunnel/openvpn/mod.rs b/talpid-core/src/tunnel/openvpn/mod.rs
index d9ddf8dd9a..910d5bb49e 100644
--- a/talpid-core/src/tunnel/openvpn/mod.rs
+++ b/talpid-core/src/tunnel/openvpn/mod.rs
@@ -274,16 +274,14 @@ impl OpenVpnMonitor<OpenVpnCommand> {
         let proxy_auth_file =
             Self::create_proxy_auth_file(&params.proxy).map_err(Error::CredentialsWriteError)?;
         let user_pass_file_path = user_pass_file.to_path_buf();
-        let proxy_auth_file_path = match proxy_auth_file {
-            Some(ref file) => Some(file.to_path_buf()),
-            _ => None,
-        };
+        let proxy_auth_file_path = proxy_auth_file.as_ref().map(|file| file.to_path_buf());
 
-        let log_dir: Option<PathBuf> = if let Some(ref log_path) = log_path {
-            Some(log_path.parent().expect("log_path has no parent").into())
-        } else {
-            None
-        };
+        let log_dir = log_path.as_ref().map(|log_path| {
+            log_path
+                .parent()
+                .expect("log_path has no parent")
+                .to_path_buf()
+        });
 
         let proxy_resources = proxy::ProxyResourceData {
             resource_dir: resource_dir.to_path_buf(),
@@ -398,7 +396,7 @@ impl<C: OpenVpnBuilder + Send + 'static> OpenVpnMonitor<C> {
         let wintun = Arc::new(wintun);
 
         cmd.plugin(plugin_path, vec![ipc_path])
-            .log(log_path.as_ref().map(|p| p.as_path()));
+            .log(log_path.as_deref());
         let (spawn_task, abort_spawn) = futures::future::abortable(Self::prepare_process(
             cmd,
             #[cfg(windows)]
@@ -946,14 +944,14 @@ mod event_server {
         ) -> std::result::Result<TunnelMetadata, tonic::Status> {
             let tunnel_alias = env
                 .get("dev")
-                .ok_or(tonic::Status::invalid_argument("missing tunnel alias"))?
+                .ok_or_else(|| tonic::Status::invalid_argument("missing tunnel alias"))?
                 .to_string();
 
             let mut ips = vec![env
                 .get("ifconfig_local")
-                .ok_or(tonic::Status::invalid_argument(
-                    "missing \"ifconfig_local\" in up event",
-                ))?
+                .ok_or_else(|| {
+                    tonic::Status::invalid_argument("missing \"ifconfig_local\" in up event")
+                })?
                 .parse()
                 .map_err(|_| tonic::Status::invalid_argument("Invalid tunnel IPv4 address"))?];
             if let Some(ipv6_address) = env.get("ifconfig_ipv6_local") {
@@ -965,9 +963,9 @@ mod event_server {
             }
             let ipv4_gateway = env
                 .get("route_vpn_gateway")
-                .ok_or(tonic::Status::invalid_argument(
-                    "No \"route_vpn_gateway\" in tunnel up event",
-                ))?
+                .ok_or_else(|| {
+                    tonic::Status::invalid_argument("No \"route_vpn_gateway\" in tunnel up event")
+                })?
                 .parse()
                 .map_err(|_| {
                     tonic::Status::invalid_argument("Invalid tunnel gateway IPv4 address")
diff --git a/talpid-core/src/tunnel/wireguard/connectivity_check.rs b/talpid-core/src/tunnel/wireguard/connectivity_check.rs
index bcb28d7c17..c48f816f2e 100644
--- a/talpid-core/src/tunnel/wireguard/connectivity_check.rs
+++ b/talpid-core/src/tunnel/wireguard/connectivity_check.rs
@@ -382,10 +382,7 @@ impl ConnState {
     }
 
     pub fn connected(&self) -> bool {
-        match self {
-            ConnState::Connected { .. } => true,
-            _ => false,
-        }
+        matches!(self, ConnState::Connected { .. })
     }
 }
 
diff --git a/talpid-core/src/tunnel/wireguard/logging.rs b/talpid-core/src/tunnel/wireguard/logging.rs
index e795326854..1a7a52ed8b 100644
--- a/talpid-core/src/tunnel/wireguard/logging.rs
+++ b/talpid-core/src/tunnel/wireguard/logging.rs
@@ -36,7 +36,8 @@ static NULL_DEVICE: &str = "NUL";
 static NULL_DEVICE: &str = "/dev/null";
 
 fn create_log_file(log_path: Option<&Path>) -> Result<fs::File, Error> {
-    fs::File::create(log_path.unwrap_or(NULL_DEVICE.as_ref())).map_err(Error::PrepareLogFileError)
+    fs::File::create(log_path.unwrap_or_else(|| NULL_DEVICE.as_ref()))
+        .map_err(Error::PrepareLogFileError)
 }
 
 pub fn clean_up_logging(ordinal: u32) {
diff --git a/talpid-core/src/tunnel/wireguard/mod.rs b/talpid-core/src/tunnel/wireguard/mod.rs
index 3d0de8ba5c..b5ee282b7e 100644
--- a/talpid-core/src/tunnel/wireguard/mod.rs
+++ b/talpid-core/src/tunnel/wireguard/mod.rs
@@ -230,7 +230,7 @@ impl WireguardMonitor {
             #[cfg(target_os = "windows")]
             setup_done_tx,
         )?;
-        let iface_name = tunnel.get_interface_name().to_string();
+        let iface_name = tunnel.get_interface_name();
 
         let event_callback = Box::new(on_event.clone());
         let (pinger_tx, pinger_rx) = sync_mpsc::channel();
@@ -544,7 +544,7 @@ impl WireguardMonitor {
         log::debug!("Using userspace WireGuard implementation");
         Ok(Box::new(
             WgGoTunnel::start_tunnel(
-                &config,
+                config,
                 log_path,
                 #[cfg(not(windows))]
                 tun_provider,
@@ -591,9 +591,7 @@ impl WireguardMonitor {
 
     /// Returns routes to the peer endpoints (through the physical interface).
     #[cfg_attr(target_os = "linux", allow(unused_variables))]
-    fn get_endpoint_routes<'a>(
-        endpoints: &'a [IpAddr],
-    ) -> impl Iterator<Item = RequiredRoute> + 'a {
+    fn get_endpoint_routes(endpoints: &[IpAddr]) -> impl Iterator<Item = RequiredRoute> + '_ {
         #[cfg(target_os = "linux")]
         {
             // No need due to policy based routing.
diff --git a/talpid-core/src/tunnel/wireguard/stats.rs b/talpid-core/src/tunnel/wireguard/stats.rs
index e9a22a906a..bda8af2e1f 100644
--- a/talpid-core/src/tunnel/wireguard/stats.rs
+++ b/talpid-core/src/tunnel/wireguard/stats.rs
@@ -72,20 +72,19 @@ impl Stats {
                 _ => continue,
             }
 
-            match (peer, tx_bytes, rx_bytes) {
-                (Some(peer_val), Some(tx_bytes_val), Some(rx_bytes_val)) => {
-                    map.insert(
-                        peer_val,
-                        Self {
-                            tx_bytes: tx_bytes_val,
-                            rx_bytes: rx_bytes_val,
-                        },
-                    );
-                    peer = None;
-                    tx_bytes = None;
-                    rx_bytes = None;
-                }
-                _ => (),
+            if let (Some(peer_val), Some(tx_bytes_val), Some(rx_bytes_val)) =
+                (peer, tx_bytes, rx_bytes)
+            {
+                map.insert(
+                    peer_val,
+                    Self {
+                        tx_bytes: tx_bytes_val,
+                        rx_bytes: rx_bytes_val,
+                    },
+                );
+                peer = None;
+                tx_bytes = None;
+                rx_bytes = None;
             }
         }
         Ok(map)
diff --git a/talpid-core/src/tunnel/wireguard/wireguard_kernel/netlink_tunnel.rs b/talpid-core/src/tunnel/wireguard/wireguard_kernel/netlink_tunnel.rs
index 109ae75367..b1159bb6de 100644
--- a/talpid-core/src/tunnel/wireguard/wireguard_kernel/netlink_tunnel.rs
+++ b/talpid-core/src/tunnel/wireguard/wireguard_kernel/netlink_tunnel.rs
@@ -72,7 +72,7 @@ impl Tunnel for NetlinkTunnel {
                     return Ok(name);
                 }
             }
-            return Err(Error::Truncated);
+            Err(Error::Truncated)
         });
 
         match result {
@@ -103,15 +103,13 @@ impl Tunnel for NetlinkTunnel {
     fn get_tunnel_stats(&self) -> std::result::Result<StatsMap, TunnelError> {
         let mut wg = self.netlink_connections.wg_handle.clone();
         let interface_index = self.interface_index;
-        let result = self.tokio_handle.block_on(async move {
+        self.tokio_handle.block_on(async move {
             let device = wg.get_by_index(interface_index).await.map_err(|err| {
                 log::error!("Failed to fetch WireGuard device config: {}", err);
                 TunnelError::GetConfigError
             })?;
             Ok(Stats::parse_device_message(&device))
-        });
-
-        result
+        })
     }
 
     fn set_config(
diff --git a/talpid-core/src/tunnel/wireguard/wireguard_kernel/nl_message.rs b/talpid-core/src/tunnel/wireguard/wireguard_kernel/nl_message.rs
index 1fc5b36e9f..cf206f501a 100644
--- a/talpid-core/src/tunnel/wireguard/wireguard_kernel/nl_message.rs
+++ b/talpid-core/src/tunnel/wireguard/wireguard_kernel/nl_message.rs
@@ -47,13 +47,13 @@ impl NetlinkSerializable<NetlinkControlMessage> for NetlinkControlMessage {
 
     fn serialize(&self, mut buffer: &mut [u8]) {
         let _ = buffer.write(&[self.cmd, self.version, 0u8, 0u8]).unwrap();
-        self.nlas.as_slice().emit(&mut buffer);
+        self.nlas.as_slice().emit(buffer);
     }
 }
 
-impl Into<NetlinkPayload<NetlinkControlMessage>> for NetlinkControlMessage {
-    fn into(self) -> NetlinkPayload<NetlinkControlMessage> {
-        NetlinkPayload::InnerMessage(self)
+impl From<NetlinkControlMessage> for NetlinkPayload<NetlinkControlMessage> {
+    fn from(msg: NetlinkControlMessage) -> Self {
+        NetlinkPayload::InnerMessage(msg)
     }
 }
 
diff --git a/talpid-core/src/tunnel/wireguard/wireguard_kernel/parsers.rs b/talpid-core/src/tunnel/wireguard/wireguard_kernel/parsers.rs
index b34c82d342..f08b2d6dfa 100644
--- a/talpid-core/src/tunnel/wireguard/wireguard_kernel/parsers.rs
+++ b/talpid-core/src/tunnel/wireguard/wireguard_kernel/parsers.rs
@@ -54,7 +54,7 @@ pub fn parse_inet_sockaddr(buffer: &[u8]) -> Result<InetAddr, DecodeError> {
     match NativeEndian::read_u16(buffer) {
         AF_INET => unsafe {
             let sockaddr: *const libc::sockaddr_in = ptr as *const _;
-            Ok(InetAddr::V4(*sockaddr).into())
+            Ok(InetAddr::V4(*sockaddr))
         },
         AF_INET6 => unsafe {
             let sockaddr: *const libc::sockaddr_in6 = ptr as *const _;
diff --git a/talpid-core/src/tunnel/wireguard/wireguard_kernel/wg_message.rs b/talpid-core/src/tunnel/wireguard/wireguard_kernel/wg_message.rs
index dd17bc0cb3..0beac84f83 100644
--- a/talpid-core/src/tunnel/wireguard/wireguard_kernel/wg_message.rs
+++ b/talpid-core/src/tunnel/wireguard/wireguard_kernel/wg_message.rs
@@ -161,12 +161,13 @@ impl NetlinkSerializable<DeviceMessage> for DeviceMessage {
     fn serialize(&self, mut buffer: &mut [u8]) {
         let command_buf = [self.command, WG_GENL_VERSION, 0u8, 0u8];
         let _ = buffer.write(&command_buf).unwrap();
-        self.nlas.as_slice().emit(&mut buffer)
+        self.nlas.as_slice().emit(buffer)
     }
 }
-impl Into<NetlinkPayload<DeviceMessage>> for DeviceMessage {
-    fn into(self) -> NetlinkPayload<DeviceMessage> {
-        NetlinkPayload::InnerMessage(self)
+
+impl From<DeviceMessage> for NetlinkPayload<DeviceMessage> {
+    fn from(msg: DeviceMessage) -> Self {
+        NetlinkPayload::InnerMessage(msg)
     }
 }
 
@@ -250,7 +251,7 @@ impl Nla for DeviceNla {
                 peers.as_slice().emit(buffer);
             }
             Unspec(payload) => {
-                let _ = buffer.write(&payload).expect("Failed to write ");
+                let _ = buffer.write(payload).expect("Failed to write ");
             }
         }
     }
@@ -266,8 +267,8 @@ impl<'a, T: AsRef<[u8]> + 'a + ?Sized + core::fmt::Debug> Parseable<NlaBuffer<&'
         let nla = match kind {
             WGDEVICE_A_IFINDEX => IfIndex(parsers::parse_u32(value)?),
             WGDEVICE_A_IFNAME => IfName(parsers::parse_cstring(value)?),
-            WGDEVICE_A_PRIVATE_KEY => PrivateKey(parsers::parse_wg_key(value)?.into()),
-            WGDEVICE_A_PUBLIC_KEY => PublicKey(parsers::parse_wg_key(value)?.into()),
+            WGDEVICE_A_PRIVATE_KEY => PrivateKey(parsers::parse_wg_key(value)?),
+            WGDEVICE_A_PUBLIC_KEY => PublicKey(parsers::parse_wg_key(value)?),
             WGDEVICE_A_FLAGS => Flags(parsers::parse_u32(value)?),
             WGDEVICE_A_LISTEN_PORT => ListenPort(parsers::parse_u16(value)?),
             WGDEVICE_A_FWMARK => Fwmark(parsers::parse_u32(value)?),
@@ -276,7 +277,7 @@ impl<'a, T: AsRef<[u8]> + 'a + ?Sized + core::fmt::Debug> Parseable<NlaBuffer<&'
                     .map(|nla_bytes| {
                         let buf = nla_bytes?;
                         let val = buf.value();
-                        PeerMessage::parse(&val)
+                        PeerMessage::parse(val)
                     })
                     .collect::<Result<Vec<PeerMessage>, DecodeError>>()?;
                 Peers(peers)
@@ -414,7 +415,7 @@ impl Nla for PeerNla {
             AllowedIps(ips) => ips.as_slice().emit(buffer),
             Unspec(payload) => {
                 let _ = buffer
-                    .write(&payload)
+                    .write(payload)
                     .expect("Buffer too small for unspecified payload");
             }
         }
@@ -426,8 +427,8 @@ impl<'a, T: AsRef<[u8]> + 'a + ?Sized> Parseable<NlaBuffer<&'a T>> for PeerNla {
         use PeerNla::*;
         let value = buf.value();
         let nla = match buf.kind() {
-            WGPEER_A_PUBLIC_KEY => PublicKey(parsers::parse_wg_key(value)?.into()),
-            WGPEER_A_PRESHARED_KEY => PresharedKey(parsers::parse_wg_key(value)?.into()),
+            WGPEER_A_PUBLIC_KEY => PublicKey(parsers::parse_wg_key(value)?),
+            WGPEER_A_PRESHARED_KEY => PresharedKey(parsers::parse_wg_key(value)?),
             WGPEER_A_FLAGS => Flags(parsers::parse_u32(value)?),
             WGPEER_A_ENDPOINT => Endpoint(parsers::parse_inet_sockaddr(value)?),
             WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL => {
@@ -469,7 +470,7 @@ impl From<&IpNetwork> for AllowedIpMessage {
         AllowedIpMessage(vec![
             AddressFamily(address_family as u16),
             CidrMask(ip.prefix()),
-            IpAddr(ip.ip().into()),
+            IpAddr(ip.ip()),
         ])
     }
 }
@@ -540,7 +541,7 @@ impl Nla for AllowedIpNla {
             CidrMask(cidr_mask) => buffer[0] = *cidr_mask,
             Unspec(payload) => {
                 let _ = buffer
-                    .write(&payload)
+                    .write(payload)
                     .expect("Buffer too small for unspec payload");
             }
         }
diff --git a/talpid-core/src/tunnel_state_machine/connected_state.rs b/talpid-core/src/tunnel_state_machine/connected_state.rs
index 80e5e28957..e166f15986 100644
--- a/talpid-core/src/tunnel_state_machine/connected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connected_state.rs
@@ -87,8 +87,7 @@ impl ConnectedState {
         if let Some(ref servers) = shared_values.dns_servers {
             servers.clone()
         } else {
-            let mut dns_ips = vec![];
-            dns_ips.push(self.metadata.ipv4_gateway.into());
+            let mut dns_ips = vec![self.metadata.ipv4_gateway.into()];
             if let Some(ipv6_gateway) = self.metadata.ipv6_gateway {
                 dns_ips.push(ipv6_gateway.into());
             };
diff --git a/talpid-core/src/tunnel_state_machine/disconnected_state.rs b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
index fa91284f6b..7b54384780 100644
--- a/talpid-core/src/tunnel_state_machine/disconnected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
@@ -28,13 +28,11 @@ impl DisconnectedState {
                 dns_redirect_port: shared_values.filtering_resolver.listening_port(),
             };
 
-            let firewall_result = shared_values.firewall.apply_policy(policy).map_err(|e| {
+            shared_values.firewall.apply_policy(policy).map_err(|e| {
                 e.display_chain_with_msg(
                     "Failed to apply blocking firewall policy for disconnected state",
                 )
-            });
-
-            firewall_result
+            })
         } else if should_reset_firewall {
             shared_values
                 .firewall
diff --git a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
index 2a14d881d6..8e7e85fd36 100644
--- a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
@@ -193,12 +193,10 @@ impl TunnelState for DisconnectingState {
         let result = if self.tunnel_close_event.is_terminated() {
             if commands.is_done() {
                 EventResult::Close(Ok(None))
+            } else if let Ok(command) = commands.get_mut().try_next() {
+                EventResult::Command(command)
             } else {
-                if let Ok(command) = commands.get_mut().try_next() {
-                    EventResult::Command(command)
-                } else {
-                    EventResult::Close(Ok(None))
-                }
+                EventResult::Close(Ok(None))
             }
         } else {
             runtime.block_on(async {
diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs
index fc1a073ccb..3552eeab61 100644
--- a/talpid-core/src/tunnel_state_machine/mod.rs
+++ b/talpid-core/src/tunnel_state_machine/mod.rs
@@ -456,7 +456,7 @@ impl SharedTunnelStateValues {
         dns_servers: Option<Vec<IpAddr>>,
     ) -> Result<bool, ErrorStateCause> {
         if self.dns_servers != dns_servers {
-            self.dns_servers = dns_servers.clone();
+            self.dns_servers = dns_servers;
 
             #[cfg(target_os = "android")]
             {
@@ -464,7 +464,7 @@ impl SharedTunnelStateValues {
                     .tun_provider
                     .lock()
                     .unwrap()
-                    .set_dns_servers(dns_servers)
+                    .set_dns_servers(self.dns_servers.clone())
                 {
                     log::error!(
                         "{}",
diff --git a/talpid-dbus/src/systemd_resolved.rs b/talpid-dbus/src/systemd_resolved.rs
index 99b73980d8..d664872557 100644
--- a/talpid-dbus/src/systemd_resolved.rs
+++ b/talpid-dbus/src/systemd_resolved.rs
@@ -199,7 +199,7 @@ impl SystemdResolved {
     /// it returns false, otherwise it checks whether the static stub file points to the local
     /// resolver. If not, the file has been _meddled_ with, so we can't trust it.
     fn resolv_conf_is_static_stub(link_path: &Path) -> Result<bool> {
-        if link_path == &STATIC_STUB_PATH.as_ref() {
+        if link_path == AsRef::<Path>::as_ref(STATIC_STUB_PATH) {
             let points_to_localhost = fs::read_to_string(link_path)
                 .map(|contents| {
                     let parts = contents.trim().split(' ');
diff --git a/talpid-openvpn-plugin/src/lib.rs b/talpid-openvpn-plugin/src/lib.rs
index 943ee8dabc..0f9bb914a6 100644
--- a/talpid-openvpn-plugin/src/lib.rs
+++ b/talpid-openvpn-plugin/src/lib.rs
@@ -94,8 +94,8 @@ fn openvpn_event(
 
     let parsed_env = openvpn_plugin::ffi::parse::env_utf8(&env).map_err(Error::ParseEnvFailed)?;
 
-    let mut ctx = handle
-        .lock()
+    let ctx = handle
+        .get_mut()
         .expect("failed to obtain mutex for EventProcessor");
     if let Some(processor) = ctx.as_mut() {
         match processor.process_event(event, parsed_env) {
diff --git a/talpid-types/src/net/mod.rs b/talpid-types/src/net/mod.rs
index a35c227ddd..16a30bc57d 100644
--- a/talpid-types/src/net/mod.rs
+++ b/talpid-types/src/net/mod.rs
@@ -41,7 +41,7 @@ impl TunnelParameters {
                 endpoint: params
                     .connection
                     .get_exit_endpoint()
-                    .unwrap_or(params.connection.get_endpoint()),
+                    .unwrap_or_else(|| params.connection.get_endpoint()),
                 proxy: None,
                 obfuscation: params.obfuscation.as_ref().map(ObfuscationEndpoint::from),
                 entry_endpoint: params
@@ -64,7 +64,7 @@ impl TunnelParameters {
                 .obfuscation
                 .as_ref()
                 .map(Self::get_obfuscator_endpoint)
-                .unwrap_or(params.connection.get_endpoint()),
+                .unwrap_or_else(|| params.connection.get_endpoint()),
         }
     }
 
diff --git a/tunnel-obfuscation/src/main.rs b/tunnel-obfuscation/src/main.rs
index db613f773b..cdc1046601 100644
--- a/tunnel-obfuscation/src/main.rs
+++ b/tunnel-obfuscation/src/main.rs
@@ -16,8 +16,8 @@ async fn main() {
     }
 }
 
-async fn instantiate_requested(obfuscator_type: &String) -> Box<dyn Obfuscator> {
-    match obfuscator_type.as_str() {
+async fn instantiate_requested(obfuscator_type: &str) -> Box<dyn Obfuscator> {
+    match obfuscator_type {
         "udp2tcp" => {
             let settings = Udp2TcpSettings {
                 peer: SocketAddr::new("127.0.0.1".parse().unwrap(), 3030),