diff --git a/src/blob.rs b/src/blob.rs
index f7780d2af..b16972eae 100644
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -483,23 +483,23 @@ mod tests {
     #[test]
     fn test_suffix() {
         let t = dummy_context();
-        let foo = BlobObject::create(&t.ctx, "foo.txt", b"hello").unwrap();
-        assert_eq!(foo.suffix(), Some("txt"));
-        let bar = BlobObject::create(&t.ctx, "bar", b"world").unwrap();
-        assert_eq!(bar.suffix(), None);
+        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello").unwrap();
+        assert_eq!(blob.suffix(), Some("txt"));
+        let blob = BlobObject::create(&t.ctx, "bar", b"world").unwrap();
+        assert_eq!(blob.suffix(), None);
     }
 
     #[test]
     fn test_create_dup() {
         let t = dummy_context();
         BlobObject::create(&t.ctx, "foo.txt", b"hello").unwrap();
-        let foo = t.ctx.get_blobdir().join("foo.txt");
-        assert!(foo.exists());
+        let foo_path = t.ctx.get_blobdir().join("foo.txt");
+        assert!(foo_path.exists());
         BlobObject::create(&t.ctx, "foo.txt", b"world").unwrap();
         for dirent in fs::read_dir(t.ctx.get_blobdir()).unwrap() {
             let fname = dirent.unwrap().file_name();
-            if fname == foo.file_name().unwrap() {
-                assert_eq!(fs::read(&foo).unwrap(), b"hello");
+            if fname == foo_path.file_name().unwrap() {
+                assert_eq!(fs::read(&foo_path).unwrap(), b"hello");
             } else {
                 let name = fname.to_str().unwrap();
                 assert!(name.starts_with("foo"));
@@ -512,13 +512,13 @@ mod tests {
     fn test_double_ext_preserved() {
         let t = dummy_context();
         BlobObject::create(&t.ctx, "foo.tar.gz", b"hello").unwrap();
-        let foo = t.ctx.get_blobdir().join("foo.tar.gz");
-        assert!(foo.exists());
+        let foo_path = t.ctx.get_blobdir().join("foo.tar.gz");
+        assert!(foo_path.exists());
         BlobObject::create(&t.ctx, "foo.tar.gz", b"world").unwrap();
         for dirent in fs::read_dir(t.ctx.get_blobdir()).unwrap() {
             let fname = dirent.unwrap().file_name();
-            if fname == foo.file_name().unwrap() {
-                assert_eq!(fs::read(&foo).unwrap(), b"hello");
+            if fname == foo_path.file_name().unwrap() {
+                assert_eq!(fs::read(&foo_path).unwrap(), b"hello");
             } else {
                 let name = fname.to_str().unwrap();
                 println!("{}", name);
diff --git a/src/chat.rs b/src/chat.rs
index dedb2b0e6..582fe48cb 100644
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -311,13 +311,12 @@ impl Chat {
                         self.id
                     );
                 }
-            } else {
-                if self.typ == Chattype::Group || self.typ == Chattype::VerifiedGroup {
-                    if self.param.get_int(Param::Unpromoted).unwrap_or_default() == 1 {
-                        self.param.remove(Param::Unpromoted);
-                        self.update_param(context)?;
-                    }
-                }
+            } else if self.typ == Chattype::Group
+                || self.typ == Chattype::VerifiedGroup
+                    && self.param.get_int(Param::Unpromoted).unwrap_or_default() == 1
+            {
+                self.param.remove(Param::Unpromoted);
+                self.update_param(context)?;
             }
 
             /* check if we can guarantee E2EE for this message.
@@ -375,12 +374,10 @@ impl Chat {
                     }
                 }
 
-                if can_encrypt {
-                    if all_mutual {
-                        do_guarantee_e2ee = true;
-                    } else if last_msg_in_chat_encrypted(context, &context.sql, self.id) {
-                        do_guarantee_e2ee = true;
-                    }
+                if can_encrypt
+                    && (all_mutual || last_msg_in_chat_encrypted(context, &context.sql, self.id))
+                {
+                    do_guarantee_e2ee = true;
                 }
             }
             if do_guarantee_e2ee {
@@ -419,15 +416,15 @@ impl Chat {
                     } else if !parent_in_reply_to.is_empty() && !parent_rfc724_mid.is_empty() {
                         new_references = format!("{} {}", parent_in_reply_to, parent_rfc724_mid);
                     } else if !parent_in_reply_to.is_empty() {
-                        new_references = parent_in_reply_to.clone();
+                        new_references = parent_in_reply_to;
                     }
                 }
             }
 
             // add independent location to database
 
-            if msg.param.exists(Param::SetLatitude) {
-                if sql::execute(
+            if msg.param.exists(Param::SetLatitude)
+                && sql::execute(
                     context,
                     &context.sql,
                     "INSERT INTO locations \
@@ -442,17 +439,16 @@ impl Chat {
                     ],
                 )
                 .is_ok()
-                {
-                    location_id = sql::get_rowid2(
-                        context,
-                        &context.sql,
-                        "locations",
-                        "timestamp",
-                        timestamp,
-                        "from_id",
-                        DC_CONTACT_ID_SELF as i32,
-                    );
-                }
+            {
+                location_id = sql::get_rowid2(
+                    context,
+                    &context.sql,
+                    "locations",
+                    "timestamp",
+                    timestamp,
+                    "from_id",
+                    DC_CONTACT_ID_SELF as i32,
+                );
             }
 
             // add message to the database
@@ -874,17 +870,14 @@ pub fn send_msg(context: &Context, chat_id: u32, msg: &mut Message) -> Result<Ms
         let forwards = msg.param.get(Param::PrepForwards);
         if let Some(forwards) = forwards {
             for forward in forwards.split(' ') {
-                match forward
+                if let Ok(msg_id) = forward
                     .parse::<u32>()
                     .map_err(|_| InvalidMsgId)
-                    .map(|id| MsgId::new(id))
+                    .map(MsgId::new)
                 {
-                    Ok(msg_id) => {
-                        if let Ok(mut msg) = Message::load_from_db(context, msg_id) {
-                            send_msg(context, 0, &mut msg)?;
-                        };
-                    }
-                    Err(_) => (),
+                    if let Ok(mut msg) = Message::load_from_db(context, msg_id) {
+                        send_msg(context, 0, &mut msg)?;
+                    };
                 }
             }
             msg.param.remove(Param::PrepForwards);
diff --git a/src/configure/auto_mozilla.rs b/src/configure/auto_mozilla.rs
index 193fcb29f..eecc79325 100644
--- a/src/configure/auto_mozilla.rs
+++ b/src/configure/auto_mozilla.rs
@@ -74,7 +74,7 @@ fn parse_xml(in_emailaddr: &str, xml_raw: &str) -> Result<LoginParam> {
     // Split address into local part and domain part.
     let p = in_emailaddr
         .find('@')
-        .ok_or(Error::InvalidEmailAddress(in_emailaddr.to_string()))?;
+        .ok_or_else(|| Error::InvalidEmailAddress(in_emailaddr.to_string()))?;
     let (in_emaillocalpart, in_emaildomain) = in_emailaddr.split_at(p);
     let in_emaildomain = &in_emaildomain[1..];
 
@@ -130,13 +130,14 @@ pub fn moz_autoconfigure(
 ) -> Result<LoginParam> {
     let xml_raw = read_url(context, url)?;
 
-    parse_xml(&param_in.addr, &xml_raw).map_err(|err| {
+    let res = parse_xml(&param_in.addr, &xml_raw);
+    if let Err(err) = &res {
         warn!(
             context,
             "Failed to parse Thunderbird autoconfiguration XML: {}", err
         );
-        err.into()
-    })
+    }
+    res
 }
 
 fn moz_autoconfigure_text_cb<B: std::io::BufRead>(
diff --git a/src/contact.rs b/src/contact.rs
index 0f6bb20e8..79b7fe73d 100644
--- a/src/contact.rs
+++ b/src/contact.rs
@@ -106,11 +106,6 @@ impl Default for Origin {
 }
 
 impl Origin {
-    /// Contacts that start a new "normal" chat, defaults to off.
-    pub fn is_start_new_chat(self) -> bool {
-        self as i32 >= 0x7FFFFFFF
-    }
-
     /// Contacts that are verified and known not to be spam.
     pub fn is_verified(self) -> bool {
         self as i32 >= 0x100
@@ -906,7 +901,7 @@ impl Contact {
 }
 
 /// Extracts first name from full name.
-fn get_first_name<'a>(full_name: &'a str) -> &'a str {
+fn get_first_name(full_name: &str) -> &str {
     full_name.splitn(2, ' ').next().unwrap_or_default()
 }
 
@@ -933,21 +928,21 @@ fn set_block_contact(context: &Context, contact_id: u32, new_blocking: bool) {
     }
 
     if let Ok(contact) = Contact::load_from_db(context, contact_id) {
-        if contact.blocked != new_blocking {
-            if sql::execute(
+        if contact.blocked != new_blocking
+            && sql::execute(
                 context,
                 &context.sql,
                 "UPDATE contacts SET blocked=? WHERE id=?;",
                 params![new_blocking as i32, contact_id as i32],
             )
             .is_ok()
-            {
-                // also (un)block all chats with _only_ this contact - we do not delete them to allow a
-                // non-destructive blocking->unblocking.
-                // (Maybe, beside normal chats (type=100) we should also block group chats with only this user.
-                // However, I'm not sure about this point; it may be confusing if the user wants to add other people;
-                // this would result in recreating the same group...)
-                if sql::execute(
+        {
+            // also (un)block all chats with _only_ this contact - we do not delete them to allow a
+            // non-destructive blocking->unblocking.
+            // (Maybe, beside normal chats (type=100) we should also block group chats with only this user.
+            // However, I'm not sure about this point; it may be confusing if the user wants to add other people;
+            // this would result in recreating the same group...)
+            if sql::execute(
                     context,
                     &context.sql,
                     "UPDATE chats SET blocked=? WHERE type=? AND id IN (SELECT chat_id FROM chats_contacts WHERE contact_id=?);",
@@ -956,7 +951,6 @@ fn set_block_contact(context: &Context, contact_id: u32, new_blocking: bool) {
                     Contact::mark_noticed(context, contact_id);
                     context.call_cb(Event::ContactsChanged(None));
                 }
-            }
         }
     }
 }
diff --git a/src/dc_receive_imf.rs b/src/dc_receive_imf.rs
index ad559bb57..18ebc8b2a 100644
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -172,7 +172,7 @@ pub fn dc_receive_imf(
             // client that relies in the SMTP server to generate one.
             // true eg. for the Webmailer used in all-inkl-KAS
             match dc_create_incoming_rfc724_mid(sent_timestamp, from_id, &to_ids) {
-                Some(x) => x.to_string(),
+                Some(x) => x,
                 None => {
                     error!(context, "can not create incoming rfc724_mid");
                     cleanup(
@@ -407,14 +407,12 @@ fn add_parts(
             // try to create a group
             // (groups appear automatically only if the _sender_ is known, see core issue #54)
 
-            let create_blocked = if 0 != test_normal_chat_id
-                && test_normal_chat_id_blocked == Blocked::Not
-                || incoming_origin.is_start_new_chat()
-            {
-                Blocked::Not
-            } else {
-                Blocked::Deaddrop
-            };
+            let create_blocked =
+                if 0 != test_normal_chat_id && test_normal_chat_id_blocked == Blocked::Not {
+                    Blocked::Not
+                } else {
+                    Blocked::Deaddrop
+                };
 
             create_or_lookup_group(
                 context,
@@ -442,7 +440,7 @@ fn add_parts(
 
         if *chat_id == 0 {
             // try to create a normal chat
-            let create_blocked = if incoming_origin.is_start_new_chat() || *from_id == *to_id {
+            let create_blocked = if *from_id == *to_id {
                 Blocked::Not
             } else {
                 Blocked::Deaddrop
@@ -545,20 +543,18 @@ fn add_parts(
                 }
             }
         }
-        if *chat_id == 0 {
-            if to_ids.is_empty() && to_self {
-                // from_id==to_id==DC_CONTACT_ID_SELF - this is a self-sent messages,
-                // maybe an Autocrypt Setup Messag
-                let (id, bl) =
-                    chat::create_or_lookup_by_contact_id(context, DC_CONTACT_ID_SELF, Blocked::Not)
-                        .unwrap_or_default();
-                *chat_id = id;
-                chat_id_blocked = bl;
+        if *chat_id == 0 && to_ids.is_empty() && to_self {
+            // from_id==to_id==DC_CONTACT_ID_SELF - this is a self-sent messages,
+            // maybe an Autocrypt Setup Messag
+            let (id, bl) =
+                chat::create_or_lookup_by_contact_id(context, DC_CONTACT_ID_SELF, Blocked::Not)
+                    .unwrap_or_default();
+            *chat_id = id;
+            chat_id_blocked = bl;
 
-                if 0 != *chat_id && Blocked::Not != chat_id_blocked {
-                    chat::unblock(context, *chat_id);
-                    chat_id_blocked = Blocked::Not;
-                }
+            if 0 != *chat_id && Blocked::Not != chat_id_blocked {
+                chat::unblock(context, *chat_id);
+                chat_id_blocked = Blocked::Not;
             }
         }
         if *chat_id == 0 {
@@ -629,7 +625,7 @@ fn add_parts(
                         .subject
                         .as_ref()
                         .map(|s| s.to_string())
-                        .unwrap_or("".into());
+                        .unwrap_or_else(|| "".into());
                     txt_raw = Some(format!("{}\n\n{}", subject, msg_raw));
                 }
                 if mime_parser.is_system_message != SystemMessage::Unknown {
@@ -705,7 +701,7 @@ fn save_locations(
     hidden: i32,
 ) {
     if chat_id <= DC_CHAT_ID_LAST_SPECIAL {
-        return ();
+        return;
     }
     let mut location_id_written = false;
     let mut send_event = false;
@@ -714,11 +710,12 @@ fn save_locations(
         let locations = &mime_parser.message_kml.as_ref().unwrap().locations;
         let newest_location_id =
             location::save(context, chat_id, from_id, locations, true).unwrap_or_default();
-        if 0 != newest_location_id && 0 == hidden {
-            if location::set_msg_location_id(context, insert_msg_id, newest_location_id).is_ok() {
-                location_id_written = true;
-                send_event = true;
-            }
+        if 0 != newest_location_id
+            && 0 == hidden
+            && location::set_msg_location_id(context, insert_msg_id, newest_location_id).is_ok()
+        {
+            location_id_written = true;
+            send_event = true;
         }
     }
 
@@ -772,10 +769,8 @@ fn calc_timestamps(
             params![chat_id as i32, from_id as i32, *sort_timestamp],
         );
         if let Some(last_msg_time) = last_msg_time {
-            if last_msg_time > 0 {
-                if *sort_timestamp <= last_msg_time {
-                    *sort_timestamp = last_msg_time + 1;
-                }
+            if last_msg_time > 0 && *sort_timestamp <= last_msg_time {
+                *sort_timestamp = last_msg_time + 1;
             }
         }
     }
@@ -916,11 +911,11 @@ fn create_or_lookup_group(
             )
         } else {
             let field = mime_parser.lookup_field("Chat-Group-Name-Changed");
-            if field.is_some() {
+            if let Some(field) = field {
                 X_MrGrpNameChanged = 1;
                 better_msg = context.stock_system_msg(
                     StockMessage::MsgGrpName,
-                    &field.unwrap(),
+                    field,
                     if let Some(ref name) = grpname {
                         name
                     } else {
@@ -930,23 +925,22 @@ fn create_or_lookup_group(
                 );
 
                 mime_parser.is_system_message = SystemMessage::GroupNameChanged;
-            } else {
-                if let Some(optional_field) = mime_parser.lookup_field("Chat-Group-Image").cloned()
-                {
-                    // fld_value is a pointer somewhere into mime_parser, must not be freed
-                    X_MrGrpImageChanged = optional_field;
-                    mime_parser.is_system_message = SystemMessage::GroupImageChanged;
-                    better_msg = context.stock_system_msg(
-                        if X_MrGrpImageChanged == "0" {
-                            StockMessage::MsgGrpImgDeleted
-                        } else {
-                            StockMessage::MsgGrpImgChanged
-                        },
-                        "",
-                        "",
-                        from_id as u32,
-                    )
-                }
+            } else if let Some(optional_field) =
+                mime_parser.lookup_field("Chat-Group-Image").cloned()
+            {
+                // fld_value is a pointer somewhere into mime_parser, must not be freed
+                X_MrGrpImageChanged = optional_field;
+                mime_parser.is_system_message = SystemMessage::GroupImageChanged;
+                better_msg = context.stock_system_msg(
+                    if X_MrGrpImageChanged == "0" {
+                        StockMessage::MsgGrpImgDeleted
+                    } else {
+                        StockMessage::MsgGrpImgChanged
+                    },
+                    "",
+                    "",
+                    from_id as u32,
+                )
             }
         }
     }
@@ -954,15 +948,11 @@ fn create_or_lookup_group(
 
     // check, if we have a chat with this group ID
     let (mut chat_id, chat_id_verified, _blocked) = chat::get_chat_id_by_grpid(context, &grpid);
-    if chat_id != 0 {
-        if chat_id_verified {
-            if let Err(err) =
-                check_verified_properties(context, mime_parser, from_id as u32, to_ids)
-            {
-                warn!(context, "verification problem: {}", err);
-                let s = format!("{}. See 'Info' for more details", err);
-                mime_parser.repl_msg_by_error(s);
-            }
+    if chat_id != 0 && chat_id_verified {
+        if let Err(err) = check_verified_properties(context, mime_parser, from_id as u32, to_ids) {
+            warn!(context, "verification problem: {}", err);
+            let s = format!("{}. See 'Info' for more details", err);
+            mime_parser.repl_msg_by_error(s);
         }
     }
 
@@ -1115,13 +1105,12 @@ fn create_or_lookup_group(
         if skip.is_none() || !addr_cmp(&self_addr, skip.unwrap()) {
             chat::add_to_chat_contacts_table(context, chat_id, DC_CONTACT_ID_SELF);
         }
-        if from_id > DC_CHAT_ID_LAST_SPECIAL {
-            if !Contact::addr_equals_contact(context, &self_addr, from_id as u32)
-                && (skip.is_none()
-                    || !Contact::addr_equals_contact(context, skip.unwrap(), from_id as u32))
-            {
-                chat::add_to_chat_contacts_table(context, chat_id, from_id as u32);
-            }
+        if from_id > DC_CHAT_ID_LAST_SPECIAL
+            && !Contact::addr_equals_contact(context, &self_addr, from_id as u32)
+            && (skip.is_none()
+                || !Contact::addr_equals_contact(context, skip.unwrap(), from_id as u32))
+        {
+            chat::add_to_chat_contacts_table(context, chat_id, from_id as u32);
         }
         for &to_id in to_ids.iter() {
             if !Contact::addr_equals_contact(context, &self_addr, to_id)
@@ -1160,7 +1149,7 @@ fn create_or_lookup_group(
     }
 
     cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-    return Ok(());
+    Ok(())
 }
 
 /// Handle groups for received messages
@@ -1352,7 +1341,7 @@ fn hex_hash(s: impl AsRef<str>) -> String {
 #[allow(non_snake_case)]
 fn search_chat_ids_by_contact_ids(
     context: &Context,
-    unsorted_contact_ids: &Vec<u32>,
+    unsorted_contact_ids: &[u32],
 ) -> Result<Vec<u32>> {
     /* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
     let mut contact_ids = Vec::with_capacity(23);
@@ -1508,7 +1497,7 @@ fn check_verified_properties(
 
 fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {
     let msg = better_msg.as_ref();
-    if msg.len() > 0 && !mime_parser.parts.is_empty() {
+    if !msg.is_empty() && !mime_parser.parts.is_empty() {
         let part = &mut mime_parser.parts[0];
         if part.typ == Viewtype::Text {
             part.msg = msg.to_string();
@@ -1535,12 +1524,12 @@ fn dc_is_reply_to_known_message(context: &Context, mime_parser: &MimeParser) ->
     0
 }
 
-fn is_known_rfc724_mid_in_list(context: &Context, mid_list: &String) -> bool {
+fn is_known_rfc724_mid_in_list(context: &Context, mid_list: &str) -> bool {
     if mid_list.is_empty() {
         return false;
     }
 
-    if let Ok(ids) = mailparse::addrparse(mid_list.as_str()) {
+    if let Ok(ids) = mailparse::addrparse(mid_list) {
         for id in ids.iter() {
             if is_known_rfc724_mid(context, id) {
                 return true;
@@ -1588,8 +1577,8 @@ fn dc_is_reply_to_messenger_message(context: &Context, mime_parser: &MimeParser)
     0
 }
 
-fn is_msgrmsg_rfc724_mid_in_list(context: &Context, mid_list: &String) -> bool {
-    if let Ok(ids) = mailparse::addrparse(mid_list.as_str()) {
+fn is_msgrmsg_rfc724_mid_in_list(context: &Context, mid_list: &str) -> bool {
+    if let Ok(ids) = mailparse::addrparse(mid_list) {
         for id in ids.iter() {
             if is_msgrmsg_rfc724_mid(context, id) {
                 return true;
@@ -1661,7 +1650,7 @@ fn dc_add_or_lookup_contacts_by_address_list(
 fn add_or_lookup_contact_by_addr(
     context: &Context,
     display_name: &Option<String>,
-    addr: &String,
+    addr: &str,
     origin: Origin,
     ids: &mut Vec<u32>,
     check_self: &mut bool,
diff --git a/src/dc_simplify.rs b/src/dc_simplify.rs
index 30a49ef05..e854b4d29 100644
--- a/src/dc_simplify.rs
+++ b/src/dc_simplify.rs
@@ -49,7 +49,7 @@ impl Simplify {
     /**
      * Simplify Plain Text
      */
-    #[allow(non_snake_case)]
+    #[allow(non_snake_case, clippy::mut_range_bound)]
     fn simplify_plain_text(&mut self, buf_terminated: &str, is_msgrmsg: bool) -> String {
         /* This function ...
         ... removes all text after the line `-- ` (footer mark)
diff --git a/src/dc_strencode.rs b/src/dc_strencode.rs
index 23fe37e68..787c5b41c 100644
--- a/src/dc_strencode.rs
+++ b/src/dc_strencode.rs
@@ -63,12 +63,6 @@ pub fn dc_needs_ext_header(to_check: impl AsRef<str>) -> bool {
     }
 
     to_check.chars().any(|c| {
-        !(c.is_ascii_alphanumeric()
-            || c == '-'
-            || c == '_'
-            || c == '_'
-            || c == '.'
-            || c == '~'
-            || c == '%')
+        !c.is_ascii_alphanumeric() && c != '-' && c != '_' && c != '.' && c != '~' && c != '%'
     })
 }
diff --git a/src/dc_tools.rs b/src/dc_tools.rs
index 08f58296c..f71df5fbf 100644
--- a/src/dc_tools.rs
+++ b/src/dc_tools.rs
@@ -778,9 +778,9 @@ mod tests {
 
     #[test]
     fn test_dc_create_incoming_rfc724_mid() {
-        let res = dc_create_incoming_rfc724_mid(123, 45, &vec![6, 7]);
+        let res = dc_create_incoming_rfc724_mid(123, 45, &[6, 7]);
         assert_eq!(res, Some("123-45-7@stub".into()));
-        let res = dc_create_incoming_rfc724_mid(123, 45, &vec![]);
+        let res = dc_create_incoming_rfc724_mid(123, 45, &[]);
         assert_eq!(res, Some("123-45-0@stub".into()));
     }
 
@@ -859,15 +859,15 @@ mod tests {
     #[test]
     fn test_listflags_has() {
         let listflags: u32 = 0x1101;
-        assert!(listflags_has(listflags, 0x1) == true);
-        assert!(listflags_has(listflags, 0x10) == false);
-        assert!(listflags_has(listflags, 0x100) == true);
-        assert!(listflags_has(listflags, 0x1000) == true);
+        assert!(listflags_has(listflags, 0x1));
+        assert!(!listflags_has(listflags, 0x10));
+        assert!(listflags_has(listflags, 0x100));
+        assert!(listflags_has(listflags, 0x1000));
         let listflags: u32 = (DC_GCL_ADD_SELF | DC_GCL_VERIFIED_ONLY).try_into().unwrap();
-        assert!(listflags_has(listflags, DC_GCL_VERIFIED_ONLY) == true);
-        assert!(listflags_has(listflags, DC_GCL_ADD_SELF) == true);
+        assert!(listflags_has(listflags, DC_GCL_VERIFIED_ONLY));
+        assert!(listflags_has(listflags, DC_GCL_ADD_SELF));
         let listflags: u32 = DC_GCL_VERIFIED_ONLY.try_into().unwrap();
-        assert!(listflags_has(listflags, DC_GCL_ADD_SELF) == false);
+        assert!(!listflags_has(listflags, DC_GCL_ADD_SELF));
     }
 
     #[test]
diff --git a/src/e2ee.rs b/src/e2ee.rs
index e207fa1c3..f296c1956 100644
--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -213,7 +213,7 @@ fn load_or_generate_self_public_key(context: &Context, self_addr: impl AsRef<str
     );
     match pgp::create_keypair(&self_addr) {
         Some((public_key, private_key)) => {
-            match dc_key_save_self_keypair(
+            if dc_key_save_self_keypair(
                 context,
                 &public_key,
                 &private_key,
@@ -221,15 +221,14 @@ fn load_or_generate_self_public_key(context: &Context, self_addr: impl AsRef<str
                 true,
                 &context.sql,
             ) {
-                true => {
-                    info!(
-                        context,
-                        "Keypair generated in {:.3}s.",
-                        start.elapsed().as_secs()
-                    );
-                    Ok(public_key)
-                }
-                false => Err(format_err!("Failed to save keypair")),
+                info!(
+                    context,
+                    "Keypair generated in {:.3}s.",
+                    start.elapsed().as_secs()
+                );
+                Ok(public_key)
+            } else {
+                Err(format_err!("Failed to save keypair"))
             }
         }
         None => Err(format_err!("Failed to generate keypair")),
diff --git a/src/imap.rs b/src/imap.rs
index 43f7d89cb..12bef048c 100644
--- a/src/imap.rs
+++ b/src/imap.rs
@@ -114,7 +114,7 @@ const JUST_UID: &str = "(UID)";
 const BODY_FLAGS: &str = "(FLAGS BODY.PEEK[])";
 const SELECT_ALL: &str = "1:*";
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Imap {
     config: RwLock<ImapConfig>,
     session: Mutex<Option<Session>>,
@@ -187,14 +187,7 @@ impl Default for ImapConfig {
 
 impl Imap {
     pub fn new() -> Self {
-        Imap {
-            session: Mutex::new(None),
-            config: RwLock::new(ImapConfig::default()),
-            interrupt: Mutex::new(None),
-            connected: Mutex::new(false),
-            skip_next_idle_wait: AtomicBool::new(false),
-            should_reconnect: AtomicBool::new(false),
-        }
+        Default::default()
     }
 
     pub async fn is_connected(&self) -> bool {
@@ -233,9 +226,7 @@ impl Imap {
                     match Client::connect_insecure((imap_server, imap_port)).await {
                         Ok(client) => {
                             if (server_flags & DC_LP_IMAP_SOCKET_STARTTLS) != 0 {
-                                let res =
-                                    client.secure(imap_server, config.certificate_checks).await;
-                                res
+                                client.secure(imap_server, config.certificate_checks).await
                             } else {
                                 Ok(client)
                             }
@@ -271,14 +262,12 @@ impl Imap {
                                 user: imap_user.into(),
                                 access_token: token,
                             };
-                            let res = client.authenticate("XOAUTH2", &auth).await;
-                            res
+                            client.authenticate("XOAUTH2", &auth).await
                         } else {
                             return Err(Error::OauthError);
                         }
                     } else {
-                        let res = client.login(imap_user, imap_pw).await;
-                        res
+                        client.login(imap_user, imap_pw).await
                     }
                 }
                 Err(err) => {
@@ -369,7 +358,7 @@ impl Imap {
         if self.connect(context, &param) {
             self.ensure_configured_folders(context, true)
         } else {
-            Err(Error::ConnectionFailed(format!("{}", param).to_string()))
+            Err(Error::ConnectionFailed(format!("{}", param)))
         }
     }
 
@@ -1398,11 +1387,7 @@ impl Imap {
         })
     }
 
-    async fn list_folders<'a>(
-        &self,
-        session: &'a mut Session,
-        context: &Context,
-    ) -> Option<Vec<Name>> {
+    async fn list_folders(&self, session: &mut Session, context: &Context) -> Option<Vec<Name>> {
         // TODO: use xlist when available
         match session.list(Some(""), Some("*")).await {
             Ok(list) => {
@@ -1470,7 +1455,7 @@ fn get_folder_meaning_by_name(folder_name: &Name) -> FolderMeaning {
     let sent_names = vec!["sent", "sent objects", "gesendet"];
     let lower = folder_name.name().to_lowercase();
 
-    if sent_names.into_iter().find(|s| *s == lower).is_some() {
+    if sent_names.into_iter().any(|s| s == lower) {
         FolderMeaning::SentObjects
     } else {
         FolderMeaning::Unknown
@@ -1486,15 +1471,12 @@ fn get_folder_meaning(folder_name: &Name) -> FolderMeaning {
     let special_names = vec!["\\Spam", "\\Trash", "\\Drafts", "\\Junk"];
 
     for attr in folder_name.attributes() {
-        match attr {
-            NameAttribute::Custom(ref label) => {
-                if special_names.iter().find(|s| *s == label).is_some() {
-                    res = FolderMeaning::Other;
-                } else if label == "\\Sent" {
-                    res = FolderMeaning::SentObjects
-                }
+        if let NameAttribute::Custom(ref label) = attr {
+            if special_names.iter().any(|s| *s == label) {
+                res = FolderMeaning::Other;
+            } else if label == "\\Sent" {
+                res = FolderMeaning::SentObjects
             }
-            _ => {}
         }
     }
 
diff --git a/src/imex.rs b/src/imex.rs
index dc2e25965..d022d5f37 100644
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -84,27 +84,24 @@ pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<Strin
     let mut newest_backup_time = 0;
     let mut newest_backup_path: Option<std::path::PathBuf> = None;
     for dirent in dir_iter {
-        match dirent {
-            Ok(dirent) => {
-                let path = dirent.path();
-                let name = dirent.file_name();
-                let name = name.to_string_lossy();
-                if name.starts_with("delta-chat") && name.ends_with(".bak") {
-                    let sql = Sql::new();
-                    if sql.open(context, &path, true) {
-                        let curr_backup_time = sql
-                            .get_raw_config_int(context, "backup_time")
-                            .unwrap_or_default();
-                        if curr_backup_time > newest_backup_time {
-                            newest_backup_path = Some(path);
-                            newest_backup_time = curr_backup_time;
-                        }
-                        info!(context, "backup_time of {} is {}", name, curr_backup_time);
-                        sql.close(&context);
+        if let Ok(dirent) = dirent {
+            let path = dirent.path();
+            let name = dirent.file_name();
+            let name = name.to_string_lossy();
+            if name.starts_with("delta-chat") && name.ends_with(".bak") {
+                let sql = Sql::new();
+                if sql.open(context, &path, true) {
+                    let curr_backup_time = sql
+                        .get_raw_config_int(context, "backup_time")
+                        .unwrap_or_default();
+                    if curr_backup_time > newest_backup_time {
+                        newest_backup_path = Some(path);
+                        newest_backup_time = curr_backup_time;
                     }
+                    info!(context, "backup_time of {} is {}", name, curr_backup_time);
+                    sql.close(&context);
                 }
             }
-            Err(_) => (),
         }
     }
     match newest_backup_path {
@@ -175,7 +172,7 @@ pub fn render_setup_file(context: &Context, passphrase: &str) -> Result<String>
     );
     let self_addr = e2ee::ensure_secret_key_exists(context)?;
     let private_key = Key::from_self_private(context, self_addr, &context.sql)
-        .ok_or(format_err!("Failed to get private key."))?;
+        .ok_or_else(|| format_err!("Failed to get private key."))?;
     let ac_headers = match context.get_config_bool(Config::E2eeEnabled) {
         false => None,
         true => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
@@ -222,7 +219,7 @@ pub fn create_setup_code(_context: &Context) -> String {
     for i in 0..9 {
         loop {
             random_val = rng.gen();
-            if !(random_val as usize > 60000) {
+            if random_val as usize <= 60000 {
                 break;
             }
         }
@@ -548,7 +545,7 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
         }
         Ok(()) => {
             dest_sql.set_raw_config_int(context, "backup_time", now as i32)?;
-            context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
+            context.call_cb(Event::ImexFileWritten(dest_path_filename));
             Ok(())
         }
     };
diff --git a/src/job.rs b/src/job.rs
index 6bdcba296..410df5858 100644
--- a/src/job.rs
+++ b/src/job.rs
@@ -597,7 +597,7 @@ fn set_delivered(context: &Context, msg_id: MsgId) {
         .unwrap_or_default();
     context.call_cb(Event::MsgDelivered {
         chat_id: chat_id as u32,
-        msg_id: msg_id,
+        msg_id,
     });
 }
 
diff --git a/src/key.rs b/src/key.rs
index cd851c999..d4dcf4deb 100644
--- a/src/key.rs
+++ b/src/key.rs
@@ -192,7 +192,6 @@ impl Key {
                 res.push(c);
                 res
             })
-            .to_string()
     }
 
     pub fn to_armored_string(
diff --git a/src/lib.rs b/src/lib.rs
index 698edee37..fc8c59c78 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,8 +1,16 @@
-#![deny(clippy::correctness, missing_debug_implementations)]
-// TODO: make all of these errors, such that clippy actually passes.
-#![warn(clippy::all, clippy::perf, clippy::not_unsafe_ptr_arg_deref)]
-// This is nice, but for now just annoying.
-#![allow(clippy::unreadable_literal)]
+#![deny(clippy::correctness, missing_debug_implementations, clippy::all)]
+#![warn(
+    clippy::type_complexity,
+    clippy::cognitive_complexity,
+    clippy::too_many_arguments,
+    clippy::block_in_if_condition_stmt,
+    clippy::large_enum_variant
+)]
+#![allow(
+    clippy::unreadable_literal,
+    clippy::needless_range_loop,
+    clippy::match_bool
+)]
 #![feature(ptr_wrapping_offset_from)]
 
 #[macro_use]
diff --git a/src/login_param.rs b/src/login_param.rs
index 42ff15917..33611f363 100644
--- a/src/login_param.rs
+++ b/src/login_param.rs
@@ -104,7 +104,7 @@ impl LoginParam {
         let server_flags = sql.get_raw_config_int(context, key).unwrap_or_default();
 
         LoginParam {
-            addr: addr.to_string(),
+            addr,
             mail_server,
             mail_user,
             mail_pw,
@@ -198,6 +198,7 @@ impl fmt::Display for LoginParam {
     }
 }
 
+#[allow(clippy::ptr_arg)]
 fn unset_empty(s: &String) -> Cow<String> {
     if s.is_empty() {
         Cow::Owned("unset".to_string())
@@ -206,44 +207,45 @@ fn unset_empty(s: &String) -> Cow<String> {
     }
 }
 
+#[allow(clippy::useless_let_if_seq)]
 fn get_readable_flags(flags: i32) -> String {
     let mut res = String::new();
     for bit in 0..31 {
         if 0 != flags & 1 << bit {
-            let mut flag_added = 0;
+            let mut flag_added = false;
             if 1 << bit == 0x2 {
                 res += "OAUTH2 ";
-                flag_added = 1;
+                flag_added = true;
             }
             if 1 << bit == 0x4 {
                 res += "AUTH_NORMAL ";
-                flag_added = 1;
+                flag_added = true;
             }
             if 1 << bit == 0x100 {
                 res += "IMAP_STARTTLS ";
-                flag_added = 1;
+                flag_added = true;
             }
             if 1 << bit == 0x200 {
                 res += "IMAP_SSL ";
-                flag_added = 1;
+                flag_added = true;
             }
             if 1 << bit == 0x400 {
                 res += "IMAP_PLAIN ";
-                flag_added = 1;
+                flag_added = true;
             }
             if 1 << bit == 0x10000 {
                 res += "SMTP_STARTTLS ";
-                flag_added = 1
+                flag_added = true;
             }
             if 1 << bit == 0x20000 {
                 res += "SMTP_SSL ";
-                flag_added = 1
+                flag_added = true;
             }
             if 1 << bit == 0x40000 {
                 res += "SMTP_PLAIN ";
-                flag_added = 1
+                flag_added = true;
             }
-            if 0 == flag_added {
+            if flag_added {
                 res += &format!("{:#0x}", 1 << bit);
             }
         }
diff --git a/src/message.rs b/src/message.rs
index bf1cb1d97..49dd555b7 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -44,7 +44,7 @@ impl MsgId {
     /// Whether the message ID signifies a special message.
     ///
     /// This kind of message ID can not be used for real messages.
-    pub fn is_special(&self) -> bool {
+    pub fn is_special(self) -> bool {
         match self.0 {
             0..=DC_MSG_ID_LAST_SPECIAL => true,
             _ => false,
@@ -60,21 +60,21 @@ impl MsgId {
     ///
     /// When this is `true`, [MsgId::is_special] will also always be
     /// `true`.
-    pub fn is_unset(&self) -> bool {
+    pub fn is_unset(self) -> bool {
         self.0 == 0
     }
 
     /// Whether the message ID is the special marker1 marker.
     ///
     /// See the docs of the `dc_get_chat_msgs` C API for details.
-    pub fn is_marker1(&self) -> bool {
+    pub fn is_marker1(self) -> bool {
         self.0 == DC_MSG_ID_MARKER1
     }
 
     /// Whether the message ID is the special day marker.
     ///
     /// See the docs of the `dc_get_chat_msgs` C API for details.
-    pub fn is_daymarker(&self) -> bool {
+    pub fn is_daymarker(self) -> bool {
         self.0 == DC_MSG_ID_DAYMARKER
     }
 
@@ -82,7 +82,7 @@ impl MsgId {
     ///
     /// Avoid using this, eventually types should be cleaned up enough
     /// that it is no longer necessary.
-    pub fn to_u32(&self) -> u32 {
+    pub fn to_u32(self) -> u32 {
         self.0
     }
 }
@@ -687,7 +687,7 @@ impl Lot {
         self.text2 = Some(get_summarytext_by_raw(
             msg.type_0,
             msg.text.as_ref(),
-            &mut msg.param,
+            &msg.param,
             SUMMARY_CHARACTERS,
             context,
         ));
@@ -1218,9 +1218,10 @@ pub fn mdn_from_ext(
                 } // else wait for more receipts
             }
         }
-        return match read_by_all {
-            true => Some((chat_id, msg_id)),
-            false => None,
+        return if read_by_all {
+            Some((chat_id, msg_id))
+        } else {
+            None
         };
     }
     None
@@ -1368,50 +1369,32 @@ mod tests {
         some_file.set(Param::File, "foo.bar");
 
         assert_eq!(
-            get_summarytext_by_raw(
-                Viewtype::Text,
-                some_text.as_ref(),
-                &mut Params::new(),
-                50,
-                &ctx
-            ),
+            get_summarytext_by_raw(Viewtype::Text, some_text.as_ref(), &Params::new(), 50, &ctx),
             "bla bla" // for simple text, the type is not added to the summary
         );
 
         assert_eq!(
-            get_summarytext_by_raw(Viewtype::Image, no_text.as_ref(), &mut some_file, 50, &ctx,),
+            get_summarytext_by_raw(Viewtype::Image, no_text.as_ref(), &some_file, 50, &ctx,),
             "Image" // file names are not added for images
         );
 
         assert_eq!(
-            get_summarytext_by_raw(Viewtype::Video, no_text.as_ref(), &mut some_file, 50, &ctx,),
+            get_summarytext_by_raw(Viewtype::Video, no_text.as_ref(), &some_file, 50, &ctx,),
             "Video" // file names are not added for videos
         );
 
         assert_eq!(
-            get_summarytext_by_raw(Viewtype::Gif, no_text.as_ref(), &mut some_file, 50, &ctx,),
+            get_summarytext_by_raw(Viewtype::Gif, no_text.as_ref(), &some_file, 50, &ctx,),
             "GIF" // file names are not added for GIFs
         );
 
         assert_eq!(
-            get_summarytext_by_raw(
-                Viewtype::Sticker,
-                no_text.as_ref(),
-                &mut some_file,
-                50,
-                &ctx,
-            ),
+            get_summarytext_by_raw(Viewtype::Sticker, no_text.as_ref(), &some_file, 50, &ctx,),
             "Sticker" // file names are not added for stickers
         );
 
         assert_eq!(
-            get_summarytext_by_raw(
-                Viewtype::Voice,
-                empty_text.as_ref(),
-                &mut some_file,
-                50,
-                &ctx,
-            ),
+            get_summarytext_by_raw(Viewtype::Voice, empty_text.as_ref(), &some_file, 50, &ctx,),
             "Voice message" // file names are not added for voice messages, empty text is skipped
         );
 
@@ -1421,13 +1404,7 @@ mod tests {
         );
 
         assert_eq!(
-            get_summarytext_by_raw(
-                Viewtype::Voice,
-                some_text.as_ref(),
-                &mut some_file,
-                50,
-                &ctx
-            ),
+            get_summarytext_by_raw(Viewtype::Voice, some_text.as_ref(), &some_file, 50, &ctx),
             "Voice message \u{2013} bla bla" // `\u{2013}` explicitly checks for "EN DASH"
         );
 
@@ -1437,24 +1414,12 @@ mod tests {
         );
 
         assert_eq!(
-            get_summarytext_by_raw(
-                Viewtype::Audio,
-                empty_text.as_ref(),
-                &mut some_file,
-                50,
-                &ctx,
-            ),
+            get_summarytext_by_raw(Viewtype::Audio, empty_text.as_ref(), &some_file, 50, &ctx,),
             "Audio \u{2013} foo.bar" // file name is added for audio, empty text is not added
         );
 
         assert_eq!(
-            get_summarytext_by_raw(
-                Viewtype::Audio,
-                some_text.as_ref(),
-                &mut some_file,
-                50,
-                &ctx
-            ),
+            get_summarytext_by_raw(Viewtype::Audio, some_text.as_ref(), &some_file, 50, &ctx),
             "Audio \u{2013} foo.bar \u{2013} bla bla" // file name and text added for audio
         );
 
diff --git a/src/mimefactory.rs b/src/mimefactory.rs
index d159cbdfe..048ff053a 100644
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -131,11 +131,12 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                     .get_config(Config::ConfiguredAddr)
                     .unwrap_or_default();
 
-                if !email_to_remove.is_empty() && !addr_cmp(email_to_remove, self_addr) {
-                    if !vec_contains_lowercase(&factory.recipients_addr, &email_to_remove) {
-                        factory.recipients_names.push("".to_string());
-                        factory.recipients_addr.push(email_to_remove.to_string());
-                    }
+                if !email_to_remove.is_empty()
+                    && !addr_cmp(email_to_remove, self_addr)
+                    && !vec_contains_lowercase(&factory.recipients_addr, &email_to_remove)
+                {
+                    factory.recipients_names.push("".to_string());
+                    factory.recipients_addr.push(email_to_remove.to_string());
                 }
             }
             if command != SystemMessage::AutocryptSetupMessage
@@ -299,14 +300,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                     return true;
                 }
 
-                match self.msg.param.get_cmd() {
-                    SystemMessage::MemberAddedToGroup => {
-                        return true;
-                    }
-                    _ => {}
-                }
-
-                false
+                self.msg.param.get_cmd() == SystemMessage::MemberAddedToGroup
             }
             Loaded::MDN => false,
         }
diff --git a/src/mimeparser.rs b/src/mimeparser.rs
index fde537d69..a345f8900 100644
--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -148,11 +148,11 @@ impl<'a> MimeParser<'a> {
             self.subject = Some(field.clone());
         }
 
-        if let Some(_) = self.lookup_field("Chat-Version") {
+        if self.lookup_field("Chat-Version").is_some() {
             self.is_send_by_messenger = true
         }
 
-        if let Some(_) = self.lookup_field("Autocrypt-Setup-Message") {
+        if self.lookup_field("Autocrypt-Setup-Message").is_some() {
             let has_setup_file = self.parts.iter().any(|p| {
                 p.mimetype.is_some() && p.mimetype.as_ref().unwrap().as_ref() == MIME_AC_SETUP_FILE
             });
@@ -188,14 +188,12 @@ impl<'a> MimeParser<'a> {
                 self.is_system_message = SystemMessage::LocationStreamingEnabled;
             }
         }
-        if let Some(_) = self.lookup_field("Chat-Group-Image") {
-            if !self.parts.is_empty() {
-                let textpart = &self.parts[0];
-                if textpart.typ == Viewtype::Text && self.parts.len() >= 2 {
-                    let imgpart = &mut self.parts[1];
-                    if imgpart.typ == Viewtype::Image {
-                        imgpart.is_meta = true;
-                    }
+        if self.lookup_field("Chat-Group-Image").is_some() && !self.parts.is_empty() {
+            let textpart = &self.parts[0];
+            if textpart.typ == Viewtype::Text && self.parts.len() >= 2 {
+                let imgpart = &mut self.parts[1];
+                if imgpart.typ == Viewtype::Image {
+                    imgpart.is_meta = true;
                 }
             }
         }
@@ -264,11 +262,11 @@ impl<'a> MimeParser<'a> {
             }
         }
         if self.parts.len() == 1 {
-            if self.parts[0].typ == Viewtype::Audio {
-                if let Some(_) = self.lookup_field("Chat-Voice-Message") {
-                    let part_mut = &mut self.parts[0];
-                    part_mut.typ = Viewtype::Voice;
-                }
+            if self.parts[0].typ == Viewtype::Audio
+                && self.lookup_field("Chat-Voice-Message").is_some()
+            {
+                let part_mut = &mut self.parts[0];
+                part_mut.typ = Viewtype::Voice;
             }
             if self.parts[0].typ == Viewtype::Image {
                 if let Some(value) = self.lookup_field("Chat-Content") {
@@ -601,7 +599,7 @@ impl<'a> MimeParser<'a> {
 
                 // if there is still no filename, guess one
                 if desired_filename.is_empty() {
-                    if let Some(subtype) = mail.ctype.mimetype.split('/').skip(1).next() {
+                    if let Some(subtype) = mail.ctype.mimetype.split('/').nth(1) {
                         desired_filename = format!("file.{}", subtype,);
                     } else {
                         return Ok(false);
@@ -626,7 +624,7 @@ impl<'a> MimeParser<'a> {
         &mut self,
         msg_type: Viewtype,
         mime_type: Mime,
-        raw_mime: &String,
+        raw_mime: &str,
         decoded_data: &[u8],
         filename: &str,
     ) {
@@ -685,7 +683,7 @@ impl<'a> MimeParser<'a> {
 
     fn do_add_single_part(&mut self, mut part: Part) {
         if self.encrypted {
-            if self.signatures.len() > 0 {
+            if !self.signatures.is_empty() {
                 part.param.set_int(Param::GuaranteeE2ee, 1);
             } else {
                 // XXX if the message was encrypted but not signed
@@ -698,17 +696,15 @@ impl<'a> MimeParser<'a> {
     }
 
     pub fn is_mailinglist_message(&self) -> bool {
-        if let Some(_) = self.lookup_field("List-Id") {
+        if self.lookup_field("List-Id").is_some() {
             return true;
         }
 
         if let Some(precedence) = self.lookup_field("Precedence") {
-            if precedence == "list" || precedence == "bulk" {
-                return true;
-            }
+            precedence == "list" || precedence == "bulk"
+        } else {
+            false
         }
-
-        false
     }
 
     pub fn sender_equals_recipient(&self) -> bool {
@@ -965,7 +961,7 @@ fn mailmime_is_attachment_disposition(mail: &mailparse::ParsedMail<'_>) -> bool
 }
 
 // returned addresses are normalized.
-fn get_recipients<'a, S: AsRef<str>, T: Iterator<Item = (S, S)>>(headers: T) -> HashSet<String> {
+fn get_recipients<S: AsRef<str>, T: Iterator<Item = (S, S)>>(headers: T) -> HashSet<String> {
     let mut recipients: HashSet<String> = Default::default();
 
     for (hkey, hvalue) in headers {
diff --git a/src/param.rs b/src/param.rs
index 8fc0891fc..3e03f90c7 100644
--- a/src/param.rs
+++ b/src/param.rs
@@ -222,7 +222,7 @@ impl Params {
             Some(val) => val,
             None => return Ok(None),
         };
-        ParamsFile::from_param(context, val).map(|file| Some(file))
+        ParamsFile::from_param(context, val).map(Some)
     }
 
     /// Gets the parameter and returns a [BlobObject] for it.
@@ -373,7 +373,7 @@ mod tests {
         if let ParamsFile::FsPath(p) = ParamsFile::from_param(&t.ctx, "/foo/bar/baz").unwrap() {
             assert_eq!(p, Path::new("/foo/bar/baz"));
         } else {
-            assert!(false, "Wrong enum variant");
+            panic!("Wrong enum variant");
         }
     }
 
@@ -383,7 +383,7 @@ mod tests {
         if let ParamsFile::Blob(b) = ParamsFile::from_param(&t.ctx, "$BLOBDIR/foo").unwrap() {
             assert_eq!(b.as_name(), "$BLOBDIR/foo");
         } else {
-            assert!(false, "Wrong enum variant");
+            panic!("Wrong enum variant");
         }
     }
 
diff --git a/src/pgp.rs b/src/pgp.rs
index 31c40e2f7..0d7014772 100644
--- a/src/pgp.rs
+++ b/src/pgp.rs
@@ -230,6 +230,7 @@ pub fn pk_encrypt(
     Ok(encoded_msg)
 }
 
+#[allow(clippy::implicit_hasher)]
 pub fn pk_decrypt(
     ctext: &[u8],
     private_keys_for_decryption: &Keyring,
diff --git a/src/securejoin.rs b/src/securejoin.rs
index 85d6b2cd4..b7e3c0995 100644
--- a/src/securejoin.rs
+++ b/src/securejoin.rs
@@ -533,12 +533,10 @@ pub(crate) fn handle_securejoin_handshake(
                 if group_chat_id == 0 {
                     error!(context, "Chat {} not found.", &field_grpid);
                     return Ok(ret);
-                } else {
-                    if let Err(err) =
-                        chat::add_contact_to_chat_ex(context, group_chat_id, contact_id, true)
-                    {
-                        error!(context, "failed to add contact: {}", err);
-                    }
+                } else if let Err(err) =
+                    chat::add_contact_to_chat_ex(context, group_chat_id, contact_id, true)
+                {
+                    error!(context, "failed to add contact: {}", err);
                 }
             } else {
                 send_handshake_msg(context, contact_chat_id, "vc-contact-confirm", "", None, "");
@@ -643,7 +641,7 @@ pub(crate) fn handle_securejoin_handshake(
                 let (group_chat_id, _, _) = chat::get_chat_id_by_grpid(context, &field_grpid);
                 context.call_cb(Event::SecurejoinMemberAdded {
                     chat_id: group_chat_id,
-                    contact_id: contact_id,
+                    contact_id,
                 });
             } else {
                 warn!(context, "vg-member-added-received invalid.",);
diff --git a/src/smtp/mod.rs b/src/smtp/mod.rs
index 950ac2cc3..c5ada1078 100644
--- a/src/smtp/mod.rs
+++ b/src/smtp/mod.rs
@@ -33,7 +33,7 @@ pub enum Error {
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-#[derive(DebugStub)]
+#[derive(Default, DebugStub)]
 pub struct Smtp {
     #[debug_stub(some = "SmtpTransport")]
     transport: Option<lettre::smtp::SmtpTransport>,
@@ -45,11 +45,7 @@ pub struct Smtp {
 impl Smtp {
     /// Create a new Smtp instances.
     pub fn new() -> Self {
-        Smtp {
-            transport: None,
-            transport_connected: false,
-            from: None,
-        }
+        Default::default()
     }
 
     /// Disconnect the SMTP transport and drop it entirely.
diff --git a/src/smtp/send.rs b/src/smtp/send.rs
index f6a2c0d99..6d3a3213b 100644
--- a/src/smtp/send.rs
+++ b/src/smtp/send.rs
@@ -58,7 +58,7 @@ impl Smtp {
                 context,
                 "uh? SMTP has no transport, failed to send to {}", recipients_display
             );
-            return Err(Error::NoTransport);
+            Err(Error::NoTransport)
         }
     }
 }
diff --git a/src/sql.rs b/src/sql.rs
index 6d6fb464c..61b071922 100644
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -68,13 +68,19 @@ pub struct Sql {
     in_use: Arc<ThreadLocal<String>>,
 }
 
-impl Sql {
-    pub fn new() -> Sql {
-        Sql {
+impl Default for Sql {
+    fn default() -> Self {
+        Self {
             pool: RwLock::new(None),
             in_use: Arc::new(ThreadLocal::new()),
         }
     }
+}
+
+impl Sql {
+    pub fn new() -> Sql {
+        Self::default()
+    }
 
     pub fn is_open(&self) -> bool {
         self.pool.read().unwrap().is_some()
@@ -1140,26 +1146,23 @@ pub fn housekeeping(context: &Context) {
 
                 unreferenced_count += 1;
 
-                match std::fs::metadata(entry.path()) {
-                    Ok(stats) => {
-                        let recently_created = stats.created().is_ok()
-                            && stats.created().unwrap() > keep_files_newer_than;
-                        let recently_modified = stats.modified().is_ok()
-                            && stats.modified().unwrap() > keep_files_newer_than;
-                        let recently_accessed = stats.accessed().is_ok()
-                            && stats.accessed().unwrap() > keep_files_newer_than;
+                if let Ok(stats) = std::fs::metadata(entry.path()) {
+                    let recently_created =
+                        stats.created().is_ok() && stats.created().unwrap() > keep_files_newer_than;
+                    let recently_modified = stats.modified().is_ok()
+                        && stats.modified().unwrap() > keep_files_newer_than;
+                    let recently_accessed = stats.accessed().is_ok()
+                        && stats.accessed().unwrap() > keep_files_newer_than;
 
-                        if recently_created || recently_modified || recently_accessed {
-                            info!(
-                                context,
-                                "Housekeeping: Keeping new unreferenced file #{}: {:?}",
-                                unreferenced_count,
-                                entry.file_name(),
-                            );
-                            continue;
-                        }
+                    if recently_created || recently_modified || recently_accessed {
+                        info!(
+                            context,
+                            "Housekeeping: Keeping new unreferenced file #{}: {:?}",
+                            unreferenced_count,
+                            entry.file_name(),
+                        );
+                        continue;
                     }
-                    Err(_) => {}
                 }
                 info!(
                     context,
diff --git a/src/stock.rs b/src/stock.rs
index ded5f7438..5df49e485 100644
--- a/src/stock.rs
+++ b/src/stock.rs
@@ -193,7 +193,7 @@ impl StockMessage {
     /// Default untranslated strings for stock messages.
     ///
     /// These could be used in logging calls, so no logging here.
-    fn fallback(&self) -> &'static str {
+    fn fallback(self) -> &'static str {
         self.get_str("fallback").unwrap_or_default()
     }
 }
@@ -238,7 +238,7 @@ impl Context {
             .unwrap()
             .get(&(id as usize))
         {
-            Some(ref x) => Cow::Owned(x.to_string()),
+            Some(ref x) => Cow::Owned((*x).to_string()),
             None => Cow::Borrowed(id.fallback()),
         }
     }
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 0be80ce2d..4b931b491 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -34,7 +34,7 @@ pub fn test_context(callback: Option<Box<ContextCallback>>) -> TestContext {
         None => Box::new(|_, _| 0),
     };
     let ctx = Context::new(cb, "FakeOs".into(), dbfile).unwrap();
-    TestContext { ctx: ctx, dir: dir }
+    TestContext { ctx, dir }
 }
 
 /// Return a dummy [TestContext].