fix all clippy lints

nyurik · emilio · commit 97ab9152b5ed · 2025-04-10T00:05:25.000Z
diff --git a/bindgen-tests/tests/parse_callbacks/item_discovery_callback/mod.rs b/bindgen-tests/tests/parse_callbacks/item_discovery_callback/mod.rs
@@ -20,7 +20,7 @@ impl ParseCallbacks for ItemDiscovery {
 
 fn test_item_discovery_callback(
     header: &str,
-    expected: HashMap<DiscoveredItemId, DiscoveredItem>,
+    expected: &HashMap<DiscoveredItemId, DiscoveredItem>,
 ) {
     let discovery = ItemDiscovery::default();
     let info = Rc::clone(&discovery.0);
@@ -34,7 +34,7 @@ fn test_item_discovery_callback(
         .generate()
         .expect("TODO: panic message");
 
-    compare_item_caches(&info.borrow(), &expected);
+    compare_item_caches(&info.borrow(), expected);
 }
 
 #[test]
@@ -103,7 +103,7 @@ fn test_item_discovery_callback_c() {
         ),
     ]);
     test_item_discovery_callback(
-        "/tests/parse_callbacks/item_discovery_callback/header_item_discovery.h", expected);
+        "/tests/parse_callbacks/item_discovery_callback/header_item_discovery.h", &expected);
 }
 
 #[test]
@@ -125,7 +125,7 @@ fn test_item_discovery_callback_cpp() {
         ),
     ]);
     test_item_discovery_callback(
-        "/tests/parse_callbacks/item_discovery_callback/header_item_discovery.hpp", expected);
+        "/tests/parse_callbacks/item_discovery_callback/header_item_discovery.hpp", &expected);
 }
 
 pub fn compare_item_caches(generated: &ItemCache, expected: &ItemCache) {
diff --git a/bindgen-tests/tests/quickchecking/src/fuzzers.rs b/bindgen-tests/tests/quickchecking/src/fuzzers.rs
@@ -1,5 +1,6 @@
 use quickcheck::{Arbitrary, Gen};
 use std::fmt;
+use std::fmt::Write as _;
 
 /// `BaseTypeC` is used in generation of C headers to represent the C language's
 /// primitive types as well as `void*`.
@@ -223,11 +224,10 @@ impl Arbitrary for DeclarationListC {
 /// Enables to string and format for `DeclarationListC` types.
 impl fmt::Display for DeclarationListC {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut display = String::new();
         for decl in &self.decls {
-            display += &format!("{decl}");
+            write!(f, "{decl}")?;
         }
-        write!(f, "{display}")
+        Ok(())
     }
 }
 
@@ -330,7 +330,7 @@ impl Arbitrary for ArrayDimensionC {
 
         for _ in 1..dimensions {
             // 16 is an arbitrary "not too big" number for capping array size.
-            def += &format!("[{}]", gen_range(g, lower_bound, 16));
+            let _ = write!(def, "[{}]", gen_range(g, lower_bound, 16));
         }
         ArrayDimensionC { def }
     }
@@ -347,7 +347,7 @@ impl fmt::Display for ArrayDimensionC {
 /// identifiers unique.
 impl MakeUnique for BasicTypeDeclarationC {
     fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{stamp}");
+        let _ = write!(self.ident_id, "_{stamp}");
     }
 }
 
@@ -384,7 +384,7 @@ impl fmt::Display for BasicTypeDeclarationC {
 /// identifiers unique.
 impl MakeUnique for StructDeclarationC {
     fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{stamp}");
+        let _ = write!(self.ident_id, "_{stamp}");
     }
 }
 
@@ -432,7 +432,7 @@ impl fmt::Display for StructDeclarationC {
 /// identifiers unique.
 impl MakeUnique for UnionDeclarationC {
     fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{stamp}");
+        let _ = write!(self.ident_id, "_{stamp}");
     }
 }
 
@@ -480,7 +480,7 @@ impl fmt::Display for UnionDeclarationC {
 /// `FunctionPointerDeclarationC` identifiers unique.
 impl MakeUnique for FunctionPointerDeclarationC {
     fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{stamp}");
+        let _ = write!(self.ident_id, "_{stamp}");
     }
 }
 
@@ -517,7 +517,7 @@ impl fmt::Display for FunctionPointerDeclarationC {
 /// identifiers unique.
 impl MakeUnique for FunctionPrototypeC {
     fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{stamp}");
+        let _ = write!(self.ident_id, "_{stamp}");
     }
 }
 
@@ -586,14 +586,13 @@ impl Arbitrary for ParameterListC {
 /// Enables to string and format for `ParameterListC` types.
 impl fmt::Display for ParameterListC {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut display = String::new();
         for (i, p) in self.params.iter().enumerate() {
             match i {
-                0 => display += &format!("{p}"),
-                _ => display += &format!(",{p}"),
+                0 => write!(f, "{p}")?,
+                _ => write!(f, ",{p}")?,
             }
         }
-        write!(f, "{display}")
+        Ok(())
     }
 }
 
@@ -612,11 +611,10 @@ impl Arbitrary for HeaderC {
 /// Enables to string and format for `HeaderC` types.
 impl fmt::Display for HeaderC {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut display = String::new();
         for decl in &self.def.decls {
-            display += &format!("{decl}");
+            write!(f, "{decl}")?;
         }
-        write!(f, "{display}")
+        Ok(())
     }
 }
 
diff --git a/bindgen-tests/tests/tests.rs b/bindgen-tests/tests/tests.rs
@@ -27,7 +27,7 @@ fn should_overwrite_expected() -> bool {
             return true;
         }
         assert!(
-            var == "0" || var == "",
+            var == "0" || var.is_empty(),
             "Invalid value of BINDGEN_OVERWRITE_EXPECTED"
         );
     }
