Apply clippy --fix fixes

This commit does not contain everything that `cargo clippy --fix`
changed on Windows. But the least controversial and simplest subset.
The remaining fixes I felt could use some manual cleanup also.

28 files changed, 112 insertions, 134 deletions

diff --git a/mullvad-daemon/src/exception_logging/win.rs b/mullvad-daemon/src/exception_logging/win.rs
index bada89af8e..343b04a59c 100644
--- a/mullvad-daemon/src/exception_logging/win.rs
+++ b/mullvad-daemon/src/exception_logging/win.rs
@@ -29,7 +29,7 @@ use windows_sys::Win32::{
 };
 
 /// Minidump file name
-const MINIDUMP_FILENAME: &'static str = "DAEMON.DMP";
+const MINIDUMP_FILENAME: &str = "DAEMON.DMP";
 
 #[repr(C)]
 #[allow(dead_code)]
@@ -177,7 +177,7 @@ unsafe extern "system" fn logging_exception_filter(info: *const EXCEPTION_POINTE
         }
     };
 
-    match generate_minidump(&dump_path, &info) {
+    match generate_minidump(&dump_path, info) {
         Ok(()) => log::info!("Wrote Minidump to {}.", dump_path.to_string_lossy()),
         Err(e) => {
             log::error!(
@@ -297,7 +297,7 @@ fn find_address_module(address: *mut c_void) -> io::Result<Option<ModuleInfo>> {
 
     for module in snap.modules() {
         let module = module?;
-        let module_end_address = unsafe { module.base_address.offset(module.size as isize) };
+        let module_end_address = unsafe { module.base_address.add(module.size) };
         if (address as *const u8) >= module.base_address
             && (address as *const u8) < module_end_address
         {
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 0561d645ca..203f8bc150 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -656,7 +656,7 @@ where
                 .split_tunnel
                 .apps
                 .iter()
-                .map(|s| OsString::from(s))
+                .map(OsString::from)
                 .collect()
         } else {
             vec![]
@@ -1625,7 +1625,7 @@ where
 
         if new_state || new_state != settings.split_tunnel.enable_exclusions {
             let tunnel_list = if new_state {
-                new_list.map(|s| OsString::from(s)).collect()
+                new_list.map(OsString::from).collect()
             } else {
                 vec![]
             };
diff --git a/mullvad-daemon/src/logging.rs b/mullvad-daemon/src/logging.rs
index 41edf62232..719f273528 100644
--- a/mullvad-daemon/src/logging.rs
+++ b/mullvad-daemon/src/logging.rs
@@ -174,5 +174,5 @@ fn escape_newlines(text: String) -> String {
 
 #[cfg(windows)]
 fn escape_newlines(text: String) -> String {
-    text.replace("\n", LINE_SEPARATOR)
+    text.replace('\n', LINE_SEPARATOR)
 }
diff --git a/mullvad-daemon/src/main.rs b/mullvad-daemon/src/main.rs
index 2572821e0d..a36ed28576 100644
--- a/mullvad-daemon/src/main.rs
+++ b/mullvad-daemon/src/main.rs
@@ -111,16 +111,14 @@ fn get_log_dir(config: &cli::Config) -> Result<Option<PathBuf>, String> {
 async fn run_platform(config: &cli::Config, log_dir: Option<PathBuf>) -> Result<(), String> {
     if config.run_as_service {
         system_service::run()
-    } else {
-        if config.register_service {
-            let install_result = system_service::install_service().map_err(|e| e.display_chain());
-            if install_result.is_ok() {
-                println!("Installed the service.");
-            }
-            install_result
-        } else {
-            run_standalone(log_dir).await
+    } else if config.register_service {
+        let install_result = system_service::install_service().map_err(|e| e.display_chain());
+        if install_result.is_ok() {
+            println!("Installed the service.");
         }
+        install_result
+    } else {
+        run_standalone(log_dir).await
     }
 }
 
diff --git a/mullvad-daemon/src/migrations/mod.rs b/mullvad-daemon/src/migrations/mod.rs
index f2edfc1147..5d93045b04 100644
--- a/mullvad-daemon/src/migrations/mod.rs
+++ b/mullvad-daemon/src/migrations/mod.rs
@@ -257,7 +257,7 @@ mod windows {
             return Ok(false);
         };
 
-        let windows_old_dir = Path::new(&prefix).join(&root).join(MIGRATION_DIRNAME);
+        let windows_old_dir = Path::new(&prefix).join(root).join(MIGRATION_DIRNAME);
         let source_settings_dir = Path::new(&windows_old_dir).join(&components);
         if !source_settings_dir.exists() {
             return Ok(false);
diff --git a/mullvad-daemon/src/system_service.rs b/mullvad-daemon/src/system_service.rs
index 1a7f3ee1fd..7b0a903324 100644
--- a/mullvad-daemon/src/system_service.rs
+++ b/mullvad-daemon/src/system_service.rs
@@ -32,8 +32,8 @@ use windows_sys::Win32::{
     },
 };
 
-static SERVICE_NAME: &'static str = "MullvadVPN";
-static SERVICE_DISPLAY_NAME: &'static str = "Mullvad VPN Service";
+static SERVICE_NAME: &str = "MullvadVPN";
+static SERVICE_DISPLAY_NAME: &str = "Mullvad VPN Service";
 static SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;
 
 const SERVICE_RECOVERY_LAST_RESTART_DELAY: Duration = Duration::from_secs(60 * 10);
diff --git a/talpid-core/src/dns/windows/dnsapi.rs b/talpid-core/src/dns/windows/dnsapi.rs
index e48f37258e..f315aba3f4 100644
--- a/talpid-core/src/dns/windows/dnsapi.rs
+++ b/talpid-core/src/dns/windows/dnsapi.rs
@@ -50,9 +50,7 @@ pub enum Error {
 }
 
 pub fn flush_resolver_cache() -> Result<(), Error> {
-    DNSAPI_HANDLE
-        .get_or_try_init(|| DnsApi::new())?
-        .flush_cache()
+    DNSAPI_HANDLE.get_or_try_init(DnsApi::new)?.flush_cache()
 }
 
 struct DnsApi {
diff --git a/talpid-core/src/dns/windows/iphlpapi.rs b/talpid-core/src/dns/windows/iphlpapi.rs
index 6f33cf3cf9..98f5034060 100644
--- a/talpid-core/src/dns/windows/iphlpapi.rs
+++ b/talpid-core/src/dns/windows/iphlpapi.rs
@@ -105,7 +105,7 @@ pub struct DnsMonitor {
 
 impl DnsMonitor {
     pub fn is_supported() -> bool {
-        IPHLPAPI_HANDLE.get_or_try_init(|| IphlpApi::new()).is_ok()
+        IPHLPAPI_HANDLE.get_or_try_init(IphlpApi::new).is_ok()
     }
 }
 
@@ -173,7 +173,7 @@ fn set_interface_dns_servers<T: ToString>(
     servers: &[T],
     flags: u32,
 ) -> Result<(), Error> {
-    let iphlpapi = IPHLPAPI_HANDLE.get_or_try_init(|| IphlpApi::new())?;
+    let iphlpapi = IPHLPAPI_HANDLE.get_or_try_init(IphlpApi::new)?;
 
     // Create comma-separated nameserver list
     let nameservers = servers
diff --git a/talpid-core/src/firewall/windows.rs b/talpid-core/src/firewall/windows.rs
index fa40fdcb42..6f727f543b 100644
--- a/talpid-core/src/firewall/windows.rs
+++ b/talpid-core/src/firewall/windows.rs
@@ -80,7 +80,7 @@ impl Firewall {
         unsafe {
             WinFw_InitializeBlocked(
                 WINFW_TIMEOUT_SECONDS,
-                &cfg,
+                cfg,
                 &allowed_endpoint.as_endpoint(),
                 Some(log_sink),
                 LOGGING_CONTEXT.as_ptr(),
@@ -105,7 +105,7 @@ impl Firewall {
 
                 self.set_connecting_state(
                     &peer_endpoint,
-                    &cfg,
+                    cfg,
                     &tunnel,
                     &WinFwAllowedEndpointContainer::from(allowed_endpoint).as_endpoint(),
                     &allowed_tunnel_traffic,
@@ -120,7 +120,7 @@ impl Firewall {
                 relay_client,
             } => {
                 let cfg = &WinFwSettings::new(allow_lan);
-                self.set_connected_state(&peer_endpoint, &cfg, &tunnel, &dns_servers, &relay_client)
+                self.set_connected_state(&peer_endpoint, cfg, &tunnel, &dns_servers, &relay_client)
             }
             FirewallPolicy::Blocked {
                 allow_lan,
@@ -128,8 +128,8 @@ impl Firewall {
             } => {
                 let cfg = &WinFwSettings::new(allow_lan);
                 self.set_blocked_state(
-                    &cfg,
-                    allowed_endpoint.map(|endpoint| WinFwAllowedEndpointContainer::from(endpoint)),
+                    cfg,
+                    allowed_endpoint.map(WinFwAllowedEndpointContainer::from),
                 )
             }
         }
@@ -427,7 +427,7 @@ mod winfw {
             let clients = endpoint
                 .clients
                 .iter()
-                .map(|client| WideCString::from_os_str_truncate(client))
+                .map(WideCString::from_os_str_truncate)
                 .collect::<Box<_>>();
             let clients_ptrs = clients
                 .iter()
@@ -568,9 +568,9 @@ mod winfw {
         }
     }
 
-    impl Into<Result<(), super::FirewallPolicyError>> for WinFwPolicyStatus {
-        fn into(self) -> Result<(), super::FirewallPolicyError> {
-            self.into_result()
+    impl From<WinFwPolicyStatus> for Result<(), super::FirewallPolicyError> {
+        fn from(val: WinFwPolicyStatus) -> Self {
+            val.into_result()
         }
     }
 
diff --git a/talpid-core/src/offline/windows.rs b/talpid-core/src/offline/windows.rs
index 77e8fca968..d669a018fa 100644
--- a/talpid-core/src/offline/windows.rs
+++ b/talpid-core/src/offline/windows.rs
@@ -113,12 +113,12 @@ impl BroadcastListener {
                 Self::connectivity_callback(event, addr_family, &system_state)
             }))
             .await
-            .map_err(|e| Error::ConnectivityMonitorError(e))?;
+            .map_err(Error::ConnectivityMonitorError)?;
         Ok(change_handle)
     }
 
-    fn connectivity_callback<'a>(
-        event_type: EventType<'a>,
+    fn connectivity_callback(
+        event_type: EventType<'_>,
         family: AddressFamily,
         state_lock: &Arc<Mutex<SystemState>>,
     ) {
diff --git a/talpid-core/src/split_tunnel/windows/driver.rs b/talpid-core/src/split_tunnel/windows/driver.rs
index 2eb9aecd30..8beb6de691 100644
--- a/talpid-core/src/split_tunnel/windows/driver.rs
+++ b/talpid-core/src/split_tunnel/windows/driver.rs
@@ -338,13 +338,13 @@ impl DeviceHandle {
 
         let raw_state: u64 = unsafe { deserialize_buffer(&buffer[0..size_of::<u64>()]) };
 
-        Ok(DriverState::try_from(raw_state)
-            .map_err(|error| io::Error::new(io::ErrorKind::Other, error))?)
+        DriverState::try_from(raw_state)
+            .map_err(|error| io::Error::new(io::ErrorKind::Other, error))
     }
 
     pub fn set_config<T: AsRef<OsStr>>(&self, apps: &[T]) -> io::Result<()> {
         let mut device_paths = Vec::with_capacity(apps.len());
-        for app in apps.as_ref() {
+        for app in apps {
             match get_device_path(app.as_ref()) {
                 Err(error) if error.kind() == io::ErrorKind::NotFound => {
                     log::debug!(
@@ -455,7 +455,7 @@ fn make_process_config<T: AsRef<OsStr>>(apps: &[T]) -> Vec<MaybeUninit<u8>> {
     let mut string_offset = 0;
 
     for (i, app) in apps.iter().enumerate() {
-        write_string_to_buffer(string_data, string_offset, &app);
+        write_string_to_buffer(string_data, string_offset, app);
 
         let app_bytelen = size_of::<u16>() * app.len();
         let entry = ConfigurationEntry {
@@ -542,8 +542,8 @@ fn build_process_tree() -> io::Result<Vec<ProcessInfo>> {
     }
 
     Ok(process_info
-        .into_iter()
-        .map(|(_, info)| info.into_inner())
+        .into_values()
+        .map(|info| info.into_inner())
         .collect())
 }
 
diff --git a/talpid-core/src/split_tunnel/windows/mod.rs b/talpid-core/src/split_tunnel/windows/mod.rs
index 5210bb98b8..022d66fed1 100644
--- a/talpid-core/src/split_tunnel/windows/mod.rs
+++ b/talpid-core/src/split_tunnel/windows/mod.rs
@@ -316,7 +316,7 @@ impl SplitTunnel {
         data_buffer
             .truncate(usize::try_from(returned_bytes).expect("usize must be no smaller than u32"));
 
-        driver::parse_event_buffer(&data_buffer)
+        driver::parse_event_buffer(data_buffer)
             .map(|(id, body)| EventResult::Event(id, body))
             .map_err(|error| {
                 log::error!(
@@ -445,7 +445,7 @@ impl SplitTunnel {
                     Request::SetPaths(paths) => {
                         let mut monitored_paths_guard = monitored_paths.lock().unwrap();
 
-                        let result = if paths.len() > 0 {
+                        let result = if !paths.is_empty() {
                             handle.set_config(&paths).map_err(Error::SetConfiguration)
                         } else {
                             handle.clear_config().map_err(Error::SetConfiguration)
@@ -535,7 +535,7 @@ impl SplitTunnel {
                 let paths = monitored_paths_copy.lock().unwrap();
                 let result = if paths.len() > 0 {
                     log::debug!("Re-resolving excluded paths");
-                    handle_copy.set_config(&*paths)
+                    handle_copy.set_config(&paths)
                 } else {
                     continue;
                 };
@@ -621,8 +621,8 @@ impl SplitTunnel {
         if let Some(metadata) = metadata {
             for ip in &metadata.ips {
                 match ip {
-                    IpAddr::V4(address) => tunnel_ipv4 = Some(address.clone()),
-                    IpAddr::V6(address) => tunnel_ipv6 = Some(address.clone()),
+                    IpAddr::V4(address) => tunnel_ipv4 = Some(*address),
+                    IpAddr::V6(address) => tunnel_ipv6 = Some(*address),
                 }
             }
         }
@@ -783,8 +783,8 @@ impl SplitTunnelDefaultRouteChangeHandlerContext {
     }
 }
 
-fn split_tunnel_default_route_change_handler<'a>(
-    event_type: EventType<'a>,
+fn split_tunnel_default_route_change_handler(
+    event_type: EventType<'_>,
     address_family: AddressFamily,
     ctx_mutex: &Arc<Mutex<SplitTunnelDefaultRouteChangeHandlerContext>>,
 ) {
@@ -803,7 +803,7 @@ fn split_tunnel_default_route_change_handler<'a>(
     let result = match event_type {
         Updated(default_route) | UpdatedDetails(default_route) => {
             match get_ip_address_for_interface(address_family, default_route.iface) {
-                Ok(Some(ip)) => match IpAddr::from(ip) {
+                Ok(Some(ip)) => match ip {
                     IpAddr::V4(addr) => ctx.addresses.internet_ipv4 = Some(addr),
                     IpAddr::V6(addr) => ctx.addresses.internet_ipv6 = Some(addr),
                 },
diff --git a/talpid-core/src/split_tunnel/windows/path_monitor.rs b/talpid-core/src/split_tunnel/windows/path_monitor.rs
index 22a3747d25..c40fec6dea 100644
--- a/talpid-core/src/split_tunnel/windows/path_monitor.rs
+++ b/talpid-core/src/split_tunnel/windows/path_monitor.rs
@@ -110,9 +110,7 @@ macro_rules! get_reparse_path {
         } else {
             let path_buffer = (&reparse_data.path_buffer) as *const u16;
             let parsed_path = std::slice::from_raw_parts(
-                path_buffer.offset(
-                    (reparse_data.sub_name_offset as usize / mem::size_of::<u16>()) as isize,
-                ),
+                path_buffer.add((reparse_data.sub_name_offset as usize / mem::size_of::<u16>())),
                 reparse_data.sub_name_length as usize / mem::size_of::<u16>(),
             );
             Ok::<PathBuf, io::Error>(PathBuf::from(OsString::from_wide(parsed_path)))
@@ -433,7 +431,7 @@ impl StrippedPath {
         ))?);
 
         Ok(StrippedPath {
-            prefix: prefix.clone(),
+            prefix,
             tail: osstr_to_wide(iter.as_path()),
         })
     }
@@ -542,10 +540,10 @@ impl PathMonitor {
                 }
                 PathMonitorCommand::SetPaths(new_paths) => {
                     *original_paths = new_paths;
-                    return !self.update_paths(&original_paths, false).is_err();
+                    return self.update_paths(original_paths, false).is_ok();
                 }
                 PathMonitorCommand::Refresh => {
-                    return !self.update_paths(&original_paths, true).is_err();
+                    return self.update_paths(original_paths, true).is_ok();
                 }
             }
         }
diff --git a/talpid-core/src/split_tunnel/windows/volume_monitor.rs b/talpid-core/src/split_tunnel/windows/volume_monitor.rs
index 34ba36089e..0d35187070 100644
--- a/talpid-core/src/split_tunnel/windows/volume_monitor.rs
+++ b/talpid-core/src/split_tunnel/windows/volume_monitor.rs
@@ -132,12 +132,10 @@ fn start_internal_monitor(
         // Compare against known state to ignore duplicate notifications
         // from frontends
         let state_diff = *known_state_guard ^ prev_state;
-        if state_diff != 0 {
-            if matches_volume(volumes, &paths_guard) {
-                // Reapply config
-                let _ = update_tx.send(());
-                let _ = path_monitor.refresh();
-            }
+        if state_diff != 0 && matches_volume(volumes, &paths_guard) {
+            // Reapply config
+            let _ = update_tx.send(());
+            let _ = path_monitor.refresh();
         }
 
         // Always grant the request
@@ -163,11 +161,11 @@ fn matches_volume(volumes: u32, paths_guard: &MutexGuard<'_, Vec<OsString>>) ->
         if let Some(path::Component::Prefix(prefix)) = path.components().next() {
             match prefix.kind() {
                 path::Prefix::VerbatimDisk(disk) | path::Prefix::Disk(disk) => {
-                    if disk < 'A' as u8 || disk > 'Z' as u8 {
+                    if !disk.is_ascii_uppercase() {
                         log::warn!("Ignoring invalid volume \"{}\"", disk as char);
                         continue;
                     }
-                    let disk = disk - 'A' as u8;
+                    let disk = disk - b'A';
                     if volumes & (1 << disk) != 0 {
                         return true;
                     }
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index ac8e0debd9..821e076db6 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -72,7 +72,7 @@ impl ConnectingState {
             allowed_endpoint: shared_values.allowed_endpoint.clone(),
             allowed_tunnel_traffic,
             #[cfg(windows)]
-            relay_client: TunnelMonitor::get_relay_client(&shared_values.resource_dir, &params),
+            relay_client: TunnelMonitor::get_relay_client(&shared_values.resource_dir, params),
         };
         shared_values
             .firewall
diff --git a/talpid-core/src/tunnel_state_machine/disconnected_state.rs b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
index b6b52bbc45..8462f56e10 100644
--- a/talpid-core/src/tunnel_state_machine/disconnected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
@@ -60,14 +60,11 @@ impl DisconnectedState {
                     )
                 );
             }
-        } else {
-            if let Err(error) = shared_values.split_tunnel.set_tunnel_addresses(None) {
-                log::error!(
-                    "{}",
-                    error
-                        .display_chain_with_msg("Failed to reset addresses in split tunnel driver")
-                );
-            }
+        } else if let Err(error) = shared_values.split_tunnel.set_tunnel_addresses(None) {
+            log::error!(
+                "{}",
+                error.display_chain_with_msg("Failed to reset addresses in split tunnel driver")
+            );
         }
     }
 
diff --git a/talpid-openvpn/src/lib.rs b/talpid-openvpn/src/lib.rs
index 0d56c746fa..87861e30a8 100644
--- a/talpid-openvpn/src/lib.rs
+++ b/talpid-openvpn/src/lib.rs
@@ -342,10 +342,10 @@ impl OpenVpnMonitor<OpenVpnCommand> {
         let wintun_logger = dll.activate_logging();
 
         let wintun_adapter = wintun::WintunAdapter::create(
-            dll.clone(),
-            &*ADAPTER_ALIAS,
-            &*ADAPTER_TUNNEL_TYPE,
-            Some(ADAPTER_GUID.clone()),
+            dll,
+            &ADAPTER_ALIAS,
+            &ADAPTER_TUNNEL_TYPE,
+            Some(ADAPTER_GUID),
         )
         .map_err(Error::WintunCreateAdapterError)?;
 
diff --git a/talpid-openvpn/src/wintun.rs b/talpid-openvpn/src/wintun.rs
index 1e98aa08f8..06fb443928 100644
--- a/talpid-openvpn/src/wintun.rs
+++ b/talpid-openvpn/src/wintun.rs
@@ -125,7 +125,7 @@ impl WintunAdapter {
         let mut guid = mem::MaybeUninit::zeroed();
         let result = unsafe { ConvertInterfaceLuidToGuid(&self.luid(), guid.as_mut_ptr()) };
         if result != NO_ERROR as i32 {
-            return Err(io::Error::from_raw_os_error(result as i32));
+            return Err(io::Error::from_raw_os_error(result));
         }
         Ok(unsafe { guid.assume_init() })
     }
diff --git a/talpid-platform-metadata/src/windows.rs b/talpid-platform-metadata/src/windows.rs
index 56db7c7919..d94bd02167 100644
--- a/talpid-platform-metadata/src/windows.rs
+++ b/talpid-platform-metadata/src/windows.rs
@@ -54,7 +54,7 @@ impl WindowsVersion {
         }
 
         let function_address = unsafe { GetProcAddress(ntdll, b"RtlGetVersion\0" as *const u8) }
-            .ok_or_else(|| io::Error::last_os_error())?;
+            .ok_or_else(io::Error::last_os_error)?;
 
         let rtl_get_version: extern "stdcall" fn(*mut RTL_OSVERSIONINFOW) =
             unsafe { *(&function_address as *const _ as *const _) };
diff --git a/talpid-routing/src/windows/default_route_monitor.rs b/talpid-routing/src/windows/default_route_monitor.rs
index 7c3fc07705..128c2533e0 100644
--- a/talpid-routing/src/windows/default_route_monitor.rs
+++ b/talpid-routing/src/windows/default_route_monitor.rs
@@ -85,7 +85,7 @@ impl DefaultRouteMonitorContext {
             (None, None) => (),
             (None, Some(current_best_route)) => {
                 self.best_route = Some(current_best_route);
-                (self.callback)(EventType::Updated(&self.best_route.as_ref().unwrap()));
+                (self.callback)(EventType::Updated(self.best_route.as_ref().unwrap()));
             }
             (Some(_), None) => {
                 self.best_route = None;
@@ -94,11 +94,9 @@ impl DefaultRouteMonitorContext {
             (Some(best_route), Some(current_best_route)) => {
                 if best_route != &current_best_route {
                     self.best_route = Some(current_best_route);
-                    (self.callback)(EventType::Updated(&self.best_route.as_ref().unwrap()));
+                    (self.callback)(EventType::Updated(self.best_route.as_ref().unwrap()));
                 } else if refresh_current {
-                    (self.callback)(EventType::UpdatedDetails(
-                        &self.best_route.as_ref().unwrap(),
-                    ));
+                    (self.callback)(EventType::UpdatedDetails(self.best_route.as_ref().unwrap()));
                 }
             }
         }
diff --git a/talpid-routing/src/windows/get_best_default_route.rs b/talpid-routing/src/windows/get_best_default_route.rs
index cb06e68a76..4f131e2b53 100644
--- a/talpid-routing/src/windows/get_best_default_route.rs
+++ b/talpid-routing/src/windows/get_best_default_route.rs
@@ -149,7 +149,7 @@ fn is_route_on_physical_interface(route: &MIB_IPFORWARD_ROW2) -> Result<bool> {
         }
     }
 
-    return Ok(true);
+    Ok(true)
 }
 
 fn contains_subslice<T: PartialEq>(slice: &[T], subslice: &[T]) -> bool {
@@ -163,7 +163,7 @@ struct AnnotatedRoute<'a> {
     effective_metric: u32,
 }
 
-fn annotate_route<'a>(route: &'a MIB_IPFORWARD_ROW2) -> Option<AnnotatedRoute<'a>> {
+fn annotate_route(route: &MIB_IPFORWARD_ROW2) -> Option<AnnotatedRoute<'_>> {
     // SAFETY: `si_family` is valid in both `Ipv4` and `Ipv6` so we can safely access `si_family`.
     let iface = get_ip_interface_entry(
         AddressFamily::try_from_af_family(unsafe { route.DestinationPrefix.Prefix.si_family })
diff --git a/talpid-routing/src/windows/mod.rs b/talpid-routing/src/windows/mod.rs
index b4831e9b3f..e68c9255fc 100644
--- a/talpid-routing/src/windows/mod.rs
+++ b/talpid-routing/src/windows/mod.rs
@@ -117,7 +117,7 @@ impl RouteManagerHandle {
                 response_tx,
             ))
             .map_err(|_| Error::RouteManagerDown)?;
-        Ok(response_rx.await.map_err(|_| Error::ManagerChannelDown)?)
+        response_rx.await.map_err(|_| Error::ManagerChannelDown)
     }
 
     /// Applies the given routes while the route manager is running.
diff --git a/talpid-routing/src/windows/route_manager.rs b/talpid-routing/src/windows/route_manager.rs
index ab3a217c6b..4a3713f7e3 100644
--- a/talpid-routing/src/windows/route_manager.rs
+++ b/talpid-routing/src/windows/route_manager.rs
@@ -250,9 +250,9 @@ impl RouteManagerInternal {
                 match default_route {
                     None => {
                         log::error!("Unable to determine details of default route");
-                        return Err(Error::NoDefaultRoute);
+                        Err(Error::NoDefaultRoute)
                     }
-                    Some(default_route) => return Ok(default_route),
+                    Some(default_route) => Ok(default_route),
                 }
             }
             NetNode::RealNode(node) => {
@@ -469,11 +469,11 @@ impl RouteManagerInternal {
         }
     }
 
-    fn default_route_change<'a>(
+    fn default_route_change(
         callbacks: &Arc<Mutex<(i32, HashMap<i32, Callback>)>>,
         records: &Arc<Mutex<Vec<RouteRecord>>>,
         family: ADDRESS_FAMILY,
-        event_type: RouteMonitorEventType<'a>,
+        event_type: RouteMonitorEventType<'_>,
     ) {
         // Forward event to all registered listeners.
         //
@@ -590,7 +590,7 @@ fn interface_luid_from_gateway(gateway: &SOCKADDR_INET) -> Result<NET_LUID_LH> {
                 unsafe { isolate_gateway_address(get_first_gateway_address_reference(adapter), family) }
             };
 
-            address_present(gateways, &gateway).unwrap_or(false)
+            address_present(gateways, gateway).unwrap_or(false)
         })
         .collect();
 
@@ -640,10 +640,10 @@ fn adapter_interface_enabled(
 
 /// SAFETY: `head` must be a linked list where each `head.Next` is either null or
 /// the it and all of its fields has lifetime 'a and are dereferenceable.
-unsafe fn isolate_gateway_address<'a>(
-    head: &'a IP_ADAPTER_GATEWAY_ADDRESS_LH,
+unsafe fn isolate_gateway_address(
+    head: &IP_ADAPTER_GATEWAY_ADDRESS_LH,
     family: ADDRESS_FAMILY,
-) -> Vec<&'a SOCKET_ADDRESS> {
+) -> Vec<&SOCKET_ADDRESS> {
     let mut matches = vec![];
 
     let mut gateway = head;
@@ -678,8 +678,7 @@ fn address_present(hay: Vec<&'_ SOCKET_ADDRESS>, needle: &'_ SOCKADDR_INET) -> R
     Ok(false)
 }
 
-fn equal_address(lhs: &'_ SOCKADDR_INET, rhs: &'_ SOCKET_ADDRESS) -> Result<bool> {
-    let rhs = &*rhs;
+fn equal_address(lhs: &SOCKADDR_INET, rhs: &SOCKET_ADDRESS) -> Result<bool> {
     // SAFETY: The si_family field is always valid
     if unsafe { lhs.si_family != (*rhs.lpSockaddr).sa_family } {
         return Ok(false);
@@ -774,7 +773,7 @@ impl Adapters {
         // IP_ADAPTER_ADDRESSES_LH is safe as that is the underlying data structure. SAFETY:
         // This union field is always valid to read from
         let system_size = unsafe {
-            (*(buffer.get(0).unwrap() as *const u8 as *const IP_ADAPTER_ADDRESSES_LH))
+            (*(buffer.first().unwrap() as *const u8 as *const IP_ADAPTER_ADDRESSES_LH))
                 .Anonymous1
                 .Anonymous
                 .Length
@@ -796,7 +795,7 @@ impl Adapters {
     /// Produces a iterator for the linked list in `Adapters` see
     /// [AdaptersIterator](struct.AdaptersIterator.html) SAFETY: See the documentation on
     /// `AdaptersIterator`
-    fn iter<'a>(&'a self) -> AdaptersIterator<'a> {
+    fn iter(&self) -> AdaptersIterator<'_> {
         let cur = if self.buffer.is_empty() {
             std::ptr::null()
         } else {
diff --git a/talpid-windows-net/src/net.rs b/talpid-windows-net/src/net.rs
index ceb9b250fd..2cf5c7af7f 100644
--- a/talpid-windows-net/src/net.rs
+++ b/talpid-windows-net/src/net.rs
@@ -187,7 +187,7 @@ pub fn notify_ip_interface_change<'a, T: FnMut(&MIB_IPINTERFACE_ROW, i32) + Send
     if status == NO_ERROR as i32 {
         Ok(context)
     } else {
-        Err(io::Error::from_raw_os_error(status as i32))
+        Err(io::Error::from_raw_os_error(status))
     }
 }
 
@@ -204,7 +204,7 @@ pub fn get_ip_interface_entry(
     if result == NO_ERROR as i32 {
         Ok(row)
     } else {
-        Err(io::Error::from_raw_os_error(result as i32))
+        Err(io::Error::from_raw_os_error(result))
     }
 }
 
@@ -214,7 +214,7 @@ pub fn set_ip_interface_entry(row: &mut MIB_IPINTERFACE_ROW) -> io::Result<()> {
     if result == NO_ERROR as i32 {
         Ok(())
     } else {
-        Err(io::Error::from_raw_os_error(result as i32))
+        Err(io::Error::from_raw_os_error(result))
     }
 }
 
@@ -296,7 +296,7 @@ pub async fn wait_for_addresses(luid: NET_LUID_LH) -> Result<()> {
                 let status = unsafe { GetUnicastIpAddressEntry(row) };
                 if status != NO_ERROR as i32 {
                     return Err(Error::ObtainUnicastAddress(io::Error::from_raw_os_error(
-                        status as i32,
+                        status,
                     )));
                 }
                 if row.DadState == IpDadStateTentative {
@@ -350,7 +350,7 @@ pub fn add_ip_address_for_interface(luid: NET_LUID_LH, address: IpAddr) -> Resul
     let status = unsafe { CreateUnicastIpAddressEntry(&row) };
     if status != NO_ERROR as i32 {
         return Err(Error::CreateUnicastEntry(io::Error::from_raw_os_error(
-            status as i32,
+            status,
         )));
     }
     Ok(())
@@ -367,7 +367,7 @@ pub fn get_unicast_table(
     let status =
         unsafe { GetUnicastIpAddressTable(af_family_from_family(family), &mut unicast_table) };
     if status != NO_ERROR as i32 {
-        return Err(io::Error::from_raw_os_error(status as i32));
+        return Err(io::Error::from_raw_os_error(status));
     }
     let first_row = unsafe { &(*unicast_table).Table[0] } as *const MIB_UNICASTIPADDRESS_ROW;
     for i in 0..unsafe { *unicast_table }.NumEntries {
@@ -383,7 +383,7 @@ pub fn index_from_luid(luid: &NET_LUID_LH) -> io::Result<u32> {
     let mut index = 0u32;
     let status = unsafe { ConvertInterfaceLuidToIndex(luid, &mut index) };
     if status != NO_ERROR as i32 {
-        return Err(io::Error::from_raw_os_error(status as i32));
+        return Err(io::Error::from_raw_os_error(status));
     }
     Ok(index)
 }
@@ -393,7 +393,7 @@ pub fn guid_from_luid(luid: &NET_LUID_LH) -> io::Result<GUID> {
     let mut guid = MaybeUninit::zeroed();
     let status = unsafe { ConvertInterfaceLuidToGuid(luid, guid.as_mut_ptr()) };
     if status != NO_ERROR as i32 {
-        return Err(io::Error::from_raw_os_error(status as i32));
+        return Err(io::Error::from_raw_os_error(status));
     }
     Ok(unsafe { guid.assume_init() })
 }
@@ -408,7 +408,7 @@ pub fn luid_from_alias<T: AsRef<OsStr>>(alias: T) -> io::Result<NET_LUID_LH> {
     let mut luid: NET_LUID_LH = unsafe { std::mem::zeroed() };
     let status = unsafe { ConvertInterfaceAliasToLuid(alias_wide.as_ptr(), &mut luid) };
     if status != NO_ERROR as i32 {
-        return Err(io::Error::from_raw_os_error(status as i32));
+        return Err(io::Error::from_raw_os_error(status));
     }
     Ok(luid)
 }
@@ -419,28 +419,26 @@ pub fn alias_from_luid(luid: &NET_LUID_LH) -> io::Result<OsString> {
     let status =
         unsafe { ConvertInterfaceLuidToAlias(luid, &mut buffer[0] as *mut _, buffer.len()) };
     if status != NO_ERROR as i32 {
-        return Err(io::Error::from_raw_os_error(status as i32));
+        return Err(io::Error::from_raw_os_error(status));
     }
     let nul = buffer.iter().position(|&c| c == 0u16).unwrap();
     Ok(OsString::from_wide(&buffer[0..nul]))
 }
 
 fn af_family_from_family(family: Option<AddressFamily>) -> u16 {
-    family
-        .map(|family| family as u16)
-        .unwrap_or(AF_UNSPEC as u16)
+    family.map(|family| family as u16).unwrap_or(AF_UNSPEC)
 }
 
 /// Converts an `Ipv4Addr` to `IN_ADDR`
 pub fn inaddr_from_ipaddr(addr: Ipv4Addr) -> IN_ADDR {
     let sockaddr = SockAddr::from(SocketAddr::V4(SocketAddrV4::new(addr, 0)));
-    (&unsafe { *(sockaddr.as_ptr() as *const sockaddr_in) }).sin_addr
+    unsafe { *(sockaddr.as_ptr() as *const sockaddr_in) }.sin_addr
 }
 
 /// Converts an `Ipv6Addr` to `IN6_ADDR`
 pub fn in6addr_from_ipaddr(addr: Ipv6Addr) -> IN6_ADDR {
     let sockaddr = SockAddr::from(SocketAddr::V6(SocketAddrV6::new(addr, 0, 0, 0)));
-    (&unsafe { *(sockaddr.as_ptr() as *const sockaddr_in6) }).sin6_addr
+    unsafe { *(sockaddr.as_ptr() as *const sockaddr_in6) }.sin6_addr
 }
 
 /// Converts an `IN_ADDR` to `Ipv4Addr`
diff --git a/talpid-wireguard/src/lib.rs b/talpid-wireguard/src/lib.rs
index 3d542641b7..f28879c512 100644
--- a/talpid-wireguard/src/lib.rs
+++ b/talpid-wireguard/src/lib.rs
@@ -833,9 +833,9 @@ impl WireguardMonitor {
     fn get_tunnel_nodes(iface_name: &str, config: &Config) -> (routing::Node, routing::Node) {
         #[cfg(windows)]
         {
-            let v4 = routing::Node::new(config.ipv4_gateway.clone().into(), iface_name.to_string());
+            let v4 = routing::Node::new(config.ipv4_gateway.into(), iface_name.to_string());
             let v6 = if let Some(ipv6_gateway) = config.ipv6_gateway.as_ref() {
-                routing::Node::new(ipv6_gateway.clone().into(), iface_name.to_string())
+                routing::Node::new((*ipv6_gateway).into(), iface_name.to_string())
             } else {
                 routing::Node::device(iface_name.to_string())
             };
diff --git a/talpid-wireguard/src/logging.rs b/talpid-wireguard/src/logging.rs
index 35ec10fc2f..d1c0a9c62d 100644
--- a/talpid-wireguard/src/logging.rs
+++ b/talpid-wireguard/src/logging.rs
@@ -73,7 +73,7 @@ impl AsRef<str> for LogLevel {
 #[cfg(windows)]
 pub fn log(context: u32, level: LogLevel, tag: &str, msg: &str) {
     let mut map = LOG_MUTEX.lock();
-    if let Some(logfile) = map.get_mut(&(context as u32)) {
+    if let Some(logfile) = map.get_mut(&{ context }) {
         log_inner(logfile, level, tag, msg);
     }
 }
@@ -104,7 +104,7 @@ pub unsafe extern "system" fn wg_go_logging_callback(
             let m = std::ffi::CStr::from_ptr(msg)
                 .to_string_lossy()
                 .to_string()
-                .replace("\n", "\r\n");
+                .replace('\n', "\r\n");
             m
         } else {
             "Logging message from WireGuard is NULL".to_string()
diff --git a/talpid-wireguard/src/wireguard_go.rs b/talpid-wireguard/src/wireguard_go.rs
index aa962ace7d..d4d542ff59 100644
--- a/talpid-wireguard/src/wireguard_go.rs
+++ b/talpid-wireguard/src/wireguard_go.rs
@@ -207,8 +207,8 @@ impl WgGoTunnel {
 
     // Callback to be used to rebind the tunnel sockets when the default route changes
     #[cfg(target_os = "windows")]
-    pub fn default_route_changed_callback<'a>(
-        event_type: crate::routing::EventType<'a>,
+    pub fn default_route_changed_callback(
+        event_type: crate::routing::EventType<'_>,
         address_family: talpid_windows_net::AddressFamily,
     ) {
         use crate::routing::EventType::*;
diff --git a/talpid-wireguard/src/wireguard_nt.rs b/talpid-wireguard/src/wireguard_nt.rs
index 538bda7f68..bdb51c74a7 100644
--- a/talpid-wireguard/src/wireguard_nt.rs
+++ b/talpid-wireguard/src/wireguard_nt.rs
@@ -246,7 +246,7 @@ impl WgAllowedIp {
                     if byte & ((host_mask & 0xff) as u8) != 0 {
                         return Err(Error::InvalidAllowedIpBits);
                     }
-                    host_mask = host_mask >> 8;
+                    host_mask >>= 8;
                 }
             }
             family => return Err(Error::UnknownAddressFamily(family)),
@@ -435,13 +435,8 @@ impl WgNtTunnel {
     ) -> Result<Self> {
         let dll = load_wg_nt_dll(resource_dir)?;
         let logger_handle = LoggerHandle::new(dll.clone(), log_path)?;
-        let device = WgNtAdapter::create(
-            dll.clone(),
-            &*ADAPTER_ALIAS,
-            &*ADAPTER_TYPE,
-            Some(ADAPTER_GUID.clone()),
-        )
-        .map_err(Error::CreateTunnelDeviceError)?;
+        let device = WgNtAdapter::create(dll, &ADAPTER_ALIAS, &ADAPTER_TYPE, Some(ADAPTER_GUID))
+            .map_err(Error::CreateTunnelDeviceError)?;
 
         let interface_name = device
             .name()
@@ -856,11 +851,11 @@ fn serialize_config(config: &Config) -> Result<Vec<MaybeUninit<u8>>> {
         let wg_peer = WgPeer {
             flags,
             reserved: 0,
-            public_key: peer.public_key.as_bytes().clone(),
+            public_key: *peer.public_key.as_bytes(),
             preshared_key: peer
                 .psk
                 .as_ref()
-                .map(|psk| psk.as_bytes().clone())
+                .map(|psk| *psk.as_bytes())
                 .unwrap_or([0u8; WIREGUARD_KEY_LENGTH]),
             persistent_keepalive: 0,
             endpoint: net::inet_sockaddr_from_socketaddr(peer.endpoint).into(),
@@ -882,8 +877,7 @@ fn serialize_config(config: &Config) -> Result<Vec<MaybeUninit<u8>>> {
                 IpNetwork::V6(v6_network) => WgIpAddr::from(v6_network.ip()),
             };
 
-            let wg_allowed_ip =
-                WgAllowedIp::new(address, address_family, allowed_ip.prefix() as u8)?;
+            let wg_allowed_ip = WgAllowedIp::new(address, address_family, allowed_ip.prefix())?;
 
             buffer.extend(as_uninit_byte_slice(&wg_allowed_ip));
         }
@@ -944,7 +938,7 @@ unsafe fn deserialize_config(
         peers.push((peer, allowed_ips));
     }
 
-    if tail.len() > 0 {
+    if !tail.is_empty() {
         return Err(Error::InvalidConfigData);
     }
 
@@ -1059,7 +1053,7 @@ mod tests {
             p0: WgPeer {
                 flags: WgPeerFlag::HAS_PUBLIC_KEY | WgPeerFlag::HAS_ENDPOINT,
                 reserved: 0,
-                public_key: WG_PUBLIC_KEY.as_bytes().clone(),
+                public_key: *WG_PUBLIC_KEY.as_bytes(),
                 preshared_key: [0; WIREGUARD_KEY_LENGTH],
                 persistent_keepalive: 0,
                 endpoint: talpid_windows_net::inet_sockaddr_from_socketaddr(
@@ -1093,7 +1087,7 @@ mod tests {
 
     #[test]
     fn test_config_serialization() {
-        let serialized_data = serialize_config(&*WG_CONFIG).unwrap();
+        let serialized_data = serialize_config(&WG_CONFIG).unwrap();
         assert_eq!(mem::size_of::<Interface>(), serialized_data.len());
         let serialized_iface = &unsafe { *(serialized_data.as_ptr() as *const Interface) };
         assert_eq!(&*WG_STRUCT_CONFIG, serialized_iface);