clippy: fix new 1.72 default clippy lints

Signed-off-by: Manos Pitsidianakis <manos@pitsidianak.is>

meli/src/components.rs

@@ -94,7 +94,7 @@ impl ExtendShortcutsMaps for ShortcutMaps {
                 true
             }
         });
-        self.extend(other.into_iter());
+        self.extend(other);
     }
 }
 

meli/src/conf/themes.rs

@@ -2044,13 +2044,13 @@ fn test_theme_parsing() {
     assert!(def.validate().is_ok());
     /* MUST SUCCEED: new user theme `hunter2`, theme `dark` has user
      * redefinitions */
-    const TEST_STR: &str = r##"[dark]
+    const TEST_STR: &str = r#"[dark]
 "mail.listing.tag_default" = { fg = "White", bg = "HotPink3" }
 "mail.listing.attachment_flag" = { fg = "mail.listing.tag_default.bg" }
 "mail.view.headers" = { bg = "mail.listing.tag_default.fg" }
 
 ["hunter2"]
-"mail.view.body" = { fg = "Black", bg = "White"}"##;
+"mail.view.body" = { fg = "Black", bg = "White"}"#;
     let parsed: Themes = toml::from_str(TEST_STR).unwrap();
     assert!(parsed.other_themes.contains_key("hunter2"));
     assert_eq!(
@@ -2079,16 +2079,16 @@ fn test_theme_parsing() {
     );
     assert!(parsed.validate().is_ok());
     /* MUST FAIL: theme `dark` contains a cycle */
-    const HAS_CYCLE: &str = r##"[dark]
+    const HAS_CYCLE: &str = r#"[dark]
 "mail.listing.compact.even" = { fg = "mail.listing.compact.odd" }
 "mail.listing.compact.odd" = { fg = "mail.listing.compact.even" }
-"##;
+"#;
     let parsed: Themes = toml::from_str(HAS_CYCLE).unwrap();
     assert!(parsed.validate().is_err());
     /* MUST FAIL: theme `dark` contains an invalid key */
-    const HAS_INVALID_KEYS: &str = r##"[dark]
+    const HAS_INVALID_KEYS: &str = r#"[dark]
 "asdfsafsa" = { fg = "Black" }
-"##;
+"#;
     let parsed: std::result::Result<Themes, _> = toml::from_str(HAS_INVALID_KEYS);
     assert!(parsed.is_err());
     /* MUST SUCCEED: alias $Jebediah resolves to a valid color */
@@ -2114,38 +2114,38 @@ color_aliases= { "Jebediah" = "#b4da55" }
     let parsed: Themes = toml::from_str(TEST_INVALID_ALIAS_STR).unwrap();
     assert!(parsed.validate().is_err());
     /* MUST FAIL: Color alias $Jebediah is defined as itself */
-    const TEST_CYCLIC_ALIAS_STR: &str = r##"[dark]
+    const TEST_CYCLIC_ALIAS_STR: &str = r#"[dark]
 color_aliases= { "Jebediah" = "$Jebediah" }
 "mail.listing.tag_default" = { fg = "$Jebediah" }
-"##;
+"#;
     let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR).unwrap();
     assert!(parsed.validate().is_err());
     /* MUST FAIL: Attr alias $Jebediah is defined as itself */
-    const TEST_CYCLIC_ALIAS_ATTR_STR: &str = r##"[dark]
+    const TEST_CYCLIC_ALIAS_ATTR_STR: &str = r#"[dark]
 attr_aliases= { "Jebediah" = "$Jebediah" }
 "mail.listing.tag_default" = { attrs = "$Jebediah" }
-"##;
+"#;
     let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_ATTR_STR).unwrap();
     assert!(parsed.validate().is_err());
     /* MUST FAIL: alias $Jebediah resolves to a cycle */
-    const TEST_CYCLIC_ALIAS_STR_2: &str = r##"[dark]
+    const TEST_CYCLIC_ALIAS_STR_2: &str = r#"[dark]
 color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default" }
 "mail.listing.tag_default" = { fg = "$Jebediah" }
-"##;
+"#;
     let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_2).unwrap();
     assert!(parsed.validate().is_err());
     /* MUST SUCCEED: alias $Jebediah resolves to a key's field */
-    const TEST_CYCLIC_ALIAS_STR_3: &str = r##"[dark]
+    const TEST_CYCLIC_ALIAS_STR_3: &str = r#"[dark]
 color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.bg" }
 "mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