@@ -57,7 +57,7 @@ fn error_diff_mismatch(
     if let Some(var) = env::var_os("BINDGEN_TESTS_DIFFTOOL") {
         //usecase: var = "meld" -> You can hand check differences
         let Some(std::path::Component::Normal(name)) =
-            filename.components().last()
+            filename.components().next_back()
         else {
             panic!("Why is the header variable so weird?")
         };
@@ -187,7 +187,7 @@ fn compare_generated_header(
             header.display(),
             looked_at,
         ),
-    };
+    }
 
     let (builder, roundtrip_builder) = builder.into_builder(check_roundtrip)?;
 
diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs
@@ -3075,7 +3075,7 @@ impl Method {
                     parent: parent_id,
                     final_name: name.clone(),
                 },
-            )
+            );
         });
 
         let mut function_name = function_item.canonical_name(ctx);
@@ -3138,7 +3138,7 @@ impl Method {
             exprs[0] = quote! {
                 self
             };
-        };
+        }
 
         let call = quote! {
             #function_name (#( #exprs ),* )
@@ -3282,7 +3282,7 @@ impl FromStr for EnumVariation {
 struct EnumBuilder {
     /// Type identifier of the enum.
     ///
-    /// This is the base name, i.e. for ModuleConst enums, this does not include the module name.
+    /// This is the base name, i.e. for `ModuleConst` enums, this does not include the module name.
     enum_type: Ident,
     /// Attributes applying to the enum type
     attrs: Vec<proc_macro2::TokenStream>,
@@ -3453,7 +3453,7 @@ impl EnumBuilder {
     }
 
     fn newtype_bitfield_impl(
-        prefix: Ident,
+        prefix: &Ident,
         rust_ty: &syn::Type,
     ) -> proc_macro2::TokenStream {
         let rust_ty_name = &rust_ty;
@@ -3593,7 +3593,7 @@ impl EnumBuilder {
 
                 let prefix = ctx.trait_prefix();
                 let bitfield_impl_opt = is_bitfield
-                    .then(|| Self::newtype_bitfield_impl(prefix, rust_ty));
+                    .then(|| Self::newtype_bitfield_impl(&prefix, rust_ty));
 
                 quote! {
                     // Previously variant impls where before the enum definition.
@@ -4625,7 +4625,7 @@ impl CodeGenerator for Function {
             FunctionKind::Method(ref method_kind) => {
                 method_kind.is_pure_virtual()
             }
-            _ => false,
+            FunctionKind::Function => false,
         };
         if is_pure_virtual && !ctx.options().generate_pure_virtual_functions {
             // Pure virtual methods have no actual symbol, so we can't generate
diff --git a/bindgen/codegen/serialize.rs b/bindgen/codegen/serialize.rs
@@ -368,7 +368,7 @@ impl<'a> CSerialize<'a> for Type {
                 match comp_info.kind() {
                     CompKind::Struct => write!(writer, "struct {name}")?,
                     CompKind::Union => write!(writer, "union {name}")?,
-                };
+                }
             }
             TypeKind::Enum(_enum_ty) => {
                 if self.is_const() {
@@ -384,7 +384,7 @@ impl<'a> CSerialize<'a> for Type {
                     loc: get_loc(item),
                 })
             }
-        };
+        }
 
         if !stack.is_empty() {
             write!(writer, " ")?;
diff --git a/bindgen/codegen/struct_layout.rs b/bindgen/codegen/struct_layout.rs
@@ -266,11 +266,11 @@ impl<'a> StructLayoutTracker<'a> {
             }
         };
 
-        if !is_union {
-            self.latest_offset += field_layout.size;
-        } else {
+        if is_union {
             self.latest_offset =
                 cmp::max(self.latest_offset, field_layout.size);
+        } else {
+            self.latest_offset += field_layout.size;
         }
         self.latest_field_layout = Some(field_layout);
         self.max_field_align =
diff --git a/bindgen/ir/analysis/derive.rs b/bindgen/ir/analysis/derive.rs
@@ -197,7 +197,7 @@ impl CannotDerive<'_> {
                         self.derive_trait
                     );
                 }
-            };
+            }
             return layout_can_derive;
         }
 
