Perform a clippy --fix

This is a giant commit which performs only a clippy --fix.

Auditing can happen in two ways, either by reading every line or by
running a `cargo clippy --fix` on the previous commit and make sure that
the result is the same.

38 files changed, 102 insertions, 131 deletions

diff --git a/android/translations-converter/src/android/string_value.rs b/android/translations-converter/src/android/string_value.rs
index bd202f16fb..04ad23653e 100644
--- a/android/translations-converter/src/android/string_value.rs
+++ b/android/translations-converter/src/android/string_value.rs
@@ -19,9 +19,9 @@ impl StringValue {
     /// indices.
     pub fn from_unescaped(string: &str) -> Self {
         let value_with_parameters = htmlize::escape_text(string)
-            .replace(r"\", r"\\")
-            .replace("\"", "\\\"")
-            .replace(r"'", r"\'");
+            .replace('\\', r"\\")
+            .replace('\"', "\\\"")
+            .replace('\'', r"\'");
 
         let value_without_line_breaks = Self::collapse_line_breaks(value_with_parameters);
         let value = Self::ensure_parameters_are_indexed(value_without_line_breaks);
@@ -50,7 +50,7 @@ impl StringValue {
             static ref PARAMETER_INDEX: Regex = Regex::new(r"^(\d+)\$").unwrap();
         }
 
-        let mut parts = original.split("%");
+        let mut parts = original.split('%');
         let mut output = parts.next().unwrap().to_owned();
         let mut offset = 1;
 
diff --git a/android/translations-converter/src/gettext/msg_string.rs b/android/translations-converter/src/gettext/msg_string.rs
index 83bcd90c30..242ff4f2d5 100644
--- a/android/translations-converter/src/gettext/msg_string.rs
+++ b/android/translations-converter/src/gettext/msg_string.rs
@@ -21,11 +21,11 @@ impl MsgString {
     /// characters. It will not attempt to escape non-ASCII characters and will just keep them as
     /// UTF-8 characters.
     pub fn from_unescaped(string: &str) -> Self {
-        let string = string.replace(r"\", r"\\");
-        let string = string.replace("\n", r"\n");
-        let string = string.replace("\r", r"\r");
-        let string = string.replace("\t", r"\t");
-        let string = string.replace(r#"""#, r#"\""#);
+        let string = string.replace('\\', r"\\");
+        let string = string.replace('\n', r"\n");
+        let string = string.replace('\r', r"\r");
+        let string = string.replace('\t', r"\t");
+        let string = string.replace('"', r#"\""#);
 
         MsgString(string)
     }
diff --git a/android/translations-converter/src/main.rs b/android/translations-converter/src/main.rs
index 262f06ff24..fdd384200d 100644
--- a/android/translations-converter/src/main.rs
+++ b/android/translations-converter/src/main.rs
@@ -181,10 +181,7 @@ fn main() {
                         id,
                         value: gettext::MsgValue::Plural {
                             plural_id,
-                            values: vec![
-                                gettext::MsgString::empty().into(),
-                                gettext::MsgString::empty().into(),
-                            ],
+                            values: vec![gettext::MsgString::empty(), gettext::MsgString::empty()],
                         },
                     }
                 }),
@@ -199,7 +196,7 @@ fn main() {
 /// `values-en-rUS`.
 fn android_locale_directory(locale: &str) -> String {
     let mut directory = String::from("values-");
-    let mut parts = locale.split("-");
+    let mut parts = locale.split('-');
 
     directory.push_str(parts.next().unwrap());
 
diff --git a/mullvad-api/src/address_cache.rs b/mullvad-api/src/address_cache.rs
index 3b6fcba074..92b7b6054f 100644
--- a/mullvad-api/src/address_cache.rs
+++ b/mullvad-api/src/address_cache.rs
@@ -49,7 +49,7 @@ impl AddressCache {
 
         let address_cache = Self {
             inner: Arc::new(Mutex::new(cache)),
-            write_path: write_path.map(|cache| Arc::from(cache)),
+            write_path: write_path.map(Arc::from),
         };
         Ok(address_cache)
     }
@@ -109,7 +109,7 @@ impl AddressCacheInner {
 async fn read_address_file(path: &Path) -> Result<SocketAddr, Error> {
     let mut file = fs::File::open(path)
         .await
-        .map_err(|error| Error::OpenAddressCache(error))?;
+        .map_err(Error::OpenAddressCache)?;
     let mut address = String::new();
     file.read_to_string(&mut address)
         .await
diff --git a/mullvad-api/src/https_client_with_sni.rs b/mullvad-api/src/https_client_with_sni.rs
index 409492712e..cc7e2c1561 100644
--- a/mullvad-api/src/https_client_with_sni.rs
+++ b/mullvad-api/src/https_client_with_sni.rs
@@ -220,7 +220,7 @@ impl HttpsConnectorWithSni {
             "invalid url, missing host",
         ))?;
         let port = uri.port_u16().unwrap_or(443);
-        if let Some(addr) = hostname.parse::<IpAddr>().ok() {
+        if let Ok(addr) = hostname.parse::<IpAddr>() {
             return Ok(SocketAddr::new(addr, port));
         }
 
@@ -234,7 +234,7 @@ impl HttpsConnectorWithSni {
         //
         let mut addrs = GaiResolver::new()
             .call(
-                Name::from_str(&hostname)
+                Name::from_str(hostname)
                     .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?,
             )
             .await
diff --git a/mullvad-api/src/lib.rs b/mullvad-api/src/lib.rs
index 714718814b..17bbc5b3a2 100644
--- a/mullvad-api/src/lib.rs
+++ b/mullvad-api/src/lib.rs
@@ -116,12 +116,8 @@ impl ApiEndpoint {
                     log::debug!("Overriding API. Using {} at {}", api.host, api.addr);
                 }
             }
-        } else {
-            if host_var.is_some() || address_var.is_some() {
-                log::warn!(
-                    "MULLVAD_API_HOST and MULLVAD_API_ADDR are ignored in production builds"
-                );
-            }
+        } else if host_var.is_some() || address_var.is_some() {
+            log::warn!("MULLVAD_API_HOST and MULLVAD_API_ADDR are ignored in production builds");
         }
         api
     }
diff --git a/mullvad-api/src/relay_list.rs b/mullvad-api/src/relay_list.rs
index 7f72767a1b..6bd4523652 100644
--- a/mullvad-api/src/relay_list.rs
+++ b/mullvad-api/src/relay_list.rs
@@ -35,7 +35,7 @@ impl RelayListProxy {
         let service = self.handle.service.clone();
         let request = self.handle.factory.request("app/v1/relays", Method::GET);
 
-        let future = async move {
+        async move {
             let mut request = request?;
             request.set_timeout(RELAY_LIST_TIMEOUT);
 
@@ -67,8 +67,7 @@ impl RelayListProxy {
                     .await?
                     .into_relay_list(etag),
             ))
-        };
-        future
+        }
     }
 }
 
@@ -113,7 +112,7 @@ impl ServerRelayList {
 
         relay_list::RelayList {
             etag: etag.map(|mut tag| {
-                if tag.starts_with("\"") {
+                if tag.starts_with('"') {
                     tag.insert_str(0, "W/");
                 }
                 tag
diff --git a/mullvad-api/src/rest.rs b/mullvad-api/src/rest.rs
index 84560e07ba..fbd2986b7c 100644
--- a/mullvad-api/src/rest.rs
+++ b/mullvad-api/src/rest.rs
@@ -151,10 +151,9 @@ impl<
             socket_bypass_tx.clone(),
         );
 
-        proxy_config_provider
-            .next()
-            .await
-            .map(|config| connector_handle.set_connection_mode(config));
+        if let Some(config) = proxy_config_provider.next().await {
+            connector_handle.set_connection_mode(config);
+        }
 
         let (command_tx, command_rx) = mpsc::unbounded();
         let client = Client::builder().build(connector);
@@ -293,14 +292,14 @@ pub struct RestRequest {
 impl RestRequest {
     /// Constructs a GET request with the given URI. Returns an error if the URI is not valid.
     pub fn get(uri: &str) -> Result<Self> {
-        let uri = hyper::Uri::from_str(&uri).map_err(Error::UriError)?;
+        let uri = hyper::Uri::from_str(uri).map_err(Error::UriError)?;
 
         let mut builder = http::request::Builder::new()
             .method(Method::GET)
             .header(header::USER_AGENT, HeaderValue::from_static(USER_AGENT))
             .header(header::ACCEPT, HeaderValue::from_static("application/json"));
         if let Some(host) = uri.host() {
-            builder = builder.header(header::HOST, HeaderValue::from_str(&host)?);
+            builder = builder.header(header::HOST, HeaderValue::from_str(host)?);
         };
 
         let request = builder
@@ -499,14 +498,14 @@ pub fn send_request(
     async move {
         let mut request = request?;
         if let Some((store, account)) = &auth {
-            let access_token = store.get_token(&account).await?;
+            let access_token = store.get_token(account).await?;
             request.set_auth(Some(access_token))?;
         }
         let response = service.request(request).await?;
         let result = parse_rest_response(response, expected_statuses).await;
 
         if let Some((store, account)) = &auth {
-            store.check_response(&account, &result);
+            store.check_response(account, &result);
         }
 
         result
@@ -526,14 +525,14 @@ pub fn send_json_request<B: serde::Serialize>(
     async move {
         let mut request = request?;
         if let Some((store, account)) = &auth {
-            let access_token = store.get_token(&account).await?;
+            let access_token = store.get_token(account).await?;
             request.set_auth(Some(access_token))?;
         }
         let response = service.request(request).await?;
         let result = parse_rest_response(response, expected_statuses).await;
 
         if let Some((store, account)) = &auth {
-            store.check_response(&account, &result);
+            store.check_response(account, &result);
         }
 
         result
diff --git a/mullvad-cli/src/cmds/account.rs b/mullvad-cli/src/cmds/account.rs
index 8432f1da0a..9cbfd6cbb2 100644
--- a/mullvad-cli/src/cmds/account.rs
+++ b/mullvad-cli/src/cmds/account.rs
@@ -241,7 +241,7 @@ impl Account {
                     || dev.id.eq_ignore_ascii_case(&device_to_revoke)
             })
             .map(|dev| dev.id)
-            .ok_or_else(|| Error::Other(DEVICE_NOT_FOUND_ERROR))?;
+            .ok_or(Error::Other(DEVICE_NOT_FOUND_ERROR))?;
 
         rpc.remove_device(types::DeviceRemoval {
             account_token: token,
diff --git a/mullvad-cli/src/cmds/bridge.rs b/mullvad-cli/src/cmds/bridge.rs
index 3f00a7f69a..b253ae63a9 100644
--- a/mullvad-cli/src/cmds/bridge.rs
+++ b/mullvad-cli/src/cmds/bridge.rs
@@ -246,7 +246,7 @@ impl Bridge {
 
     async fn handle_set_bridge_provider(matches: &clap::ArgMatches) -> Result<()> {
         let providers: Vec<String> = matches.values_of_t_or_exit("provider");
-        let providers = if providers.iter().next().map(String::as_str) == Some("any") {
+        let providers = if providers.get(0).map(String::as_str) == Some("any") {
             vec![]
         } else {
             providers
diff --git a/mullvad-cli/src/cmds/relay.rs b/mullvad-cli/src/cmds/relay.rs
index d0d75dea20..c624c2a25b 100644
--- a/mullvad-cli/src/cmds/relay.rs
+++ b/mullvad-cli/src/cmds/relay.rs
@@ -479,7 +479,7 @@ impl Relay {
 
     async fn set_providers(&self, matches: &clap::ArgMatches) -> Result<()> {
         let providers: Vec<String> = matches.values_of_t_or_exit("provider");
-        let providers = if providers.iter().next().map(String::as_str) == Some("any") {
+        let providers = if providers.get(0).map(String::as_str) == Some("any") {
             vec![]
         } else {
             providers
diff --git a/mullvad-cli/src/format.rs b/mullvad-cli/src/format.rs
index a43307a789..74630166d2 100644
--- a/mullvad-cli/src/format.rs
+++ b/mullvad-cli/src/format.rs
@@ -128,9 +128,9 @@ fn format_relay_connection(relay_info: &TunnelStateRelayInfo, verbose: bool) ->
 
     format!(
         "{exit_endpoint}{first_hop}{bridge}{obfuscator}{tunnel_type}{bridge_type}{obfuscator_type}",
-        first_hop = first_hop.unwrap_or(String::new()),
-        bridge = bridge.unwrap_or(String::new()),
-        obfuscator = obfuscator.unwrap_or(String::new()),
+        first_hop = first_hop.unwrap_or_default(),
+        bridge = bridge.unwrap_or_default(),
+        obfuscator = obfuscator.unwrap_or_default(),
     )
 }
 
diff --git a/mullvad-cli/src/state.rs b/mullvad-cli/src/state.rs
index 4cf826214f..f237689a3b 100644
--- a/mullvad-cli/src/state.rs
+++ b/mullvad-cli/src/state.rs
@@ -26,7 +26,7 @@ pub fn state_listen(mut rpc: ManagementServiceClient) -> Receiver<Result<TunnelS
                         Err(status) => Err(Error::RpcFailed(status)),
                     };
 
-                    if let Err(_) = sender.send(forward).await {
+                    if sender.send(forward).await.is_err() {
                         break;
                     }
                 }
diff --git a/mullvad-daemon/src/api.rs b/mullvad-daemon/src/api.rs
index f2b8708ae6..fe718c441a 100644
--- a/mullvad-daemon/src/api.rs
+++ b/mullvad-daemon/src/api.rs
@@ -94,7 +94,7 @@ impl Stream for ApiConnectionModeProvider {
             config
         }));
 
-        return self.poll_next(cx);
+        self.poll_next(cx)
     }
 }
 
@@ -148,7 +148,7 @@ impl ApiEndpointUpdaterHandle {
                 };
                 let (result_tx, result_rx) = oneshot::channel();
                 let _ = tunnel_tx.unbounded_send(TunnelCommand::AllowEndpoint(
-                    get_allowed_endpoint(address.clone()),
+                    get_allowed_endpoint(address),
                     result_tx,
                 ));
                 // Wait for the firewall policy to be updated.
diff --git a/mullvad-daemon/src/device/mod.rs b/mullvad-daemon/src/device/mod.rs
index a0e3bed908..93dbac49ca 100644
--- a/mullvad-daemon/src/device/mod.rs
+++ b/mullvad-daemon/src/device/mod.rs
@@ -316,8 +316,7 @@ impl AccountManagerHandle {
     }
 
     pub async fn logout(&self) -> Result<(), Error> {
-        self.send_command(|tx| AccountManagerCommand::Logout(tx))
-            .await
+        self.send_command(AccountManagerCommand::Logout).await
     }
 
     pub async fn set(&self, data: PrivateAccountAndDevice) -> Result<(), Error> {
@@ -326,18 +325,16 @@ impl AccountManagerHandle {
     }
 
     pub async fn data(&self) -> Result<PrivateDeviceState, Error> {
-        self.send_command(|tx| AccountManagerCommand::GetData(tx))
-            .await
+        self.send_command(AccountManagerCommand::GetData).await
     }
 
     pub async fn data_after_login(&self) -> Result<PrivateDeviceState, Error> {
-        self.send_command(|tx| AccountManagerCommand::GetDataAfterLogin(tx))
+        self.send_command(AccountManagerCommand::GetDataAfterLogin)
             .await
     }
 
     pub async fn rotate_key(&self) -> Result<(), Error> {
-        self.send_command(|tx| AccountManagerCommand::RotateKey(tx))
-            .await
+        self.send_command(AccountManagerCommand::RotateKey).await
     }
 
     pub async fn set_rotation_interval(&self, interval: RotationInterval) -> Result<(), Error> {
@@ -346,7 +343,7 @@ impl AccountManagerHandle {
     }
 
     pub async fn validate_device(&self) -> Result<(), Error> {
-        self.send_command(|tx| AccountManagerCommand::ValidateDevice(tx))
+        self.send_command(AccountManagerCommand::ValidateDevice)
             .await
     }
 
diff --git a/mullvad-daemon/src/logging.rs b/mullvad-daemon/src/logging.rs
index 597643fe26..cd58619108 100644
--- a/mullvad-daemon/src/logging.rs
+++ b/mullvad-daemon/src/logging.rs
@@ -137,7 +137,7 @@ impl Formatter {
         if self.output_timestamp {
             DATE_TIME_FORMAT_STR
         } else {
-            &""
+            ""
         }
     }
 
diff --git a/mullvad-daemon/src/migrations/account_history.rs b/mullvad-daemon/src/migrations/account_history.rs
index 06a8326f04..22534c7f88 100644
--- a/mullvad-daemon/src/migrations/account_history.rs
+++ b/mullvad-daemon/src/migrations/account_history.rs
@@ -131,7 +131,6 @@ fn try_format_v1(bytes: &[u8]) -> Result<Option<AccountToken>> {
 
 #[cfg(test)]
 mod test {
-    use serde_json;
 
     pub const ACCOUNT_HISTORY_V1: &str = r#"
 {
diff --git a/mullvad-daemon/src/migrations/v1.rs b/mullvad-daemon/src/migrations/v1.rs
index 7f2a656c04..c8d6f9d585 100644
--- a/mullvad-daemon/src/migrations/v1.rs
+++ b/mullvad-daemon/src/migrations/v1.rs
@@ -76,7 +76,6 @@ fn version_matches(settings: &mut serde_json::Value) -> bool {
 #[cfg(test)]
 mod test {
     use super::{migrate, version_matches};
-    use serde_json;
 
     pub const V2_SETTINGS: &str = r#"
 {
diff --git a/mullvad-daemon/src/migrations/v2.rs b/mullvad-daemon/src/migrations/v2.rs
index 585bc16cc1..e91a0d08e8 100644
--- a/mullvad-daemon/src/migrations/v2.rs
+++ b/mullvad-daemon/src/migrations/v2.rs
@@ -73,7 +73,6 @@ fn version_matches(settings: &mut serde_json::Value) -> bool {
 #[cfg(test)]
 mod test {
     use super::{migrate, version_matches};
-    use serde_json;
 
     const V2_SETTINGS: &str = r#"
 {
diff --git a/mullvad-daemon/src/migrations/v3.rs b/mullvad-daemon/src/migrations/v3.rs
index dd44505103..cf8631e121 100644
--- a/mullvad-daemon/src/migrations/v3.rs
+++ b/mullvad-daemon/src/migrations/v3.rs
@@ -94,7 +94,6 @@ fn version_matches(settings: &mut serde_json::Value) -> bool {
 #[cfg(test)]
 mod test {
     use super::{migrate, version_matches};
-    use serde_json;
 
     pub const V3_SETTINGS: &str = r#"
 {
diff --git a/mullvad-daemon/src/migrations/v4.rs b/mullvad-daemon/src/migrations/v4.rs
index 5bdfa7e5be..6908b13010 100644
--- a/mullvad-daemon/src/migrations/v4.rs
+++ b/mullvad-daemon/src/migrations/v4.rs
@@ -140,7 +140,6 @@ fn wg_protocol_from_port(port: u16) -> TransportProtocol {
 #[cfg(test)]
 mod test {
     use super::{migrate, version_matches};
-    use serde_json;
 
     pub const V4_SETTINGS: &str = r#"
 {
diff --git a/mullvad-daemon/src/migrations/v5.rs b/mullvad-daemon/src/migrations/v5.rs
index ba12c5ae91..9f0fdc4b94 100644
--- a/mullvad-daemon/src/migrations/v5.rs
+++ b/mullvad-daemon/src/migrations/v5.rs
@@ -175,7 +175,6 @@ fn version_matches(settings: &mut serde_json::Value) -> bool {
 #[cfg(test)]
 mod test {
     use super::{migrate, version_matches};
-    use serde_json;
 
     pub const V5_SETTINGS: &str = r#"
 {
diff --git a/mullvad-management-interface/src/types.rs b/mullvad-management-interface/src/types.rs
index 54aac8964f..01f16d8220 100644
--- a/mullvad-management-interface/src/types.rs
+++ b/mullvad-management-interface/src/types.rs
@@ -563,7 +563,7 @@ impl From<mullvad_types::relay_constraints::BridgeSettings> for BridgeSettings {
                     bridge_settings::Type::Shadowsocks(bridge_settings::ShadowsocksProxySettings {
                         peer: proxy_settings.peer.to_string(),
                         password: proxy_settings.password.clone(),
-                        cipher: proxy_settings.cipher.clone(),
+                        cipher: proxy_settings.cipher,
                     })
                 }
             },
@@ -900,13 +900,11 @@ impl TryFrom<RelaySettings> for mullvad_types::relay_constraints::RelaySettings
         use mullvad_types::{relay_constraints as mullvad_constraints, CustomTunnelEndpoint};
         use talpid_types::net;
 
-        let update_value =
-            settings
-                .endpoint
-                .clone()
-                .ok_or(FromProtobufTypeError::InvalidArgument(
-                    "missing relay settings",
-                ))?;
+        let update_value = settings
+            .endpoint
+            .ok_or(FromProtobufTypeError::InvalidArgument(
+                "missing relay settings",
+            ))?;
 
         match update_value {
             relay_settings::Endpoint::Custom(settings) => {
@@ -972,13 +970,11 @@ impl TryFrom<RelaySettingsUpdate> for mullvad_types::relay_constraints::RelaySet
         use mullvad_types::{relay_constraints as mullvad_constraints, CustomTunnelEndpoint};
         use talpid_types::net;
 
-        let update_value =
-            settings
-                .r#type
-                .clone()
-                .ok_or(FromProtobufTypeError::InvalidArgument(
-                    "missing relay settings",
-                ))?;
+        let update_value = settings
+            .r#type
+            .ok_or(FromProtobufTypeError::InvalidArgument(
+                "missing relay settings",
+            ))?;
 
         match update_value {
             relay_settings_update::Type::Custom(settings) => {
diff --git a/mullvad-problem-report/src/lib.rs b/mullvad-problem-report/src/lib.rs
index 2570aa6c78..b5fdadc2fe 100644
--- a/mullvad-problem-report/src/lib.rs
+++ b/mullvad-problem-report/src/lib.rs
@@ -171,7 +171,7 @@ pub fn collect_report(
 
     problem_report.add_logs(extra_logs);
 
-    write_problem_report(&output_path, &problem_report).map_err(|source| Error::WriteReportError {
+    write_problem_report(output_path, &problem_report).map_err(|source| Error::WriteReportError {
         path: output_path.display().to_string(),
         source,
     })
@@ -291,8 +291,7 @@ async fn send_problem_report_inner(
     report_content: &str,
     cache_dir: &Path,
 ) -> Result<(), Error> {
-    let metadata =
-        ProblemReport::parse_metadata(&report_content).unwrap_or_else(|| metadata::collect());
+    let metadata = ProblemReport::parse_metadata(report_content).unwrap_or_else(metadata::collect);
     let api_runtime = mullvad_api::Runtime::with_cache(
         cache_dir,
         false,
@@ -315,7 +314,7 @@ async fn send_problem_report_inner(
 
     for _attempt in 0..MAX_SEND_ATTEMPTS {
         match api_client
-            .problem_report(user_email, user_message, &report_content, &metadata)
+            .problem_report(user_email, user_message, report_content, &metadata)
             .await
         {
             Ok(()) => {
diff --git a/mullvad-problem-report/src/main.rs b/mullvad-problem-report/src/main.rs
index 9d6b580e49..09d681fd25 100644
--- a/mullvad-problem-report/src/main.rs
+++ b/mullvad-problem-report/src/main.rs
@@ -107,7 +107,7 @@ fn run() -> Result<(), Error> {
             "Problem report written to {}",
             expanded_output_path.display()
         );
-        println!("");
+        println!();
         println!("Send the problem report to support via the send subcommand. See:");
         println!(" $ {} send --help", env::args().next().unwrap());
         Ok(())
diff --git a/mullvad-relay-selector/src/lib.rs b/mullvad-relay-selector/src/lib.rs
index e21eee96fc..158086b1d4 100644
--- a/mullvad-relay-selector/src/lib.rs
+++ b/mullvad-relay-selector/src/lib.rs
@@ -279,7 +279,7 @@ impl RelaySelector {
             }
             RelaySettings::Normal(constraints) => {
                 let relay =
-                    self.get_tunnel_endpoint(&constraints, config.bridge_state, retry_attempt)?;
+                    self.get_tunnel_endpoint(constraints, config.bridge_state, retry_attempt)?;
                 let bridge = match relay.endpoint {
                     MullvadEndpoint::OpenVpn(endpoint)
                         if endpoint.protocol == TransportProtocol::Tcp =>
@@ -300,7 +300,7 @@ impl RelaySelector {
                         self.get_obfuscator_inner(
                             &config,
                             obfuscator_relay,
-                            &endpoint,
+                            endpoint,
                             retry_attempt,
                         )?
                     }
@@ -324,7 +324,7 @@ impl RelaySelector {
                 &relay_constraints.location,
                 &relay_constraints.providers,
                 &relay_constraints.ownership,
-                relay_constraints.openvpn_constraints.clone(),
+                relay_constraints.openvpn_constraints,
                 bridge_state,
                 retry_attempt,
             ),
@@ -434,7 +434,7 @@ impl RelaySelector {
     ) -> Result<NormalSelectedRelay, Error> {
         let mut exit_matcher = RelayMatcher {
             location: exit_location,
-            tunnel: WIREGUARD_EXIT_CONSTRAINTS.clone().into(),
+            tunnel: WIREGUARD_EXIT_CONSTRAINTS.clone(),
             ..entry_matcher.clone()
         };
 
@@ -476,7 +476,7 @@ impl RelaySelector {
             entry_endpoint,
             entry_relay,
         );
-        return Ok(result);
+        Ok(result)
     }
 
     /// Returns a WireGuard endpoint, should only ever be used when the user has specified the
@@ -536,7 +536,7 @@ impl RelaySelector {
 
         // Pick the entry relay first if its location constraint is a subset of the exit location.
         if relay_constraints.wireguard_constraints.use_multihop {
-            matcher.tunnel.wireguard = WIREGUARD_EXIT_CONSTRAINTS.clone().into();
+            matcher.tunnel.wireguard = WIREGUARD_EXIT_CONSTRAINTS.clone();
             if relay_constraints
                 .wireguard_constraints
                 .entry_location
@@ -603,7 +603,7 @@ impl RelaySelector {
         retry_attempt: u32,
     ) -> Result<NormalSelectedRelay, Error> {
         let preferred_constraints =
-            self.preferred_constraints(&relay_constraints, bridge_state, retry_attempt);
+            self.preferred_constraints(relay_constraints, bridge_state, retry_attempt);
 
         if let Ok(result) = self.get_multihop_tunnel_endpoint_internal(&preferred_constraints) {
             log::debug!(
@@ -611,7 +611,7 @@ impl RelaySelector {
                 retry_attempt
             );
             Ok(result)
-        } else if let Ok(result) = self.get_multihop_tunnel_endpoint_internal(&relay_constraints) {
+        } else if let Ok(result) = self.get_multihop_tunnel_endpoint_internal(relay_constraints) {
             log::debug!(
                 "Relay matched on second preference for retry attempt {}",
                 retry_attempt
@@ -716,7 +716,7 @@ impl RelaySelector {
 
         let relay = self
             .pick_random_relay(&matching_relays)
-            .map(|relay| relay.clone())
+            .cloned()
             .ok_or(Error::NoRelay)?;
         let endpoint = matcher
             .mullvad_endpoint(&relay)
@@ -849,7 +849,7 @@ impl RelaySelector {
             self.pick_random_relay(&matching_relays)
         };
         relay.and_then(|relay| {
-            self.pick_random_bridge(&relay)
+            self.pick_random_bridge(relay)
                 .map(|bridge| (bridge, relay.clone()))
         })
     }
@@ -1060,7 +1060,7 @@ impl RelaySelector {
 
         self.pick_random_relay(&matching_relays)
             .and_then(|selected_relay| {
-                let endpoint = matcher.mullvad_endpoint(&selected_relay);
+                let endpoint = matcher.mullvad_endpoint(selected_relay);
                 let addr_in = endpoint
                     .as_ref()
                     .map(|endpoint| endpoint.to_endpoint().address.ip())
@@ -1444,7 +1444,7 @@ mod test {
             "se9-wireguard".to_string(),
         );
         let relay_constraints = RelayConstraints {
-            location: Constraint::Only(location.clone()),
+            location: Constraint::Only(location),
             tunnel_protocol: Constraint::Any,
             ..RelayConstraints::default()
         };
@@ -1469,7 +1469,7 @@ mod test {
             "se-got-001".to_string(),
         );
         let relay_constraints = RelayConstraints {
-            location: Constraint::Only(location.clone()),
+            location: Constraint::Only(location),
             tunnel_protocol: Constraint::Any,
             ..RelayConstraints::default()
         };
@@ -1615,7 +1615,7 @@ mod test {
             "se-got-001".to_string(),
         );
         let mut relay_constraints = RelayConstraints {
-            location: Constraint::Only(location.clone()),
+            location: Constraint::Only(location),
             tunnel_protocol: Constraint::Any,
             ..RelayConstraints::default()
         };
diff --git a/mullvad-relay-selector/src/matcher.rs b/mullvad-relay-selector/src/matcher.rs
index 3e88777b81..089510a6c0 100644
--- a/mullvad-relay-selector/src/matcher.rs
+++ b/mullvad-relay-selector/src/matcher.rs
@@ -155,7 +155,7 @@ impl TunnelMatcher for AnyTunnelMatcher {
                 self.wireguard.mullvad_endpoint(relay),
             ]
             .into_iter()
-            .filter_map(|relay| relay)
+            .flatten()
             .collect::<Vec<_>>()
             .choose(&mut rand::thread_rng())
             .cloned(),
diff --git a/mullvad-relay-selector/src/updater.rs b/mullvad-relay-selector/src/updater.rs
index fe5088704d..480be795fb 100644
--- a/mullvad-relay-selector/src/updater.rs
+++ b/mullvad-relay-selector/src/updater.rs
@@ -69,7 +69,7 @@ impl RelayListUpdater {
         let updater = RelayListUpdater {
             api_client,
             cache_path: cache_dir.join(super::RELAYS_FILENAME),
-            parsed_relays: selector.parsed_relays.clone(),
+            parsed_relays: selector.parsed_relays,
             on_update: Box::new(on_update),
             last_check: UNIX_EPOCH,
             api_availability,
@@ -165,12 +165,11 @@ impl RelayListUpdater {
             ExponentialBackoff::new(EXPONENTIAL_BACKOFF_INITIAL, EXPONENTIAL_BACKOFF_FACTOR)
                 .max_delay(UPDATE_INTERVAL * 2);
 
-        let download_future = retry_future(
+        retry_future(
             download_futures,
             |result| result.is_err(),
             Jittered::jitter(exponential_backoff),
-        );
-        download_future
+        )
     }
 
     async fn update_cache(&mut self, new_relay_list: RelayList) -> Result<(), Error> {
diff --git a/mullvad-types/src/custom_tunnel.rs b/mullvad-types/src/custom_tunnel.rs
index 7cbfcc609f..dfbea72c7d 100644
--- a/mullvad-types/src/custom_tunnel.rs
+++ b/mullvad-types/src/custom_tunnel.rs
@@ -52,14 +52,14 @@ impl CustomTunnelEndpoint {
             ConnectionConfig::OpenVpn(config) => openvpn::TunnelParameters {
                 config,
                 options: tunnel_options.openvpn.clone(),
-                generic_options: tunnel_options.generic.clone(),
+                generic_options: tunnel_options.generic,
                 proxy,
             }
             .into(),
             ConnectionConfig::Wireguard(connection) => wireguard::TunnelParameters {
                 connection,
                 options: tunnel_options.wireguard.options.clone(),
-                generic_options: tunnel_options.generic.clone(),
+                generic_options: tunnel_options.generic,
                 obfuscation: None,
             }
             .into(),
diff --git a/mullvad-types/src/location.rs b/mullvad-types/src/location.rs
index 92352ef146..6453d17717 100644
--- a/mullvad-types/src/location.rs
+++ b/mullvad-types/src/location.rs
@@ -198,7 +198,7 @@ mod tests {
         use super::haversine_dist_deg;
         assert_eq!(
             haversine_dist_deg(36.12, -86.67, 33.94, -118.4),
-            2887.2599506071111
+            2_887.259_950_607_111
         );
         assert_eq!(
             haversine_dist_deg(90.0, 5.0, 90.0, 79.0),
diff --git a/mullvad-types/src/relay_constraints.rs b/mullvad-types/src/relay_constraints.rs
index 7dff97d1e4..8da12d579b 100644
--- a/mullvad-types/src/relay_constraints.rs
+++ b/mullvad-types/src/relay_constraints.rs
@@ -213,16 +213,14 @@ impl RelayConstraints {
         RelayConstraints {
             location: update.location.unwrap_or_else(|| self.location.clone()),
             providers: update.providers.unwrap_or_else(|| self.providers.clone()),
-            ownership: update.ownership.unwrap_or_else(|| self.ownership.clone()),
-            tunnel_protocol: update
-                .tunnel_protocol
-                .unwrap_or_else(|| self.tunnel_protocol.clone()),
+            ownership: update.ownership.unwrap_or(self.ownership),
+            tunnel_protocol: update.tunnel_protocol.unwrap_or(self.tunnel_protocol),
             wireguard_constraints: update
                 .wireguard_constraints
                 .unwrap_or_else(|| self.wireguard_constraints.clone()),
             openvpn_constraints: update
                 .openvpn_constraints
-                .unwrap_or_else(|| self.openvpn_constraints.clone()),
+                .unwrap_or(self.openvpn_constraints),
         }
     }
 }
@@ -329,7 +327,7 @@ impl Set<LocationConstraint> for LocationConstraint {
 }
 
 /// Limits the set of servers to choose based on ownership.
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
+#[derive(Copy, Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
 pub enum Ownership {
     MullvadOwned,
     Rented,
diff --git a/mullvad-types/src/version.rs b/mullvad-types/src/version.rs
index 46d39dc417..16466f8259 100644
--- a/mullvad-types/src/version.rs
+++ b/mullvad-types/src/version.rs
@@ -194,7 +194,7 @@ mod test {
         ];
 
         for (input, expected_output) in tests {
-            assert_eq!(ParsedAppVersion::from_str(&input), expected_output,);
+            assert_eq!(ParsedAppVersion::from_str(input), expected_output,);
         }
     }
 }
diff --git a/talpid-dbus/src/network_manager.rs b/talpid-dbus/src/network_manager.rs
index 272243ee23..87566891d1 100644
--- a/talpid-dbus/src/network_manager.rs
+++ b/talpid-dbus/src/network_manager.rs
@@ -56,7 +56,7 @@ const MINIMUM_SUPPORTED_MINOR_VERSION: u32 = 16;
 const MAXIMUM_SUPPORTED_MAJOR_VERSION: u32 = 1;
 const MAXIMUM_SUPPORTED_MINOR_VERSION: u32 = 26;
 
-const NM_DEVICE_STATE_CHANGED: &'static str = "StateChanged";
+const NM_DEVICE_STATE_CHANGED: &str = "StateChanged";
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -155,10 +155,10 @@ impl NetworkManager {
     }
 
     fn create_wg_tunnel_inner(&self, config: &DeviceConfig) -> Result<WireguardTunnel> {
-        let config_path: dbus::Path<'static> = match self.add_connection_2(&config) {
+        let config_path: dbus::Path<'static> = match self.add_connection_2(config) {
             Ok((path, _result)) => path,
             Err(Error::Dbus(dbus_error)) if dbus_error.name() == Some(DBUS_UNKNOWN_METHOD) => {
-                self.add_connection_unsaved(&config)?.0
+                self.add_connection_unsaved(config)?.0
             }
             Err(err) => {
                 log::error!(
@@ -238,7 +238,7 @@ impl NetworkManager {
     }
 
     fn parse_nm_version(version: &str) -> Option<(u32, u32)> {
-        let mut parts = version.split(".").map(|part| part.parse().ok());
+        let mut parts = version.split('.').map(|part| part.parse().ok());
 
         let major_version: u32 = parts.next()??;
         let minor_version: u32 = parts.next()??;
@@ -382,7 +382,7 @@ impl NetworkManager {
     pub fn ensure_network_manager_exists(&self) -> Result<()> {
         match self
             .as_manager()
-            .get::<Box<dyn RefArg>>(&NM_MANAGER, "Version")
+            .get::<Box<dyn RefArg>>(NM_MANAGER, "Version")
         {
             Ok(_) => Ok(()),
             Err(err) => {
@@ -534,7 +534,7 @@ impl NetworkManager {
             .filter_map(|server| {
                 match server {
                     // Network-byte order
-                    IpAddr::V4(server) => Some(u32::to_be(server.clone().into())),
+                    IpAddr::V4(server) => Some(u32::to_be((*server).into())),
                     IpAddr::V6(_) => None,
                 }
             })
@@ -610,12 +610,12 @@ impl NetworkManager {
             .as_manager()
             .get(NM_MANAGER, "Devices")
             .map_err(Error::Dbus)?;
-        let mut iter = devices
+        let iter = devices
             .as_iter()
             .ok_or(Error::ObtainDevices)?
             .map(|device| device.box_clone());
 
-        while let Some(device_item) = iter.next() {
+        for device_item in iter {
             // Copy due to lifetime weirdness
             let device_path = device_item
                 .as_any()
@@ -623,7 +623,7 @@ impl NetworkManager {
                 .ok_or(Error::ObtainDevices)?;
 
             let device_name: String = self
-                .as_path(&device_path)
+                .as_path(device_path)
                 .get(NM_DEVICE, "Interface")
                 .map_err(Error::Dbus)?;
 
diff --git a/talpid-dbus/src/systemd_resolved.rs b/talpid-dbus/src/systemd_resolved.rs
index b68c3a08d9..99b73980d8 100644
--- a/talpid-dbus/src/systemd_resolved.rs
+++ b/talpid-dbus/src/systemd_resolved.rs
@@ -128,7 +128,7 @@ impl SystemdResolved {
     pub fn ensure_resolved_exists(&self) -> Result<()> {
         let _: Box<dyn RefArg> = self
             .as_manager_object()
-            .get(&MANAGER_INTERFACE, "DNS")
+            .get(MANAGER_INTERFACE, "DNS")
             .map_err(Error::NoSystemdResolved)?;
 
         Ok(())
@@ -483,7 +483,7 @@ impl DnsServer {
 
         let ip_bytes = iter.next()?.box_clone();
         let ip_bytes: &Vec<u8> = arg::cast(&ip_bytes)?;
-        let address = ip_from_bytes(&ip_bytes)?;
+        let address = ip_from_bytes(ip_bytes)?;
         Some(Self {
             iface_index,
             address_family,
diff --git a/talpid-openvpn-plugin/src/lib.rs b/talpid-openvpn-plugin/src/lib.rs
index 3bec7f11e7..943ee8dabc 100644
--- a/talpid-openvpn-plugin/src/lib.rs
+++ b/talpid-openvpn-plugin/src/lib.rs
@@ -34,7 +34,7 @@ pub enum Error {
 
 /// All the OpenVPN events this plugin will register for listening to. Edit this variable to change
 /// events.
-pub static INTERESTING_EVENTS: &'static [EventType] = &[
+pub static INTERESTING_EVENTS: &[EventType] = &[
     EventType::AuthFailed,
     EventType::Up,
     EventType::RouteUp,
@@ -75,7 +75,7 @@ fn parse_args(args: &[CString]) -> Result<Arguments, Error> {
         .into_iter();
 
     let _plugin_path = args_iter.next();
-    let ipc_socket_path: String = args_iter.next().ok_or_else(|| Error::MissingCoreServerId)?;
+    let ipc_socket_path: String = args_iter.next().ok_or(Error::MissingCoreServerId)?;
 
     Ok(Arguments { ipc_socket_path })
 }
diff --git a/talpid-openvpn-plugin/src/processing.rs b/talpid-openvpn-plugin/src/processing.rs
index 10186ed0f6..ba0b76a34d 100644
--- a/talpid-openvpn-plugin/src/processing.rs
+++ b/talpid-openvpn-plugin/src/processing.rs
@@ -29,7 +29,7 @@ impl EventProcessor {
             .build()
             .map_err(Error::CreateRuntime)?;
         let ipc_client = runtime
-            .block_on(Self::spawn_client(arguments.ipc_socket_path.clone()))
+            .block_on(Self::spawn_client(arguments.ipc_socket_path))
             .map_err(Error::CreateTransport)?;
 
         Ok(EventProcessor {
diff --git a/talpid-types/src/net/mod.rs b/talpid-types/src/net/mod.rs
index 270c0c769d..36bfba4f9d 100644
--- a/talpid-types/src/net/mod.rs
+++ b/talpid-types/src/net/mod.rs
@@ -41,10 +41,7 @@ impl TunnelParameters {
                     .get_exit_endpoint()
                     .unwrap_or(params.connection.get_endpoint()),
                 proxy: None,
-                obfuscation: params
-                    .obfuscation
-                    .as_ref()
-                    .map(|obfs| ObfuscationEndpoint::from(obfs)),
+                obfuscation: params.obfuscation.as_ref().map(ObfuscationEndpoint::from),
                 entry_endpoint: params
                     .connection
                     .get_exit_endpoint()
@@ -64,7 +61,7 @@ impl TunnelParameters {
             TunnelParameters::Wireguard(params) => params
                 .obfuscation
                 .as_ref()
-                .map(|obfuscator| Self::get_obfuscator_endpoint(obfuscator))
+                .map(Self::get_obfuscator_endpoint)
                 .unwrap_or(params.connection.get_endpoint()),
         }
     }
diff --git a/talpid-types/src/net/wireguard.rs b/talpid-types/src/net/wireguard.rs
index 2b3a9054b5..199ff3bd29 100644
--- a/talpid-types/src/net/wireguard.rs
+++ b/talpid-types/src/net/wireguard.rs
@@ -214,7 +214,7 @@ impl Serialize for PublicKey {
     where
         S: Serializer,
     {
-        serialize_key(&self.0.as_bytes(), serializer)
+        serialize_key(self.0.as_bytes(), serializer)
     }
 }