-"##;
+"#;
     let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_3).unwrap();
     assert!(parsed.validate().is_ok());
     /* MUST FAIL: alias $Jebediah resolves to an invalid key */
-    const TEST_INVALID_LINK_KEY_FIELD_STR: &str = r##"[dark]
+    const TEST_INVALID_LINK_KEY_FIELD_STR: &str = r#"[dark]
 color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.attrs" }
 "mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
-"##;
+"#;
     let parsed: Themes = toml::from_str(TEST_INVALID_LINK_KEY_FIELD_STR).unwrap();
     assert!(parsed.validate().is_err());
 }
@@ -2156,7 +2156,7 @@ fn test_theme_key_values() {
     let mut rust_files: VecDeque<PathBuf> = VecDeque::new();
     let mut dirs_queue: VecDeque<PathBuf> = VecDeque::new();
     dirs_queue.push_back("src/".into());
-    let re_whitespace = regex::Regex::new(r#"\s*"#).unwrap();
+    let re_whitespace = regex::Regex::new(r"\s*").unwrap();
     let re_conf = regex::Regex::new(r#"value\([&]?context,"([^"]*)""#).unwrap();
 
     while let Some(dir) = dirs_queue.pop_front() {

meli/src/mail/compose.rs

@@ -344,7 +344,7 @@ impl Composer {
                             melib::email::parser::generic::mailto(list_post_addr)
                                 .map(|(_, m)| m.address)
                         {
-                            to.extend(list_address.into_iter());
+                            to.extend(list_address);
                         }
                     }
                 }

meli/src/mail/listing.rs

@@ -680,7 +680,7 @@ pub trait MailListingTrait: ListingTrait {
                                     .collect();
                                 let mut file =
                                     std::io::BufWriter::new(std::fs::File::create(&path_)?);
-                                let mut iter = envs.iter().zip(bytes.into_iter());
+                                let mut iter = envs.iter().zip(bytes);
                                 let tags_lck = collection.tag_index.read().unwrap();
                                 if let Some((env, ref bytes)) = iter.next() {
                                     let tags: Vec<&str> = env
@@ -1552,7 +1552,7 @@ impl Component for Listing {
                                     row_updates.push(*k);
                                 }
                             }
-                            self.component.row_updates().extend(row_updates.into_iter());
+                            self.component.row_updates().extend(row_updates);
                         }
                         _ => {}
                     },

meli/src/utilities.rs

@@ -634,18 +634,17 @@ impl Component for StatusBar {
                     return true;
                 }
                 let pos = self.ex_buffer_cmd_history_pos.map(|p| p + 1).unwrap_or(0);
-                let pos = Some(std::cmp::min(pos, self.cmd_history.len().saturating_sub(1)));
-                if pos != self.ex_buffer_cmd_history_pos {
+                let pos = std::cmp::min(pos, self.cmd_history.len().saturating_sub(1));
+                if Some(pos) != self.ex_buffer_cmd_history_pos {
                     let mut utext = UText::new(
-                        self.cmd_history[self.cmd_history.len().saturating_sub(1) - pos.unwrap()]
-                            .clone(),
+                        self.cmd_history[self.cmd_history.len().saturating_sub(1) - pos].clone(),
                     );
                     let len = utext.as_str().len();
                     utext.set_cursor(len);
                     self.container.set_dirty(true);
                     self.set_dirty(true);
                     self.ex_buffer = TextField::new(utext, None);
-                    self.ex_buffer_cmd_history_pos = pos;
+                    self.ex_buffer_cmd_history_pos = Some(pos);
                     self.dirty = true;
                 }
 
@@ -659,18 +658,16 @@ impl Component for StatusBar {
                     self.ex_buffer_cmd_history_pos = None;
                     self.ex_buffer.clear();
                     self.dirty = true;
-                } else if self.ex_buffer_cmd_history_pos.is_some() {
-                    let pos = self.ex_buffer_cmd_history_pos.map(|p| p - 1);
+                } else if let Some(pos) = self.ex_buffer_cmd_history_pos.map(|p| p - 1) {
                     let mut utext = UText::new(
-                        self.cmd_history[self.cmd_history.len().saturating_sub(1) - pos.unwrap()]
-                            .clone(),
+                        self.cmd_history[self.cmd_history.len().saturating_sub(1) - pos].clone(),
                     );
                     let len = utext.as_str().len();
                     utext.set_cursor(len);
                     self.container.set_dirty(true);
                     self.set_dirty(true);
                     self.ex_buffer = TextField::new(utext, None);
-                    self.ex_buffer_cmd_history_pos = pos;
+                    self.ex_buffer_cmd_history_pos = Some(pos);
                     self.dirty = true;
                 }
 

meli/src/utilities/tables.rs

@@ -176,7 +176,6 @@ impl<const N: usize> DataColumns<N> {
         let mut width_accum = 0;
         let mut growees = 0;
         let mut growees_max = 0;
-        let grow_minmax = None;
         for i in 0..N {
             if screen_height == 0 {
                 self.widths[i] = 0;
@@ -207,20 +206,12 @@ impl<const N: usize> DataColumns<N> {
         // add column gaps
         width_accum += 2 * N.saturating_sub(1);
         debug_assert!(growees >= growees_max);
-        debug_assert!(grow_minmax.is_none() || growees_max > 0);
         if width_accum >= screen_width || screen_height == 0 || screen_width == 0 || growees == 0 {
             self.width_accum = width_accum;
             return width_accum;
         }
         let distribute = screen_width - width_accum;
-        let maxmins = growees_max * grow_minmax.unwrap_or(0);
-        let part = if maxmins != 0 && growees_max < growees {
-            distribute.saturating_sub(maxmins) / (growees - growees_max)
-        } else if maxmins != 0 {
-            distribute.saturating_sub(maxmins) / growees_max + grow_minmax.unwrap_or(0)
-        } else {
-            distribute / growees
-        };
+        let part = distribute / growees;
 
         for i in 0..N {
             match self.elasticities[i] {

melib/src/backends.rs

@@ -699,7 +699,7 @@ impl LazyCountSet {
 
     pub fn insert_existing_set(&mut self, set: BTreeSet<EnvelopeHash>) {
         let old_len = self.set.len();
-        self.set.extend(set.into_iter());
+        self.set.extend(set);
         self.not_yet_seen = self.not_yet_seen.saturating_sub(self.set.len() - old_len);
     }
 
@@ -723,7 +723,7 @@ impl LazyCountSet {
     }
 
     pub fn insert_set(&mut self, set: BTreeSet<EnvelopeHash>) {
-        self.set.extend(set.into_iter());
+        self.set.extend(set);
     }
 
     pub fn remove(&mut self, env_hash: EnvelopeHash) -> bool {

melib/src/email/compose.rs

@@ -352,7 +352,7 @@ impl Draft {
                 body_attachment.set_raw(self.body.as_bytes().to_vec());
                 parts.push(body_attachment);
             }
-            parts.extend(attachments.into_iter());
+            parts.extend(attachments);
             build_multipart(&mut ret, MultipartType::Mixed, &[], parts);
         }
 

melib/src/notmuch/message.rs

@@ -36,7 +36,7 @@ impl<'m> Message<'m> {
         let lib = db.lib.clone();
         unsafe {
             call!(lib, notmuch_database_find_message)(
-                *db.inner.read().unwrap(),
+                db.inner.lock().unwrap().as_mut(),
                 msg_id.as_ptr(),
                 std::ptr::addr_of_mut!(message),
             )

melib/src/notmuch/mod.rs

@@ -26,6 +26,7 @@ use std::{
     os::unix::ffi::OsStrExt,
     path::{Path, PathBuf},
     pin::Pin,
+    ptr::NonNull,
     sync::{Arc, Mutex, RwLock},
 };
 
@@ -71,20 +72,33 @@ pub use tags::*;
 mod thread;
 pub use thread::*;
 
+#[derive(Debug)]
+#[repr(transparent)]
+struct DbPointer(NonNull<notmuch_database_t>);
+
+unsafe impl Send for DbPointer {}
+unsafe impl Sync for DbPointer {}
+
+impl DbPointer {
+    #[inline]
+    pub(self) fn as_mut(&mut self) -> *mut notmuch_database_t {
+        unsafe { self.0.as_mut() }
+    }
+}
+
 #[derive(Debug)]
 pub struct DbConnection {
     #[allow(dead_code)]
     pub lib: Arc<libloading::Library>,
-    pub inner: Arc<RwLock<*mut notmuch_database_t>>,
+    inner: Arc<Mutex<DbPointer>>,
     pub revision_uuid: Arc<RwLock<u64>>,
-    pub database_ph: std::marker::PhantomData<&'static mut notmuch_database_t>,
 }
 
 impl DbConnection {
     pub fn get_revision_uuid(&self) -> u64 {
         unsafe {
             call!(self.lib, notmuch_database_get_revision)(
-                *self.inner.read().unwrap(),
+                self.inner.lock().unwrap().as_mut(),
                 std::ptr::null_mut(),
             )
         }
@@ -182,8 +196,6 @@ impl DbConnection {
     }
 }
 
-unsafe impl Send for DbConnection {}
-unsafe impl Sync for DbConnection {}
 #[derive(Debug)]
 pub struct NotmuchError(String);
 
@@ -201,14 +213,19 @@ impl std::error::Error for NotmuchError {
 
 impl Drop for DbConnection {
     fn drop(&mut self) {
-        let inner = self.inner.write().unwrap();
+        let mut inner = self.inner.lock().unwrap();
         unsafe {
-            if let Err(err) = try_call!(self.lib, call!(self.lib, notmuch_database_close)(*inner)) {
+            if let Err(err) = try_call!(
+                self.lib,
+                call!(self.lib, notmuch_database_close)(inner.as_mut())
+            ) {
                 debug!(err);
                 return;
             }
-            if let Err(err) = try_call!(self.lib, call!(self.lib, notmuch_database_destroy)(*inner))
-            {
+            if let Err(err) = try_call!(
+                self.lib,
+                call!(self.lib, notmuch_database_destroy)(inner.as_mut())
+            ) {
                 debug!(err);
             }
         }
@@ -550,12 +567,24 @@ impl NotmuchDb {
                 status
             )));
         }
-        assert!(!database.is_null());
+        #[cfg(debug_assertions)]
+        let database = DbPointer(
+            NonNull::new(database)
+                .expect("notmuch_database_open returned a NULL pointer and status = 0"),
+        );
+        #[cfg(not(debug_assertions))]
+        let database = NonNull::new(database).map(DbPointer).ok_or_else(|| {
+            Error::new("notmuch_database_open returned a NULL pointer and status = 0")
+                .set_kind(ErrorKind::External)
+                .set_details(
+                    "libnotmuch exhibited an unexpected and unrecoverable error. Make sure your \
+                     libnotmuch version is compatible with this release.",
+                )
+        })?;
         let ret = DbConnection {
             lib,
             revision_uuid,
-            inner: Arc::new(RwLock::new(database)),
-            database_ph: std::marker::PhantomData,
+            inner: Arc::new(Mutex::new(database)),
         };
         if *ret.revision_uuid.read().unwrap() == 0 {
             let new = ret.get_revision_uuid();
@@ -1071,7 +1100,10 @@ impl<'s> Query<'s> {
         let lib: Arc<libloading::Library> = database.lib.clone();
         let query_cstr = std::ffi::CString::new(query_str)?;
         let query: *mut notmuch_query_t = unsafe {
-            call!(lib, notmuch_query_create)(*database.inner.read().unwrap(), query_cstr.as_ptr())
+            call!(lib, notmuch_query_create)(
+                database.inner.lock().unwrap().as_mut(),
+                query_cstr.as_ptr(),
+            )
         };
         if query.is_null() {
             return Err(Error::new("Could not create query. Out of memory?"));

melib/src/text_processing/line_break.rs

@@ -1216,7 +1216,7 @@ fn reflow_helper(
         if in_paragraph {
             if let Some(width) = width {
                 let ex = linear(&paragraph, width);
-                ret.extend(ex.into_iter());
+                ret.extend(ex);
             } else {
                 ret.push(paragraph);
             }
@@ -1803,7 +1803,7 @@ fn reflow_helper2(
         if in_paragraph {
             if let Some(width) = width {
                 let ex = linear(&paragraph, width);
-                ret.extend(ex.into_iter());
+                ret.extend(ex);
             } else {
                 ret.push_back(paragraph);
             }

melib/src/utils/parsec.rs

@@ -312,7 +312,7 @@ macro_rules! permutation {
                 let mut any_success = false;
                 $(if results.$field.is_none() {
                     if let Ok((rest, res)) = $parser.parse(input) {
-                        if !matches!(res, None) || count > left {
+                        if res.is_some() || count > left {
                             results.$field = Some(res);
                             finished += 1;
                             count = 1;