@@ -355,7 +355,7 @@ impl CannotDerive<'_> {
                                     self.derive_trait
                                 );
                             }
-                        };
+                        }
                         return layout_can_derive;
                     }
                 }
diff --git a/bindgen/ir/comp.rs b/bindgen/ir/comp.rs
@@ -1855,7 +1855,7 @@ impl IsOpaque for CompInfo {
             // See https://github.com/rust-lang/rust-bindgen/issues/537 and
             // https://github.com/rust-lang/rust/issues/33158
             if self.is_packed(ctx, layout.as_ref()) &&
-                layout.map_or(false, |l| l.align > 1)
+                layout.is_some_and(|l| l.align > 1)
             {
                 warn!("Found a type that is both packed and aligned to greater than \
                        1; Rust before version 1.33 doesn't have `#[repr(packed(N))]`, so we \
diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs
@@ -931,7 +931,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                 *ty.kind()
             {
                 typerefs.push((id, *ty, loc, parent_id));
-            };
+            }
         }
         typerefs
     }
@@ -3076,7 +3076,7 @@ impl TemplateParameters for PartialType {
                             num_params += 1;
                         }
                         _ => {}
-                    };
+                    }
                     clang_sys::CXChildVisit_Continue
                 });
                 num_params
diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs
@@ -727,15 +727,15 @@ impl Item {
         to.push_str(&self.canonical_name(ctx));
         if let ItemKind::Type(ref ty) = *self.kind() {
             if let TypeKind::TemplateInstantiation(ref inst) = *ty.kind() {
-                to.push_str(&format!("_open{level}_"));
+                let _ = write!(to, "_open{level}_");
                 for arg in inst.template_arguments() {
                     arg.into_resolver()
                         .through_type_refs()
                         .resolve(ctx)
                         .push_disambiguated_name(ctx, to, level + 1);
                     to.push('_');
                 }
-                to.push_str(&format!("close{level}"));
+                let _ = write!(to, "close{level}");
             }
         }
     }
diff --git a/bindgen/lib.rs b/bindgen/lib.rs
@@ -575,7 +575,7 @@ impl BindgenOptions {
         self.parse_callbacks
             .iter()
             .filter_map(|cb| f(cb.as_ref()))
-            .last()
+            .next_back()
     }
 
     fn all_callbacks<T>(
@@ -796,7 +796,7 @@ impl Bindings {
                 0,
                 format!("--target={effective_target}").into_boxed_str(),
             );
-        };
+        }
 
         fn detect_include_paths(options: &mut BindgenOptions) {
             if !options.detect_include_paths {
@@ -1209,7 +1209,7 @@ pub fn clang_version() -> ClangVersion {
                 };
             }
         }
