Fix clippy lints

20 files changed, 102 insertions, 99 deletions

diff --git a/src/builder/create_embed.rs b/src/builder/create_embed.rs
index a6b264c..cc5e642 100644
--- a/src/builder/create_embed.rs
+++ b/src/builder/create_embed.rs
@@ -69,7 +69,7 @@ impl CreateEmbed {
     pub fn colour<C: Into<Colour>>(mut self, colour: C) -> Self {
         self.0.insert(
             "color".to_string(),
-            Value::Number(Number::from(colour.into().0 as u64)),
+            Value::Number(Number::from(u64::from(colour.into().0))),
         );
 
         CreateEmbed(self.0)
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 9b43804..921e77b 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -301,15 +301,15 @@ impl Cache {
         let id = id.into();
 
         if let Some(channel) = self.channels.get(&id) {
-            return Some(Channel::Guild(channel.clone()));
+            return Some(Channel::Guild(Arc::clone(channel)));
         }
 
         if let Some(private_channel) = self.private_channels.get(&id) {
-            return Some(Channel::Private(private_channel.clone()));
+            return Some(Channel::Private(Arc::clone(private_channel)));
         }
 
         if let Some(group) = self.groups.get(&id) {
-            return Some(Channel::Group(group.clone()));
+            return Some(Channel::Group(Arc::clone(group)));
         }
 
         None
diff --git a/src/client/bridge/gateway/shard_manager.rs b/src/client/bridge/gateway/shard_manager.rs
index 2068bef..98ada1e 100644
--- a/src/client/bridge/gateway/shard_manager.rs
+++ b/src/client/bridge/gateway/shard_manager.rs
@@ -32,6 +32,7 @@ pub struct ShardManager {
 
 impl ShardManager {
     #[cfg(feature = "framework")]
+    #[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
     pub fn new<H>(
         shard_index: u64,
         shard_init: u64,
@@ -49,15 +50,15 @@ impl ShardManager {
         let runners = Arc::new(ParkingLotMutex::new(HashMap::new()));
 
         let mut shard_queuer = ShardQueuer {
-            data: data.clone(),
-            event_handler: event_handler.clone(),
-            framework: framework.clone(),
+            data: Arc::clone(&data),
+            event_handler: Arc::clone(&event_handler),
+            framework: Arc::clone(&framework),
             last_start: None,
             manager_tx: thread_tx.clone(),
-            runners: runners.clone(),
+            runners: Arc::clone(&runners),
             rx: shard_queue_rx,
-            token: token.clone(),
-            ws_url: ws_url.clone(),
+            token: Arc::clone(&token),
+            ws_url: Arc::clone(&ws_url),
             threadpool,
         };
 
diff --git a/src/client/bridge/gateway/shard_queuer.rs b/src/client/bridge/gateway/shard_queuer.rs
index ea49de4..78118c7 100644
--- a/src/client/bridge/gateway/shard_queuer.rs
+++ b/src/client/bridge/gateway/shard_queuer.rs
@@ -80,16 +80,20 @@ impl<H: EventHandler + Send + Sync + 'static> ShardQueuer<H> {
 
     fn start(&mut self, shard_id: ShardId, shard_total: ShardId) -> Result<()> {
         let shard_info = [shard_id.0, shard_total.0];
-        let shard = Shard::new(self.ws_url.clone(), self.token.clone(), shard_info)?;
+        let shard = Shard::new(
+            Arc::clone(&self.ws_url),
+            Arc::clone(&self.token),
+            shard_info,
+        )?;
         let locked = Arc::new(ParkingLotMutex::new(shard));
 
         let mut runner = feature_framework! {{
             ShardRunner::new(
-                locked.clone(),
+                Arc::clone(&locked),
                 self.manager_tx.clone(),
-                self.framework.clone(),
-                self.data.clone(),
-                self.event_handler.clone(),
+                Arc::clone(&self.framework),
+                Arc::clone(&self.data),
+                Arc::clone(&self.event_handler),
                 self.threadpool.clone(),
             )
         } else {
diff --git a/src/client/bridge/gateway/shard_runner.rs b/src/client/bridge/gateway/shard_runner.rs
index 1b1de0e..7ee18c3 100644
--- a/src/client/bridge/gateway/shard_runner.rs
+++ b/src/client/bridge/gateway/shard_runner.rs
@@ -112,12 +112,12 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
             let (event, successful) = self.recv_event();
 
             if let Some(event) = event {
-                let data = self.data.clone();
-                let event_handler = self.event_handler.clone();
-                let shard = self.shard.clone();
+                let data = Arc::clone(&self.data);
+                let event_handler = Arc::clone(&self.event_handler);
+                let shard = Arc::clone(&self.shard);
 
                 feature_framework! {{
-                    let framework = self.framework.clone();
+                    let framework = Arc::clone(&self.framework);
 
                     self.threadpool.execute(|| {
                         dispatch(
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 709e34b..351b4fb 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -206,7 +206,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                 let cache = CACHE.read().unwrap();
 
                 if cache.unavailable_guilds.is_empty() {
-                    let context = context(conn.clone(), data.clone());
+                    let context = context(Arc::clone(&conn), Arc::clone(&data));
 
                     let guild_amount = cache
                         .guilds
diff --git a/src/client/mod.rs b/src/client/mod.rs
index f2fb297..0a3c49f 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -766,16 +766,16 @@ impl<H: EventHandler + Send + Sync + 'static> Client<H> {
             shard_data[0],
             shard_data[1] - shard_data[0] + 1,
             shard_data[2],
-            gateway_url.clone(),
-            self.token.clone(),
-            self.data.clone(),
-            self.event_handler.clone(),
+            Arc::clone(&gateway_url),
+            Arc::clone(&self.token),
+            Arc::clone(&self.data),
+            Arc::clone(&self.event_handler),
             #[cfg(feature = "framework")]
-            self.framework.clone(),
+            Arc::clone(&self.framework),
             self.threadpool.clone(),
         );
 
-        self.shard_runners = manager.runners.clone();
+        self.shard_runners = Arc::clone(&manager.runners);
 
         if let Err(why) = manager.initialize() {
             error!("Failed to boot a shard: {:?}", why);
diff --git a/src/framework/standard/help_commands.rs b/src/framework/standard/help_commands.rs
index 91e173b..631ec3b 100644
--- a/src/framework/standard/help_commands.rs
+++ b/src/framework/standard/help_commands.rs
@@ -51,7 +51,7 @@ fn remove_aliases(cmds: &HashMap<String, CommandOrAlias>) -> HashMap<&String, &I
     result
 }
 
-/// Checks whether a user is member of required roles 
+/// Checks whether a user is member of required roles
 /// and given the required permissions.
 pub fn has_all_requirements(cmd: &Command, guild: &Guild, member: &Member, msg: &Message) -> bool {
     if cmd.allowed_roles.is_empty() {
@@ -106,7 +106,7 @@ pub fn with_embeds(_: &mut Context,
                                     if let Some(member) = guild.members.get(&msg.author.id) {
                                         if let Ok(permissions) = member.permissions() {
                                             if !permissions.administrator() &&
-                                               !has_all_requirements(cmd, &guild, member, &msg) {
+                                               !has_all_requirements(cmd, &guild, member, msg) {
                                                 break;
                                             }
                                         }
@@ -213,7 +213,7 @@ pub fn with_embeds(_: &mut Context,
                             if let Some(member) = guild.members.get(&msg.author.id) {
                                 if let Ok(permissions) = member.permissions() {
                                     if cmd.help_available &&
-                                       (has_all_requirements(cmd, &guild, member, &msg) ||
+                                       (has_all_requirements(cmd, &guild, member, msg) ||
                                         permissions.administrator()) {
                                         let _ = write!(desc, "`{}`\n", name);
                                         has_commands = true;
@@ -252,6 +252,7 @@ pub fn with_embeds(_: &mut Context,
 /// client.with_framework(StandardFramework::new()
 ///     .command("help", |c| c.exec_help(help_commands::plain)));
 /// ```
+#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
 pub fn plain(_: &mut Context,
              msg: &Message,
              groups: HashMap<String, Arc<CommandGroup>>,
@@ -279,7 +280,7 @@ pub fn plain(_: &mut Context,
                                     if let Some(member) = guild.members.get(&msg.author.id) {
                                         if let Ok(permissions) = member.permissions() {
                                             if !permissions.administrator() &&
-                                               !has_all_requirements(cmd, &guild, member, &msg) {
+                                               !has_all_requirements(cmd, &guild, member, msg) {
                                                 break;
                                             }
                                         }
@@ -366,7 +367,7 @@ pub fn plain(_: &mut Context,
                 if let Some(member) = guild.members.get(&msg.author.id) {
                     if let Ok(permissions) = member.permissions() {
                         if cmd.help_available &&
-                           (permissions.administrator() || has_all_requirements(cmd, &guild, member, &msg)) {
+                           (permissions.administrator() || has_all_requirements(cmd, &guild, member, msg)) {
                             let _ = write!(group_help, "`{}` ", name);
                         }
                     }
diff --git a/src/framework/standard/mod.rs b/src/framework/standard/mod.rs
index 68bff80..38c1d2d 100644
--- a/src/framework/standard/mod.rs
+++ b/src/framework/standard/mod.rs
@@ -417,6 +417,7 @@ impl StandardFramework {
     }
 
     #[allow(too_many_arguments)]
+    #[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
     fn should_fail(&mut self,
                    mut context: &mut Context,
                    message: &Message,
@@ -511,12 +512,12 @@ impl StandardFramework {
                 if !command.allowed_roles.is_empty() {
                     if let Some(guild) = message.guild() {
                         let guild = guild.read().unwrap();
+
                         if let Some(member) = guild.members.get(&message.author.id) {
                             if let Ok(permissions) = member.permissions() {
-                                if !permissions.administrator() {
-                                    if !has_correct_roles(&command, &guild, &member) {
-                                        return Some(DispatchError::LackingRole);
-                                    }
+                                if !permissions.administrator()
+                                    && !has_correct_roles(command, &guild, member) {
+                                    return Some(DispatchError::LackingRole);
                                 }
                             }
                         }
@@ -531,7 +532,7 @@ impl StandardFramework {
                 if all_passed {
                     None
                 } else {
-                    Some(DispatchError::CheckFailed(command.clone()))
+                    Some(DispatchError::CheckFailed(Arc::clone(command)))
                 }
             }
         }
@@ -876,7 +877,7 @@ impl Framework for StandardFramework {
                     if let Some(&CommandOrAlias::Command(ref command)) =
                         group.commands.get(&to_check) {
                         let before = self.before.clone();
-                        let command = command.clone();
+                        let command = Arc::clone(command);
                         let after = self.after.clone();
                         let groups = self.groups.clone();
 
diff --git a/src/http/mod.rs b/src/http/mod.rs
index 1828bd7..0abed02 100644
--- a/src/http/mod.rs
+++ b/src/http/mod.rs
@@ -1632,7 +1632,7 @@ pub fn send_files<'a, T, It: IntoIterator<Item=T>>(channel_id: u64, files: It, m
     let mut request = Multipart::from_request(request)?;
     let mut file_num = "0".to_string();
 
-    for file in files.into_iter() {
+    for file in files {
         match file.into() {
             AttachmentType::Bytes((mut bytes, filename)) => {
                 request
diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index ed3eb71..dbaca6b 100644
--- a/src/http/ratelimiting.rs
+++ b/src/http/ratelimiting.rs
@@ -362,7 +362,7 @@ pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
         // - get the global rate;
         // - sleep if there is 0 remaining
         // - then, perform the request
-        let bucket = ROUTES
+        let bucket = Arc::clone(ROUTES
             .lock()
             .expect("routes poisoned")
             .entry(route)
@@ -372,8 +372,7 @@ pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
                     remaining: i64::MAX,
                     reset: i64::MAX,
                 }))
-            })
-            .clone();
+            }));
 
         let mut lock = bucket.lock().unwrap();
         lock.pre_hook(&route);
diff --git a/src/internal/timer.rs b/src/internal/timer.rs
index 0bd0d13..6a8bf74 100644
--- a/src/internal/timer.rs
+++ b/src/internal/timer.rs
@@ -18,11 +18,11 @@ impl Timer {
     }
 
     pub fn await(&mut self) {
-        let due_time = (self.due.timestamp() * 1000) + self.due.timestamp_subsec_millis() as i64;
+        let due_time = (self.due.timestamp() * 1000) + i64::from(self.due.timestamp_subsec_millis());
         let now_time = {
             let now = Utc::now();
 
-            (now.timestamp() * 1000) + now.timestamp_subsec_millis() as i64
+            (now.timestamp() * 1000) + i64::from(now.timestamp_subsec_millis())
         };
 
         if due_time > now_time {
diff --git a/src/lib.rs b/src/lib.rs
index 612972a..6719587 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -90,15 +90,12 @@
 #![allow(doc_markdown, inline_always)]
 #![warn(enum_glob_use, if_not_else)]
 
-#[allow(unused_imports)]
 #[macro_use]
 extern crate bitflags;
-#[allow(unused_imports)]
 #[macro_use]
 extern crate log;
 #[macro_use]
 extern crate serde_derive;
-#[allow(unused_imports)]
 #[macro_use]
 extern crate serde_json;
 
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 55f61ba..480c15d 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -370,7 +370,7 @@ impl Message {
         // Check if the content is over the maximum number of unicode code
         // points.
         let count = content.chars().count() as i64;
-        let diff = count - (constants::MESSAGE_CODE_LIMIT as i64);
+        let diff = count - i64::from(constants::MESSAGE_CODE_LIMIT);
 
         if diff > 0 {
             Some(diff as u64)
@@ -561,7 +561,7 @@ impl Message {
         if total <= constants::EMBED_MAX_LENGTH as usize {
             Ok(())
         } else {
-            let overflow = total as u64 - constants::EMBED_MAX_LENGTH as u64;
+            let overflow = total as u64 - u64::from(constants::EMBED_MAX_LENGTH);
 
             Err(Error::Model(ModelError::EmbedTooLarge(overflow)))
         }
diff --git a/src/model/event.rs b/src/model/event.rs
index 7278bbb..086f422 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -57,13 +57,13 @@ impl CacheUpdate for ChannelCreateEvent {
     fn update(&mut self, cache: &mut Cache) -> Option<Self::Output> {
         match self.channel {
             Channel::Group(ref group) => {
-                let group = group.clone();
+                let group = Arc::clone(group);
 
                 let channel_id = group.with_mut(|writer| {
                     for (recipient_id, recipient) in &mut writer.recipients {
                         cache.update_user_entry(&recipient.read().unwrap());
 
-                        *recipient = cache.users[recipient_id].clone();
+                        *recipient = Arc::clone(&cache.users[recipient_id]);
                     }
 
                     writer.channel_id
@@ -76,23 +76,23 @@ impl CacheUpdate for ChannelCreateEvent {
             Channel::Guild(ref channel) => {
                 let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
-                cache.channels.insert(channel_id, channel.clone());
+                cache.channels.insert(channel_id, Arc::clone(channel));
 
                 cache
                     .guilds
                     .get_mut(&guild_id)
                     .and_then(|guild| {
                         guild
-                            .with_mut(|guild| guild.channels.insert(channel_id, channel.clone()))
+                            .with_mut(|guild| guild.channels.insert(channel_id, Arc::clone(channel)))
                     })
                     .map(Channel::Guild)
             },
             Channel::Private(ref channel) => {
                 if let Some(channel) = cache.private_channels.get(&channel.with(|c| c.id)) {
-                    return Some(Channel::Private((*channel).clone()));
+                    return Some(Channel::Private(Arc::clone(&(*channel))));
                 }
 
-                let channel = channel.clone();
+                let channel = Arc::clone(channel);
 
                 let id = channel.with_mut(|writer| {
                     let user_id = writer.recipient.with_mut(|user| {
@@ -101,16 +101,16 @@ impl CacheUpdate for ChannelCreateEvent {
                         user.id
                     });
 
-                    writer.recipient = cache.users[&user_id].clone();
+                    writer.recipient = Arc::clone(&cache.users[&user_id]);
                     writer.id
                 });
 
-                let ch = cache.private_channels.insert(id, channel.clone());
+                let ch = cache.private_channels.insert(id, Arc::clone(&channel));
                 ch.map(Channel::Private)
             },
             Channel::Category(ref category) => cache
                 .categories
-                .insert(category.read().unwrap().id, category.clone())
+                .insert(category.read().unwrap().id, Arc::clone(category))
                 .map(Channel::Category),
         }
     }
@@ -211,7 +211,7 @@ impl CacheUpdate for ChannelRecipientAddEvent {
 
     fn update(&mut self, cache: &mut Cache) -> Option<()> {
         cache.update_user_entry(&self.user);
-        let user = cache.users[&self.user.id].clone();
+        let user = Arc::clone(&cache.users[&self.user.id]);
 
         cache.groups.get_mut(&self.channel_id).map(|group| {
             group.write().unwrap().recipients.insert(self.user.id, user);
@@ -260,7 +260,7 @@ impl CacheUpdate for ChannelUpdateEvent {
 
                 match cache.groups.entry(ch_id) {
                     Entry::Vacant(e) => {
-                        e.insert(group.clone());
+                        e.insert(Arc::clone(group));
                     },
                     Entry::Occupied(mut e) => {
                         let mut dest = e.get_mut().write().unwrap();
@@ -280,10 +280,10 @@ impl CacheUpdate for ChannelUpdateEvent {
             Channel::Guild(ref channel) => {
                 let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
-                cache.channels.insert(channel_id, channel.clone());
+                cache.channels.insert(channel_id, Arc::clone(channel));
                 cache.guilds.get_mut(&guild_id).map(|guild| {
                     guild
-                        .with_mut(|g| g.channels.insert(channel_id, channel.clone()))
+                        .with_mut(|g| g.channels.insert(channel_id, Arc::clone(channel)))
                 });
             },
             Channel::Private(ref channel) => {
@@ -341,9 +341,9 @@ impl CacheUpdate for GuildCreateEvent {
 
         for (user_id, member) in &mut guild.members {
             cache.update_user_entry(&member.user.read().unwrap());
-            let user = cache.users[user_id].clone();
+            let user = Arc::clone(&cache.users[user_id]);
 
-            member.user = user.clone();
+            member.user = Arc::clone(&user);
         }
 
         cache.channels.extend(guild.channels.clone());
@@ -431,7 +431,7 @@ impl CacheUpdate for GuildMemberAddEvent {
         cache.update_user_entry(&self.member.user.read().unwrap());
 
         // Always safe due to being inserted above.
-        self.member.user = cache.users[&user_id].clone();
+        self.member.user = Arc::clone(&cache.users[&user_id]);
 
         cache.guilds.get_mut(&self.guild_id).map(|guild| {
             guild.with_mut(|guild| {
@@ -767,7 +767,7 @@ impl CacheUpdate for PresenceUpdateEvent {
 
         if let Some(user) = self.presence.user.as_mut() {
             cache.update_user_entry(&user.read().unwrap());
-            *user = cache.users[&user_id].clone();
+            *user = Arc::clone(&cache.users[&user_id]);
         }
 
         if let Some(guild_id) = self.guild_id {
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index 711e13c..5a5ab63 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -755,7 +755,7 @@ impl Guild {
     /// - "zeya", "zeyaa", "zeyla", "zeyzey", "zeyzeyzey"
     /// It would be sorted:
     /// - "zeya", "zeyaa", "zeyla", "zeyzey", "zeyzeyzey"
-    /// 
+    ///
     /// [`Member`]: struct.Member.html
     pub fn members_starting_with(&self, prefix: &str, case_sensitive: bool, sorted: bool) -> Vec<&Member> {
         let mut members: Vec<&Member> = self.members
@@ -765,24 +765,24 @@ impl Guild {
                 if case_sensitive {
                     member.user.read().unwrap().name.starts_with(prefix)
                 } else {
-                    starts_with_case_insensitive(&member.user.read().unwrap().name, &prefix)
+                    starts_with_case_insensitive(&member.user.read().unwrap().name, prefix)
                 }
-                
+
                 || member.nick.as_ref()
                     .map_or(false, |nick|
 
                     if case_sensitive {
                         nick.starts_with(prefix)
                     } else {
-                        starts_with_case_insensitive(&nick, &prefix)
+                        starts_with_case_insensitive(nick, prefix)
                     })).collect();
 
         if sorted {
-            members 
+            members
                 .sort_by(|a, b| {
                     let name_a = match a.nick {
                         Some(ref nick) => {
-                            if contains_case_insensitive(&a.user.read().unwrap().name[..], &prefix) {
+                            if contains_case_insensitive(&a.user.read().unwrap().name[..], prefix) {
                                 a.user.read().unwrap().name.clone()
                             } else {
                                 nick.clone()
@@ -793,7 +793,7 @@ impl Guild {
 
                     let name_b = match b.nick {
                         Some(ref nick) => {
-                            if contains_case_insensitive(&b.user.read().unwrap().name[..], &prefix) {
+                            if contains_case_insensitive(&b.user.read().unwrap().name[..], prefix) {
                                 b.user.read().unwrap().name.clone()
                             } else {
                                 nick.clone()
@@ -802,7 +802,7 @@ impl Guild {
                         None => b.user.read().unwrap().name.clone(),
                     };
 
-                    closest_to_origin(&prefix, &name_a[..], &name_b[..])
+                    closest_to_origin(prefix, &name_a[..], &name_b[..])
                 });
             members
         } else {
@@ -810,7 +810,7 @@ impl Guild {
         }
     }
 
-    /// Retrieves all [`Member`] containing a given `String` as 
+    /// Retrieves all [`Member`] containing a given `String` as
     /// either username or nick, with a priority on username.
     ///
     /// If the substring is "yla", following results are possible:
@@ -827,10 +827,10 @@ impl Guild {
     /// It would be sorted:
     /// - "zey", "azey", "zeyla", "zeylaa", "zeyzeyzey"
     ///
-    /// **Note**: Due to two fields of a `Member` being candidates for 
+    /// **Note**: Due to two fields of a `Member` being candidates for
     /// the searched field, setting `sorted` to `true` will result in an overhead,
     /// as both fields have to be considered again for sorting.
-    /// 
+    ///
     /// [`Member`]: struct.Member.html
     pub fn members_containing(&self, substring: &str, case_sensitive: bool, sorted: bool) -> Vec<&Member> {
         let mut members: Vec<&Member> = self.members
@@ -840,25 +840,25 @@ impl Guild {
                 if case_sensitive {
                     member.user.read().unwrap().name.contains(substring)
                 } else {
-                    contains_case_insensitive(&member.user.read().unwrap().name, &substring)
+                    contains_case_insensitive(&member.user.read().unwrap().name, substring)
                 }
-                
+
                 || member.nick.as_ref()
                     .map_or(false, |nick| {
 
                         if case_sensitive {
                             nick.contains(substring)
                         } else {
-                            contains_case_insensitive(&nick, &substring)
+                            contains_case_insensitive(nick, substring)
                         }
                     })).collect();
 
         if sorted {
-            members 
+            members
                 .sort_by(|a, b| {
                     let name_a = match a.nick {
                         Some(ref nick) => {
-                            if contains_case_insensitive(&a.user.read().unwrap().name[..], &substring) {
+                            if contains_case_insensitive(&a.user.read().unwrap().name[..], substring) {
                                 a.user.read().unwrap().name.clone()
                             } else {
                                 nick.clone()
@@ -869,7 +869,7 @@ impl Guild {
 
                     let name_b = match b.nick {
                         Some(ref nick) => {
-                            if contains_case_insensitive(&b.user.read().unwrap().name[..], &substring) {
+                            if contains_case_insensitive(&b.user.read().unwrap().name[..], substring) {
                                 b.user.read().unwrap().name.clone()
                             } else {
                                 nick.clone()
@@ -878,7 +878,7 @@ impl Guild {
                         None => b.user.read().unwrap().name.clone(),
                     };
 
-                    closest_to_origin(&substring, &name_a[..], &name_b[..])
+                    closest_to_origin(substring, &name_a[..], &name_b[..])
                 });
             members
         } else {
@@ -886,7 +886,7 @@ impl Guild {
         }
     }
 
-    /// Retrieves all [`Member`] containing a given `String` in 
+    /// Retrieves all [`Member`] containing a given `String` in
     /// their username.
     ///
     /// If the substring is "yla", following results are possible:
@@ -909,16 +909,16 @@ impl Guild {
                 if case_sensitive {
                     member.user.read().unwrap().name.contains(substring)
                 } else {
-                    contains_case_insensitive(&member.user.read().unwrap().name, &substring)
+                    contains_case_insensitive(&member.user.read().unwrap().name, substring)
                 }
             }).collect();
 
         if sorted {
-            members 
+            members
                 .sort_by(|a, b| {
                     let name_a = &a.user.read().unwrap().name;
                     let name_b = &b.user.read().unwrap().name;
-                    closest_to_origin(&substring, &name_a[..], &name_b[..])
+                    closest_to_origin(substring, &name_a[..], &name_b[..])
                 });
             members
         } else {
@@ -926,7 +926,7 @@ impl Guild {
         }
     }
 
-    /// Retrieves all [`Member`] containing a given `String` in 
+    /// Retrieves all [`Member`] containing a given `String` in
     /// their nick.
     ///
     /// If the substring is "yla", following results are possible:
@@ -955,12 +955,12 @@ impl Guild {
                         if case_sensitive {
                             nick.contains(substring)
                         } else {
-                            contains_case_insensitive(&nick, &substring)
+                            contains_case_insensitive(nick, substring)
                         }
                     })).collect();
 
         if sorted {
-            members 
+            members
                 .sort_by(|a, b| {
                     let name_a = match a.nick {
                         Some(ref nick) => {
@@ -976,7 +976,7 @@ impl Guild {
                         None => b.user.read().unwrap().name.clone(),
                     };
 
-                    closest_to_origin(&substring, &name_a[..], &name_b[..])
+                    closest_to_origin(substring, &name_a[..], &name_b[..])
                 });
             members
         } else {
@@ -1470,12 +1470,12 @@ fn closest_to_origin(origin: &str, word_a: &str, word_b: &str) -> std::cmp::Orde
         Some(value) => value + word_a.len(),
         None => return std::cmp::Ordering::Greater,
     };
-    
+
     let value_b = match word_b.find(origin) {
         Some(value) => value + word_b.len(),
         None => return std::cmp::Ordering::Less,
     };
-    
+
     value_a.cmp(&value_b)
 }
 
diff --git a/src/model/permissions.rs b/src/model/permissions.rs
index 22599ea..51aafe5 100644
--- a/src/model/permissions.rs
+++ b/src/model/permissions.rs
@@ -445,7 +445,7 @@ impl<'de> Visitor<'de> for U64Visitor {
 
     fn visit_i64<E: DeError>(self, value: i64) -> StdResult<u64, E> { Ok(value as u64) }
 
-    fn visit_u32<E: DeError>(self, value: u32) -> StdResult<u64, E> { Ok(value as u64) }
+    fn visit_u32<E: DeError>(self, value: u32) -> StdResult<u64, E> { Ok(u64::from(value)) }
 
     fn visit_u64<E: DeError>(self, value: u64) -> StdResult<u64, E> { Ok(value) }
 }
diff --git a/src/utils/colour.rs b/src/utils/colour.rs
index 72df2e9..4e612cc 100644
--- a/src/utils/colour.rs
+++ b/src/utils/colour.rs
@@ -125,9 +125,9 @@ impl Colour {
     /// assert_eq!(colour.tuple(), (217, 45, 215));
     /// ```
     pub fn from_rgb(r: u8, g: u8, b: u8) -> Colour {
-        let mut uint = r as u32;
-        uint = (uint << 8) | (g as u32);
-        uint = (uint << 8) | (b as u32);
+        let mut uint = u32::from(r);
+        uint = (uint << 8) | (u32::from(g));
+        uint = (uint << 8) | (u32::from(b));
 
         Colour(uint)
     }
diff --git a/src/voice/audio.rs b/src/voice/audio.rs
index be3ae60..24a4fcd 100644
--- a/src/voice/audio.rs
+++ b/src/voice/audio.rs
@@ -1,5 +1,5 @@
 pub const HEADER_LEN: usize = 12;
-pub const SAMPLE_RATE: u32 = 48000;
+pub const SAMPLE_RATE: u32 = 48_000;
 
 /// A readable audio source.
 pub trait AudioSource: Send {
diff --git a/src/voice/connection.rs b/src/voice/connection.rs
index 3b31488..07033cc 100644
--- a/src/voice/connection.rs
+++ b/src/voice/connection.rs
@@ -138,7 +138,7 @@ impl Connection {
             .set_read_timeout(Some(Duration::from_millis(25)));
 
         let mutexed_client = Arc::new(Mutex::new(client));
-        let thread_items = start_threads(mutexed_client.clone(), &udp)?;
+        let thread_items = start_threads(Arc::clone(&mutexed_client), &udp)?;
 
         info!("[Voice] Connected to: {}", info.endpoint);