thanks clippy

Author: Byron

gix-attributes/src/search/outcome.rs

@@ -176,12 +176,11 @@ impl Outcome {
         source: Option<&std::path::PathBuf>,
         sequence_number: usize,
     ) -> bool {
-        self.attrs_stack.extend(attrs.filter_map(|attr| {
-            self.matches_by_id[attr.id.0]
-                .r#match
-                .is_none()
-                .then(|| (attr.id, attr.inner.clone(), None))
-        }));
+        self.attrs_stack.extend(
+            attrs
+                .filter(|attr| self.matches_by_id[attr.id.0].r#match.is_none())
+                .map(|attr| (attr.id, attr.inner.clone(), None)),
+        );
         while let Some((id, assignment, parent_order)) = self.attrs_stack.pop() {
             let slot = &mut self.matches_by_id[id.0];
             if slot.r#match.is_some() {
@@ -212,12 +211,12 @@ impl Outcome {
             if is_macro {
                 // TODO(borrowchk): one fine day we should be able to re-borrow `slot` without having to redo the array access.
                 let slot = &self.matches_by_id[id.0];
-                self.attrs_stack.extend(slot.macro_attributes.iter().filter_map(|attr| {
-                    self.matches_by_id[attr.id.0]
-                        .r#match
-                        .is_none()
-                        .then(|| (attr.id, attr.inner.clone(), Some(id)))
-                }));
+                self.attrs_stack.extend(
+                    slot.macro_attributes
+                        .iter()
+                        .filter(|attr| self.matches_by_id[attr.id.0].r#match.is_none())
+                        .map(|attr| (attr.id, attr.inner.clone(), Some(id))),
+                );
             }
         }
         false

gix-config/src/parse/section/mod.rs

@@ -88,7 +88,7 @@ mod types {
 
             impl PartialOrd for $name<'_> {
                 fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-                    self.cmp(other).into()
+                    Some(self.cmp(other))
                 }
             }
 

gix-filter/src/eol/convert_to_git.rs

@@ -81,7 +81,7 @@ pub(crate) mod function {
                 return Ok(false);
             }
 
-            if let Some(()) = index_object(buf).map_err(|err| Error::FetchObjectFromIndex(err))? {
+            if let Some(()) = index_object(buf).map_err(Error::FetchObjectFromIndex)? {
                 let has_crlf_in_index = buf
                     .find_byte(b'\r')
                     .map(|_| Stats::from_bytes(buf))

gix-odb/src/store_impls/dynamic/load_index.rs

@@ -711,7 +711,7 @@ impl PartialEq<Self> for Either {
 
 impl PartialOrd<Self> for Either {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.path().partial_cmp(other.path())
+        Some(self.path().cmp(other.path()))
     }
 }
 

gix-pack/tests/pack/index.rs

@@ -409,8 +409,7 @@ fn pack_lookup() -> Result<(), Box<dyn std::error::Error>> {
                 "iteration should yield the same pack offsets as the index"
             );
 
-            let mut buf = Vec::new();
-            buf.resize(entry.decompressed_size as usize, 0);
+            let mut buf = vec![0u8; entry.decompressed_size as usize];
             let pack_entry = pack.entry(offset_from_index);
             assert_eq!(
                 pack_entry.pack_offset(),

gix-packetline/tests/encode/mod.rs

@@ -27,9 +27,7 @@ mod data_to_write {
     #[maybe_async::test(feature = "blocking-io", async(feature = "async-io", async_std::test))]
     async fn error_if_data_exceeds_limit() {
         fn vec_sized(size: usize) -> Vec<u8> {
-            let mut v = Vec::new();
-            v.resize(size, 0);
-            v
+            vec![0; size]
         }
 
         let res = data_to_write(&vec_sized(65516 + 1), io::sink()).await;

gix-packetline/tests/write/mod.rs

@@ -38,11 +38,7 @@ async fn write_text_and_write_binary() -> crate::Result {
 #[maybe_async::test(feature = "blocking-io", async(feature = "async-io", async_std::test))]
 async fn huge_writes_are_split_into_lines() -> crate::Result {
     let buf = {
-        let data = {
-            let mut v = Vec::new();
-            v.resize(MAX_DATA_LEN * 2, 0);
-            v
-        };
+        let data = vec![0u8; MAX_DATA_LEN * 2];
         let mut w = Writer::new(Vec::new());
         w.write(&data).await?;
         w.into_inner()

gix-pathspec/tests/search/mod.rs

@@ -219,8 +219,8 @@ mod baseline {
                         is_inconsistent = spec.as_bstr() == "git-inconsistency";
                         !is_inconsistent
                     })
-                    .filter_map(|s| (!s.trim().is_empty()).then(|| s.trim()))
-                    .map(|pathspec| gix_pathspec::parse(pathspec, Default::default()).expect("valid pathspec"))
+                    .filter(|s| !s.trim().is_empty())
+                    .map(|pathspec| gix_pathspec::parse(pathspec.trim(), Default::default()).expect("valid pathspec"))
                     .collect();
                 Expected {
                     pathspecs,

gix-ref/src/store/packed/transaction.rs

@@ -78,7 +78,7 @@ impl packed::Transaction {
                 edit.peeled = loop {
                     let kind = find(next_id, &mut buf)?;
                     match kind {
-                        Some(kind) if kind == gix_object::Kind::Tag => {
+                        Some(gix_object::Kind::Tag) => {
                             next_id = gix_object::TagRefIter::from_bytes(&buf).target_id().map_err(|_| {
                                 prepare::Error::Resolve(
                                     format!("Couldn't get target object id from tag {next_id}").into(),

gix-refspec/src/spec.rs

@@ -65,13 +65,13 @@ mod impls {
 
     impl PartialOrd for RefSpecRef<'_> {
         fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            self.instruction().partial_cmp(&other.instruction())
+            Some(self.cmp(other))
         }
     }
 
     impl PartialOrd for RefSpec {
         fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            self.to_ref().partial_cmp(&other.to_ref())
+            Some(self.to_ref().cmp(&other.to_ref()))
         }
     }