-    };
+    }
     ClangVersion {
         parsed: None,
         full: raw_v.clone(),

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`use quickcheck::{Arbitrary, Gen};`
`2`	`2`	`use std::fmt;`
	`3`	`+use std::fmt::Write as _;`
`3`	`4`
`4`	`5`	/// `BaseTypeC` is used in generation of C headers to represent the C language's
`5`	`6`	/// primitive types as well as `void*`.
`@@ -223,11 +224,10 @@ impl Arbitrary for DeclarationListC {`
`223`	`224`	/// Enables to string and format for `DeclarationListC` types.
`224`	`225`	`impl fmt::Display for DeclarationListC {`
`225`	`226`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`226`		`- let mut display = String::new();`
`227`	`227`	`for decl in &self.decls {`
`228`		`- display += &format!("{decl}");`
	`228`	`+ write!(f, "{decl}")?;`
`229`	`229`	`}`
`230`		`- write!(f, "{display}")`
	`230`	`+ Ok(())`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`
`@@ -330,7 +330,7 @@ impl Arbitrary for ArrayDimensionC {`
`330`	`330`
`331`	`331`	`for _ in 1..dimensions {`
`332`	`332`	`// 16 is an arbitrary "not too big" number for capping array size.`
`333`		`- def += &format!("[{}]", gen_range(g, lower_bound, 16));`
	`333`	`+ let _ = write!(def, "[{}]", gen_range(g, lower_bound, 16));`
`334`	`334`	`}`
`335`	`335`	`ArrayDimensionC { def }`
`336`	`336`	`}`
`@@ -347,7 +347,7 @@ impl fmt::Display for ArrayDimensionC {`
`347`	`347`	`/// identifiers unique.`
`348`	`348`	`impl MakeUnique for BasicTypeDeclarationC {`
`349`	`349`	`fn make_unique(&mut self, stamp: usize) {`
`350`		`- self.ident_id += &format!("_{stamp}");`
	`350`	`+ let _ = write!(self.ident_id, "_{stamp}");`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`
`@@ -384,7 +384,7 @@ impl fmt::Display for BasicTypeDeclarationC {`
`384`	`384`	`/// identifiers unique.`
`385`	`385`	`impl MakeUnique for StructDeclarationC {`
`386`	`386`	`fn make_unique(&mut self, stamp: usize) {`
`387`		`- self.ident_id += &format!("_{stamp}");`
	`387`	`+ let _ = write!(self.ident_id, "_{stamp}");`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
`@@ -432,7 +432,7 @@ impl fmt::Display for StructDeclarationC {`
`432`	`432`	`/// identifiers unique.`
`433`	`433`	`impl MakeUnique for UnionDeclarationC {`
`434`	`434`	`fn make_unique(&mut self, stamp: usize) {`
`435`		`- self.ident_id += &format!("_{stamp}");`
	`435`	`+ let _ = write!(self.ident_id, "_{stamp}");`
`436`	`436`	`}`
`437`	`437`	`}`
`438`	`438`
`@@ -480,7 +480,7 @@ impl fmt::Display for UnionDeclarationC {`
`480`	`480`	/// `FunctionPointerDeclarationC` identifiers unique.
`481`	`481`	`impl MakeUnique for FunctionPointerDeclarationC {`
`482`	`482`	`fn make_unique(&mut self, stamp: usize) {`
`483`		`- self.ident_id += &format!("_{stamp}");`
	`483`	`+ let _ = write!(self.ident_id, "_{stamp}");`
`484`	`484`	`}`
`485`	`485`	`}`
`486`	`486`
`@@ -517,7 +517,7 @@ impl fmt::Display for FunctionPointerDeclarationC {`
`517`	`517`	`/// identifiers unique.`
`518`	`518`	`impl MakeUnique for FunctionPrototypeC {`
`519`	`519`	`fn make_unique(&mut self, stamp: usize) {`
`520`		`- self.ident_id += &format!("_{stamp}");`
	`520`	`+ let _ = write!(self.ident_id, "_{stamp}");`
`521`	`521`	`}`
`522`	`522`	`}`
`523`	`523`
`@@ -586,14 +586,13 @@ impl Arbitrary for ParameterListC {`
`586`	`586`	/// Enables to string and format for `ParameterListC` types.
`587`	`587`	`impl fmt::Display for ParameterListC {`
`588`	`588`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`589`		`- let mut display = String::new();`
`590`	`589`	`for (i, p) in self.params.iter().enumerate() {`
`591`	`590`	`match i {`
`592`		`- 0 => display += &format!("{p}"),`
`593`		`- _ => display += &format!(",{p}"),`
	`591`	`+ 0 => write!(f, "{p}")?,`
	`592`	`+ _ => write!(f, ",{p}")?,`
`594`	`593`	`}`
`595`	`594`	`}`
`596`		`- write!(f, "{display}")`
	`595`	`+ Ok(())`
`597`	`596`	`}`
`598`	`597`	`}`
`599`	`598`
`@@ -612,11 +611,10 @@ impl Arbitrary for HeaderC {`
`612`	`611`	/// Enables to string and format for `HeaderC` types.
`613`	`612`	`impl fmt::Display for HeaderC {`
`614`	`613`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`615`		`- let mut display = String::new();`
`616`	`614`	`for decl in &self.def.decls {`
`617`		`- display += &format!("{decl}");`
	`615`	`+ write!(f, "{decl}")?;`
`618`	`616`	`}`
`619`		`- write!(f, "{display}")`
	`617`	`+ Ok(())`
`620`	`618`	`}`
`621`	`619`	`}`
`622`	`620`
Original file line number	Diff line number	Diff line change
`@@ -266,11 +266,11 @@ impl<'a> StructLayoutTracker<'a> {`
`266`	`266`	`}`
`267`	`267`	`};`
`268`	`268`
`269`		`- if !is_union {`
`270`		`- self.latest_offset += field_layout.size;`
`271`		`- } else {`
	`269`	`+ if is_union {`
`272`	`270`	`self.latest_offset =`
`273`	`271`	`cmp::max(self.latest_offset, field_layout.size);`
	`272`	`+ } else {`
	`273`	`+ self.latest_offset += field_layout.size;`
`274`	`274`	`}`
`275`	`275`	`self.latest_field_layout = Some(field_layout);`
`276`	`276`	`self.max_field_align =`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ impl CannotDerive<'_> {`
`197`	`197`	`self.derive_trait`
`198`	`198`	`);`
`199`	`199`	`}`
`200`		`- };`
	`200`	`+ }`
`201`	`201`	`return layout_can_derive;`
`202`	`202`	`}`
`203`	`203`
`@@ -355,7 +355,7 @@ impl CannotDerive<'_> {`
`355`	`355`	`self.derive_trait`
`356`	`356`	`);`
`357`	`357`	`}`
`358`		`- };`
	`358`	`+ }`
`359`	`359`	`return layout_can_derive;`
`360`	`360`	`}`
`361`	`361`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1855,7 +1855,7 @@ impl IsOpaque for CompInfo {`
`1855`	`1855`	`// See https://github.com/rust-lang/rust-bindgen/issues/537 and`
`1856`	`1856`	`// https://github.com/rust-lang/rust/issues/33158`
`1857`	`1857`	`if self.is_packed(ctx, layout.as_ref()) &&`
`1858`		`- layout.map_or(false, \|l\| l.align > 1)`
	`1858`	`+ layout.is_some_and(\|l\| l.align > 1)`
`1859`	`1859`	`{`
`1860`	`1860`	`warn!("Found a type that is both packed and aligned to greater than \`
`1861`	`1861`	1; Rust before version 1.33 doesn't have `#[repr(packed(N))]`, so we \
Original file line number	Diff line number	Diff line change
`@@ -931,7 +931,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"`
`931`	`931`	`*ty.kind()`
`932`	`932`	`{`
`933`	`933`	`typerefs.push((id, *ty, loc, parent_id));`
`934`		`- };`
	`934`	`+ }`
`935`	`935`	`}`
`936`	`936`	`typerefs`
`937`	`937`	`}`
`@@ -3076,7 +3076,7 @@ impl TemplateParameters for PartialType {`
`3076`	`3076`	`num_params += 1;`
`3077`	`3077`	`}`
`3078`	`3078`	`_ => {}`
`3079`		`- };`
	`3079`	`+ }`
`3080`	`3080`	`clang_sys::CXChildVisit_Continue`
`3081`	`3081`	`});`
`3082`	`3082`	`num_params`
Original file line number	Diff line number	Diff line change
`@@ -727,15 +727,15 @@ impl Item {`
`727`	`727`	`to.push_str(&self.canonical_name(ctx));`
`728`	`728`	`if let ItemKind::Type(ref ty) = *self.kind() {`
`729`	`729`	`if let TypeKind::TemplateInstantiation(ref inst) = *ty.kind() {`
`730`		`- to.push_str(&format!("_open{level}_"));`
	`730`	`+ let _ = write!(to, "_open{level}_");`
`731`	`731`	`for arg in inst.template_arguments() {`
`732`	`732`	`arg.into_resolver()`
`733`	`733`	`.through_type_refs()`
`734`	`734`	`.resolve(ctx)`
`735`	`735`	`.push_disambiguated_name(ctx, to, level + 1);`
`736`	`736`	`to.push('_');`
`737`	`737`	`}`
`738`		`- to.push_str(&format!("close{level}"));`
	`738`	`+ let _ = write!(to, "close{level}");`
`739`	`739`	`}`
`740`	`740`	`}`
`741`	`741`	`}`