Fix clippy warnings (#122)

* Fix clippy warnings

* Fix new warnings

client_listener/examples/restart.rs

@@ -62,7 +62,7 @@ async fn do_restart(
 ) -> ! {
     let data = SaveData {
         listeners: listeners.save().await.unwrap(),
-        connections: connections.into_iter().map(|(_, c)| c.save()).collect(),
+        connections: connections.into_values().map(|c| c.save()).collect(),
     };
     let fd = to_memfd(data).unwrap();
 

client_listener/src/internal/connection.rs

@@ -2,7 +2,7 @@ use crate::internal::*;
 use crate::*;
 
 use sha1::{Digest, Sha1};
-use std::{convert::TryInto, net::IpAddr};
+use std::net::IpAddr;
 use tokio::{
     io::AsyncWriteExt,
     net::TcpStream,
@@ -44,12 +44,11 @@ impl InternalConnection {
                             .get_ref()
                             .1
                             .peer_certificates()
-                            .map(|c| c.get(0))
-                            .flatten()
+                            .and_then(|c| c.first())
                             .map(|cert| {
                                 let mut hasher = Sha1::new();
                                 hasher.update(&cert.0);
-                                hex::encode(hasher.finalize()).as_str().try_into().unwrap()
+                                hex::encode(hasher.finalize()).as_str().into()
                             });
 
                         tls_info = Some(TlsInfo { fingerprint });
@@ -80,7 +79,11 @@ impl InternalConnection {
             tls_info,
         };
 
-        if let Err(_) = events.send(InternalConnectionEventType::New(conn)).await {
+        if events
+            .send(InternalConnectionEventType::New(conn))
+            .await
+            .is_err()
+        {
             tracing::error!("Error sending new connection");
         };
 

sable_ipc/src/lib.rs

@@ -114,13 +114,10 @@ pub struct Receiver<T: DeserializeOwned> {
 
 impl<T: DeserializeOwned> Receiver<T> {
     fn new(socket: UnixDatagram, max_len: u64) -> Self {
-        let mut recv_buf = Vec::new();
-        recv_buf.resize(max_len as usize, 0u8);
-
         Self {
             socket: Some(socket),
             max_len,
-            recv_buffer: Mutex::new(recv_buf),
+            recv_buffer: Mutex::new(vec![0u8; max_len as usize]),
             _phantom: PhantomData,
         }
     }

sable_ircd/src/capability/mod.rs

@@ -116,7 +116,7 @@ impl ClientCapabilitySet {
         self.0 &= !(cap as u64);
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = ClientCapability> + 'a {
+    pub fn iter(&self) -> impl Iterator<Item = ClientCapability> + '_ {
         ClientCapability::ALL
             .iter()
             .cloned()
@@ -156,7 +156,7 @@ impl AtomicCapabilitySet {
         self.0.fetch_and(!(cap as u64), Ordering::Relaxed);
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = ClientCapability> + 'a {
+    pub fn iter(&self) -> impl Iterator<Item = ClientCapability> + '_ {
         ClientCapability::ALL
             .iter()
             .cloned()

sable_ircd/src/capability/repository.rs

@@ -103,11 +103,11 @@ impl CapabilityRepository {
             self.update_supported_lists();
         }
     */
-    pub fn enable_with_values(&self, cap: ClientCapability, values: &Vec<String>) {
+    pub fn enable_with_values(&self, cap: ClientCapability, values: &[String]) {
         for entry in &self.supported_caps {
             if entry.cap == cap {
                 entry.available.store(true, Ordering::Relaxed);
-                std::mem::swap(entry.values.write().as_mut(), &mut values.clone())
+                std::mem::swap(entry.values.write().as_mut(), &mut values.to_owned())
             }
         }
         self.update_supported_lists();

sable_ircd/src/command/client_command.rs

@@ -18,7 +18,7 @@ impl<'a> CommandSource<'a> {
     pub fn user(&self) -> Option<&wrapper::User<'a>> {
         match self {
             Self::PreClient(_) => None,
-            Self::User(u, _) => Some(&u),
+            Self::User(u, _) => Some(u),
         }
     }
 
@@ -72,7 +72,7 @@ impl ClientCommand {
         message: ClientMessage,
     ) -> Result<Self, CommandError> {
         let net = server.network();
-        let source = Self::translate_message_source(&*net, &*connection)?;
+        let source = Self::translate_message_source(&net, &connection)?;
         let response_target = Self::translate_internal_source(&source, net.as_ref()).format();
         let response_sink = Self::make_response_sink(
             Arc::clone(&connection),

sable_ircd/src/command/handlers/admin.rs

@@ -4,20 +4,17 @@ use super::*;
 fn handle_admin(server: &ClientServer, response: &dyn CommandResponse) -> CommandResult {
     response.numeric(make_numeric!(AdminMe, server.name()));
     if let Some(admin_info) = &server.info_strings.admin_info {
-        admin_info
-            .server_location
-            .as_ref()
-            .map(|i| response.numeric(make_numeric!(AdminLocation1, i)));
+        if let Some(i) = admin_info.server_location.as_ref() {
+            response.numeric(make_numeric!(AdminLocation1, i))
+        }
 
-        admin_info
-            .description
-            .as_ref()
-            .map(|i| response.numeric(make_numeric!(AdminLocation2, i)));
+        if let Some(i) = admin_info.description.as_ref() {
+            response.numeric(make_numeric!(AdminLocation2, i))
+        }
 
-        admin_info
-            .email
-            .as_ref()
-            .map(|i| response.numeric(make_numeric!(AdminEmail, i)));
+        if let Some(i) = admin_info.email.as_ref() {
+            response.numeric(make_numeric!(AdminEmail, i))
+        }
     }
     Ok(())
 }

sable_ircd/src/command/handlers/chathistory.rs

@@ -34,6 +34,7 @@ fn parse_msgref(subcommand: &str, target: Option<&str>, msgref: &str) -> Result<
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 #[command_handler("CHATHISTORY")]
 fn handle_chathistory(
     source: UserSource,
@@ -66,7 +67,7 @@ fn handle_chathistory(
             // The spec allows the from and to timestamps in either order; list_targets requires from < to
             list_targets(
                 server,
-                &response,
+                response,
                 source,
                 Some(min(from_ts, to_ts)),
                 Some(max(from_ts, to_ts)),
@@ -93,10 +94,10 @@ fn handle_chathistory(
 
             send_history_for_target(
                 server,
-                &response,
+                response,
                 source,
                 subcommand,
-                &target,
+                target,
                 None,
                 to_ts,
                 limit,
@@ -120,7 +121,7 @@ fn handle_chathistory(
 
             send_history_for_target(
                 server,
-                &response,
+                response,
                 source,
                 subcommand,
                 target,
@@ -147,10 +148,10 @@ fn handle_chathistory(
 
             send_history_for_target(
                 server,
-                &response,
+                response,
                 source,
                 subcommand,
-                &target,
+                target,
                 Some(start_ts),
                 None,
                 Some(0), // backward limit
@@ -176,10 +177,10 @@ fn handle_chathistory(
 
             send_history_for_target(
                 server,
-                &response,
+                response,
                 source,
                 subcommand,
-                &target,
+                target,
                 Some(around_ts),
                 None,
                 Some(limit / 2), // backward limit
@@ -204,10 +205,10 @@ fn handle_chathistory(
 
             send_history_for_target(
                 server,
-                &response,
+                response,
                 source,
                 subcommand,
-                &target,
+                target,
                 Some(start_ts),
                 Some(end_ts),
                 Some(0), // backward limit
@@ -371,7 +372,7 @@ fn send_history_entries<'a>(
     backward_entries: Vec<&'a HistoryLogEntry>,
     forward_entries: Vec<&'a HistoryLogEntry>,
 ) -> CommandResult {
-    if backward_entries.len() == 0 && forward_entries.len() == 0 {
+    if backward_entries.is_empty() && forward_entries.is_empty() {
         into.send(message::Fail::new(
             "CHATHISTORY",
             "INVALID_TARGET",

sable_ircd/src/command/handlers/mode.rs

@@ -70,7 +70,7 @@ async fn handle_user_mode(
         if let Ok(d) = Direction::try_from(c) {
             dir = d;
         } else if let Some(flag) = UserModeFlag::from_mode_char(c) {
-            if server.policy().can_set_umode(&source, flag).is_err() {
+            if server.policy().can_set_umode(source, flag).is_err() {
                 continue;
             }
 

sable_ircd/src/command/handlers/monitor.rs

@@ -36,8 +36,7 @@ fn handle_monitor_add(
     let mut monitors = server.monitors.write();
     let res = targets
         .iter()
-        .map(|&target| monitors.insert(target, cmd.connection_id()))
-        .collect::<Result<(), _>>()
+        .try_for_each(|&target| monitors.insert(target, cmd.connection_id()))
         .map_err(
             |MonitorInsertError::TooManyMonitorsPerConnection { max, current }| {
                 CommandError::Numeric(make_numeric!(MonListFull, max, current))

sable_ircd/src/command/handlers/names.rs

@@ -9,7 +9,7 @@ fn handle_names(
 ) -> CommandResult {
     match channel {
         Ok(channel) => Ok(crate::utils::send_channel_names(
-            server, &response, &source, &channel,
+            server, response, &source, &channel,
         )?),
         Err(channel_name) => {
             // "If the channel name is invalid or the channel does not exist, one RPL_ENDOFNAMES numeric

sable_ircd/src/command/handlers/notice.rs

@@ -31,7 +31,7 @@ async fn handle_notice(
          */
         return Ok(());
     };
-    if msg.len() == 0 {
+    if msg.is_empty() {
         // Ditto
         return Ok(());
     }
@@ -44,7 +44,7 @@ async fn handle_notice(
             }
         }
         TargetParameter::Channel(channel) => {
-            if server.policy().can_send(&source, &channel, msg).is_err() {
+            if server.policy().can_send(&source, channel, msg).is_err() {
                 // Silent error, see above
                 return Ok(());
             }

sable_ircd/src/command/handlers/oper.rs

@@ -40,10 +40,5 @@ fn find_oper_block<'a>(
 ) -> Option<&'a config::OperConfig> {
     let conf = net.config();
 
-    for block in &conf.opers {
-        if block.name == oper_name {
-            return Some(block);
-        }
-    }
-    None
+    conf.opers.iter().find(|&block| block.name == oper_name)
 }

sable_ircd/src/command/handlers/privmsg.rs

@@ -10,14 +10,14 @@ async fn handle_privmsg(
     target: TargetParameter<'_>,
     msg: &str,
 ) -> CommandResult {
-    if msg.len() == 0 {
+    if msg.is_empty() {
         return numeric_error!(NoTextToSend);
     }
 
     match &target {
         TargetParameter::User(user) => {
             if let Some(AliasUser { command_alias, .. }) = user.is_alias_user() {
-                return super::services::dispatch_alias_command(cmd, &user, &command_alias, msg)
+                return super::services::dispatch_alias_command(cmd, user, command_alias, msg)
                     .await;
             }
 
@@ -26,7 +26,7 @@ async fn handle_privmsg(
             }
         }
         TargetParameter::Channel(channel) => {
-            server.policy().can_send(&source, &channel, msg)?;
+            server.policy().can_send(&source, channel, msg)?;
         }
     }
 

sable_ircd/src/command/handlers/rename.rs

@@ -1,5 +1,6 @@
 use super::*;
 
+#[allow(clippy::too_many_arguments)]
 #[command_handler("RENAME")]
 async fn handle_rename(
     server: &ClientServer,

sable_ircd/src/command/handlers/services/cs/role.rs

@@ -78,7 +78,7 @@ async fn role_edit(
         let (adding, flag_name) = match flag_str.as_bytes()[0] {
             b'+' => (true, &flag_str[1..]),
             b'-' => (false, &flag_str[1..]),
-            _ => (true, &flag_str[..]),
+            _ => (true, flag_str),
         };
 
         let Ok(flag) = ChannelAccessFlag::from_str(flag_name) else {
@@ -154,7 +154,7 @@ async fn role_add(
         source: source.account.id(),
         channel: chan.id(),
         name: target_role_name,
-        flags: flags,
+        flags,
     };
     let registration_response = services_target.send_remote_request(request).await;
 

sable_ircd/src/command/handlers/services/dispatch_alias.rs

@@ -6,9 +6,9 @@ pub async fn dispatch_alias_command(
     alias: &str,
     command_str: &str,
 ) -> CommandResult {
-    let (command, args) = command_str.split_once(" ").unwrap_or((command_str, ""));
+    let (command, args) = command_str.split_once(' ').unwrap_or((command_str, ""));
 
-    let new_args = args.split(" ").map(ToOwned::to_owned).collect::<Vec<_>>();
+    let new_args = args.split(' ').map(ToOwned::to_owned).collect::<Vec<_>>();
     let new_arg_iter = ArgListIter::new(&new_args);
 
     let new_cmd = ServicesCommand::new(cmd, command, new_arg_iter, Some(through_user));