Merge branch 'clippy-semantic-manual-fixes'

Author: Jontified

android/translations-converter/src/android/string_value.rs

@@ -84,13 +84,6 @@ impl StringValue {
     }
 }
 
-impl StringValue {
-    /// Clones the internal string value.
-    pub fn to_string(&self) -> String {
-        self.0.clone()
-    }
-}
-
 impl Deref for StringValue {
     type Target = str;
 

clippy.toml

@@ -0,0 +1 @@
+enum-variant-size-threshold = 1000

mullvad-api/src/address_cache.rs

@@ -10,19 +10,16 @@ use tokio::{
 #[error(no_from)]
 pub enum Error {
     #[error(display = "Failed to open the address cache file")]
-    OpenAddressCache(#[error(source)] io::Error),
+    Open(#[error(source)] io::Error),
 
     #[error(display = "Failed to read the address cache file")]
-    ReadAddressCache(#[error(source)] io::Error),
+    Read(#[error(source)] io::Error),
 
     #[error(display = "Failed to parse the address cache file")]
-    ParseAddressCache,
+    Parse,
 
     #[error(display = "Failed to update the address cache file")]
-    WriteAddressCache(#[error(source)] io::Error),
-
-    #[error(display = "The address cache is empty")]
-    EmptyAddressCache,
+    Write(#[error(source)] io::Error),
 }
 
 #[derive(Clone)]
@@ -68,7 +65,7 @@ impl AddressCache {
         self.inner.lock().await.address
     }
 
-    pub async fn set_address(&self, address: SocketAddr) -> io::Result<()> {
+    pub async fn set_address(&self, address: SocketAddr) -> Result<(), Error> {
         let mut inner = self.inner.lock().await;
         if address != inner.address {
             self.save_to_disk(&address).await?;
@@ -77,17 +74,21 @@ impl AddressCache {
         Ok(())
     }
 
-    async fn save_to_disk(&self, address: &SocketAddr) -> io::Result<()> {
+    async fn save_to_disk(&self, address: &SocketAddr) -> Result<(), Error> {
         let write_path = match self.write_path.as_ref() {
             Some(write_path) => write_path,
             None => return Ok(()),
         };
 
-        let mut file = crate::fs::AtomicFile::new(write_path.to_path_buf()).await?;
+        let mut file = crate::fs::AtomicFile::new(write_path.to_path_buf())
+            .await
+            .map_err(Error::Open)?;
         let mut contents = address.to_string();
         contents += "\n";
-        file.write_all(contents.as_bytes()).await?;
-        file.finalize().await
+        file.write_all(contents.as_bytes())
+            .await
+            .map_err(Error::Write)?;
+        file.finalize().await.map_err(Error::Write)
     }
 }
 
@@ -103,12 +104,10 @@ impl AddressCacheInner {
 }
 
 async fn read_address_file(path: &Path) -> Result<SocketAddr, Error> {
-    let mut file = fs::File::open(path)
-        .await
-        .map_err(Error::OpenAddressCache)?;
+    let mut file = fs::File::open(path).await.map_err(Error::Open)?;
     let mut address = String::new();
     file.read_to_string(&mut address)
         .await
-        .map_err(Error::ReadAddressCache)?;
-    address.trim().parse().map_err(|_| Error::ParseAddressCache)
+        .map_err(Error::Read)?;
+    address.trim().parse().map_err(|_| Error::Parse)
 }

mullvad-api/src/https_client_with_sni.rs

@@ -304,7 +304,7 @@ impl Service<Uri> for HttpsConnectorWithSni {
                             )
                             .await?;
                             let tls_stream = TlsStream::connect_https(socket, &hostname).await?;
-                            Ok::<_, io::Error>(ApiConnection::Direct(tls_stream))
+                            Ok::<_, io::Error>(ApiConnection::Direct(Box::new(tls_stream)))
                         }
                         InnerConnectionMode::Proxied(proxy_config) => {
                             let socket = Self::open_socket(
@@ -320,7 +320,7 @@ impl Service<Uri> for HttpsConnectorWithSni {
                                 addr,
                             );
                             let tls_stream = TlsStream::connect_https(proxy, &hostname).await?;
-                            Ok(ApiConnection::Proxied(tls_stream))
+                            Ok(ApiConnection::Proxied(Box::new(tls_stream)))
                         }
                     }
                 };

mullvad-api/src/lib.rs

@@ -236,7 +236,7 @@ impl Runtime {
         new_address_callback: impl ApiEndpointUpdateCallback + Send + Sync + 'static,
         #[cfg(target_os = "android")] socket_bypass_tx: Option<mpsc::Sender<SocketBypassRequest>>,
     ) -> rest::RequestServiceHandle {
-        let service_handle = rest::RequestService::new(
+        let service_handle = rest::RequestService::spawn(
             sni_hostname,
             self.api_availability.handle(),
             self.address_cache.clone(),

mullvad-api/src/proxy.rs

@@ -132,8 +132,8 @@ impl ApiConnectionMode {
 
 /// Stream that is either a regular TLS stream or TLS via shadowsocks
 pub enum ApiConnection {
-    Direct(TlsStream<TcpStream>),
-    Proxied(TlsStream<ProxyClientStream<TcpStream>>),
+    Direct(Box<TlsStream<TcpStream>>),
+    Proxied(Box<TlsStream<ProxyClientStream<TcpStream>>>),
 }
 
 impl AsyncRead for ApiConnection {

mullvad-api/src/relay_list.rs

@@ -130,7 +130,7 @@ impl ServerRelayList {
     ) {
         let openvpn_endpoint_data = openvpn.ports;
         for mut openvpn_relay in openvpn.relays.into_iter() {
-            openvpn_relay.to_lower();
+            openvpn_relay.convert_to_lowercase();
             if let Some((country_code, city_code)) = split_location_code(&openvpn_relay.location) {
                 if let Some(country) = countries.get_mut(country_code) {
                     if let Some(city) = country
@@ -184,7 +184,7 @@ impl ServerRelayList {
             };
 
         for mut wireguard_relay in relays {
-            wireguard_relay.relay.to_lower();
+            wireguard_relay.relay.convert_to_lowercase();
             if let Some((country_code, city_code)) =
                 split_location_code(&wireguard_relay.relay.location)
             {
@@ -235,7 +235,7 @@ impl ServerRelayList {
         } = bridges;
 
         for mut bridge_relay in relays {
-            bridge_relay.to_lower();
+            bridge_relay.convert_to_lowercase();
             if let Some((country_code, city_code)) = split_location_code(&bridge_relay.location) {
                 if let Some(country) = countries.get_mut(country_code) {
                     if let Some(city) = country
@@ -345,7 +345,7 @@ struct Relay {
 }
 
 impl Relay {
-    fn to_lower(&mut self) {
+    fn convert_to_lowercase(&mut self) {
         self.hostname = self.hostname.to_lowercase();
         self.location = self.location.to_lowercase();
     }

mullvad-api/src/rest.rs

@@ -130,7 +130,7 @@ impl<
     > RequestService<T, F>
 {
     /// Constructs a new request service.
-    pub async fn new(
+    pub async fn spawn(
         sni_hostname: Option<String>,
         api_availability: ApiAvailabilityHandle,
         address_cache: AddressCache,

mullvad-daemon/src/cleanup.rs

@@ -7,26 +7,26 @@ use tokio::{fs, io};
 #[error(no_from)]
 pub enum Error {
     #[error(display = "Failed to get path")]
-    PathError(#[error(source)] mullvad_paths::Error),
+    Path(#[error(source)] mullvad_paths::Error),
 
     #[error(display = "Failed to remove directory {}", _0)]
-    RemoveDirError(String, #[error(source)] io::Error),
+    RemoveDir(String, #[error(source)] io::Error),
 
     #[cfg(not(target_os = "windows"))]
     #[error(display = "Failed to create directory {}", _0)]
-    CreateDirError(String, #[error(source)] io::Error),
+    CreateDir(String, #[error(source)] io::Error),
 
     #[cfg(target_os = "windows")]
     #[error(display = "Failed to get file type info")]
-    FileTypeError(#[error(source)] io::Error),
+    FileType(#[error(source)] io::Error),
 
     #[cfg(target_os = "windows")]
     #[error(display = "Failed to get dir entry")]
-    FileEntryError(#[error(source)] io::Error),
+    FileEntry(#[error(source)] io::Error),
 
     #[cfg(target_os = "windows")]
     #[error(display = "Failed to read dir entries")]
-    ReadDirError(#[error(source)] io::Error),
+    ReadDir(#[error(source)] io::Error),
 }
 
 pub async fn clear_directories() -> Result<(), Error> {
@@ -35,12 +35,12 @@ pub async fn clear_directories() -> Result<(), Error> {
 }
 
 async fn clear_log_directory() -> Result<(), Error> {
-    let log_dir = mullvad_paths::get_log_dir().map_err(Error::PathError)?;
+    let log_dir = mullvad_paths::get_log_dir().map_err(Error::Path)?;
     clear_directory(&log_dir).await
 }
 
 async fn clear_cache_directory() -> Result<(), Error> {
-    let cache_dir = mullvad_paths::cache_dir().map_err(Error::PathError)?;
+    let cache_dir = mullvad_paths::cache_dir().map_err(Error::Path)?;
     clear_directory(&cache_dir).await
 }
 
@@ -49,22 +49,22 @@ async fn clear_directory(path: &Path) -> Result<(), Error> {
     {
         fs::remove_dir_all(path)
             .await
-            .map_err(|e| Error::RemoveDirError(path.display().to_string(), e))?;
+            .map_err(|e| Error::RemoveDir(path.display().to_string(), e))?;
         fs::create_dir_all(path)
             .await
-            .map_err(|e| Error::CreateDirError(path.display().to_string(), e))
+            .map_err(|e| Error::CreateDir(path.display().to_string(), e))
     }
     #[cfg(target_os = "windows")]
     {
-        let mut dir = fs::read_dir(&path).await.map_err(Error::ReadDirError)?;
+        let mut dir = fs::read_dir(&path).await.map_err(Error::ReadDir)?;
 
         let mut result = Ok(());
 
-        while let Some(entry) = dir.next_entry().await.map_err(Error::FileEntryError)? {
+        while let Some(entry) = dir.next_entry().await.map_err(Error::FileEntry)? {
             let entry_type = match entry.file_type().await {
                 Ok(entry_type) => entry_type,
                 Err(error) => {
-                    result = result.and(Err(Error::FileTypeError(error)));
+                    result = result.and(Err(Error::FileType(error)));
                     continue;
                 }
             };
@@ -74,9 +74,8 @@ async fn clear_directory(path: &Path) -> Result<(), Error> {
             } else {
                 fs::remove_dir_all(entry.path()).await
             };
-            result = result.and(
-                removal.map_err(|e| Error::RemoveDirError(entry.path().display().to_string(), e)),
-            );
+            result = result
+                .and(removal.map_err(|e| Error::RemoveDir(entry.path().display().to_string(), e)));
         }
         result
     }

mullvad-daemon/src/device/api.rs

@@ -35,10 +35,10 @@ impl CurrentApiCall {
     }
 
     pub fn is_validating(&self) -> bool {
-        match &self.current_call {
-            Some(Call::Validation(_)) | Some(Call::OneshotKeyRotation(_)) => true,
-            _ => false,
-        }
+        matches!(
+            &self.current_call,
+            Some(Call::Validation(_)) | Some(Call::OneshotKeyRotation(_))
+        )
     }
 
     pub fn is_running_timed_totation(&self) -> bool {
@@ -51,10 +51,7 @@ impl CurrentApiCall {
 
     pub fn is_logging_in(&self) -> bool {
         use Call::*;
-        match &self.current_call {
-            Some(Login(..)) => true,
-            _ => false,
-        }
+        matches!(&self.current_call, Some(Login(..)))
     }
 }
 

mullvad-daemon/src/exception_logging/unix.rs

@@ -5,7 +5,7 @@ use nix::sys::signal::{sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal
 
 use std::{convert::TryFrom, sync::Once};
 
-const INIT_ONCE: Once = Once::new();
+static INIT_ONCE: Once = Once::new();
 
 const FAULT_SIGNALS: [Signal; 5] = [
     // Access to invalid memory address