Resolve new Clippy lints

Author: GKFX

bindgen/callbacks.rs

@@ -8,19 +8,16 @@ use std::fmt;
 
 /// An enum to allow ignoring parsing of macros.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Default)]
 pub enum MacroParsingBehavior {
     /// Ignore the macro, generating no code for it, or anything that depends on
     /// it.
     Ignore,
     /// The default behavior bindgen would have otherwise.
+    #[default]
     Default,
 }
 
-impl Default for MacroParsingBehavior {
-    fn default() -> Self {
-        MacroParsingBehavior::Default
-    }
-}
 
 /// A trait to allow configuring different kinds of types in different
 /// situations.

bindgen/clang.rs

@@ -14,8 +14,8 @@ use std::fs::OpenOptions;
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong};
-use std::{mem, ptr, slice};
 use std::sync::OnceLock;
+use std::{mem, ptr, slice};
 
 /// Type representing a clang attribute.
 ///

bindgen/codegen/mod.rs

@@ -2608,7 +2608,7 @@ impl CodeGenerator for CompInfo {
                 ctx,
                 &canonical_ident,
                 flex_inner_ty,
-                &*generic_param_names,
+                &generic_param_names,
                 &impl_generics_labels,
             ));
         }
@@ -3011,6 +3011,7 @@ impl Method {
 
 /// A helper type that represents different enum variations.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Default)]
 pub enum EnumVariation {
     /// The code for this enum will use a Rust enum. Note that creating this in unsafe code
     /// (including FFI) with an invalid value will invoke undefined behaviour, whether or not
@@ -3027,6 +3028,7 @@ pub enum EnumVariation {
         is_global: bool,
     },
     /// The code for this enum will use consts
+    #[default]
     Consts,
     /// The code for this enum will use a module containing consts
     ModuleConsts,
@@ -3044,11 +3046,6 @@ impl EnumVariation {
     }
 }
 
-impl Default for EnumVariation {
-    fn default() -> EnumVariation {
-        EnumVariation::Consts
-    }
-}
 
 impl fmt::Display for EnumVariation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -3758,10 +3755,12 @@ impl CodeGenerator for Enum {
 
 /// Enum for the default type of macro constants.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Default)]
 pub enum MacroTypeVariation {
     /// Use i32 or i64
     Signed,
     /// Use u32 or u64
+    #[default]
     Unsigned,
 }
 
@@ -3775,11 +3774,6 @@ impl fmt::Display for MacroTypeVariation {
     }
 }
 
-impl Default for MacroTypeVariation {
-    fn default() -> MacroTypeVariation {
-        MacroTypeVariation::Unsigned
-    }
-}
 
 impl std::str::FromStr for MacroTypeVariation {
     type Err = std::io::Error;
@@ -3802,8 +3796,10 @@ impl std::str::FromStr for MacroTypeVariation {
 
 /// Enum for how aliases should be translated.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Default)]
 pub enum AliasVariation {
     /// Convert to regular Rust alias
+    #[default]
     TypeAlias,
     /// Create a new type by wrapping the old type in a struct and using #[repr(transparent)]
     NewType,
@@ -3823,11 +3819,6 @@ impl fmt::Display for AliasVariation {
     }
 }
 
-impl Default for AliasVariation {
-    fn default() -> AliasVariation {
-        AliasVariation::TypeAlias
-    }
-}
 
 impl std::str::FromStr for AliasVariation {
     type Err = std::io::Error;

bindgen/ir/analysis/has_vtable.rs

@@ -10,8 +10,10 @@ use std::ops;
 
 /// The result of the `HasVtableAnalysis` for an individual item.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Default)]
 pub(crate) enum HasVtableResult {
     /// The item does not have a vtable pointer.
+    #[default]
     No,
 
     /// The item has a vtable and the actual vtable pointer is within this item.
@@ -22,11 +24,6 @@ pub(crate) enum HasVtableResult {
     BaseHasVtable,
 }
 
-impl Default for HasVtableResult {
-    fn default() -> Self {
-        HasVtableResult::No
-    }
-}
 
 impl HasVtableResult {
     /// Take the least upper bound of `self` and `rhs`.

bindgen/ir/analysis/mod.rs

@@ -126,20 +126,17 @@ pub(crate) trait MonotoneFramework: Sized + fmt::Debug {
 /// Whether an analysis's `constrain` function modified the incremental results
 /// or not.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Default)]
 pub(crate) enum ConstrainResult {
     /// The incremental results were updated, and the fix-point computation
     /// should continue.
     Changed,
 
     /// The incremental results were not updated.
+    #[default]
     Same,
 }
 
-impl Default for ConstrainResult {
-    fn default() -> Self {
-        ConstrainResult::Same
-    }
-}
 
 impl ops::BitOr for ConstrainResult {
     type Output = Self;

bindgen/ir/analysis/sizedness.rs

@@ -25,12 +25,14 @@ use std::{cmp, ops};
 /// We initially assume that all types are `ZeroSized` and then update our
 /// understanding as we learn more about each type.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Default)]
 pub(crate) enum SizednessResult {
     /// The type is zero-sized.
     ///
     /// This means that if it is a C++ type, and is not being used as a base
     /// member, then we must add an `_address` byte to enforce the
     /// unique-address-per-distinct-object-instance rule.
+    #[default]
     ZeroSized,
 
     /// Whether this type is zero-sized or not depends on whether a type
@@ -62,11 +64,6 @@ pub(crate) enum SizednessResult {
     NonZeroSized,
 }
 
-impl Default for SizednessResult {
-    fn default() -> Self {
-        SizednessResult::ZeroSized
-    }
-}
 
 impl SizednessResult {
     /// Take the least upper bound of `self` and `rhs`.

bindgen/ir/annotations.rs

@@ -10,12 +10,14 @@ use crate::clang;
 
 /// What kind of visibility modifier should be used for a struct or field?
 #[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
+#[derive(Default)]
 pub enum FieldVisibilityKind {
     /// Fields are marked as private, i.e., struct Foo {bar: bool}
     Private,
     /// Fields are marked as crate public, i.e., struct Foo {pub(crate) bar: bool}
     PublicCrate,
     /// Fields are marked as public, i.e., struct Foo {pub bar: bool}
+    #[default]
     Public,
 }
 
@@ -44,11 +46,6 @@ impl std::fmt::Display for FieldVisibilityKind {
     }
 }
 
-impl Default for FieldVisibilityKind {
-    fn default() -> Self {
-        FieldVisibilityKind::Public
-    }
-}
 
 /// What kind of accessor should we provide for a field?
 #[derive(Copy, PartialEq, Eq, Clone, Debug)]

bindgen/ir/derive.rs

@@ -93,8 +93,10 @@ pub(crate) trait CanDeriveOrd {
 /// Initially we assume that we can derive trait for all types and then
 /// update our understanding as we learn more about each type.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Default)]
 pub enum CanDerive {
     /// Yes, we can derive automatically.
+    #[default]
     Yes,
 
     /// The only thing that stops us from automatically deriving is that
@@ -107,11 +109,6 @@ pub enum CanDerive {
     No,
 }
 
-impl Default for CanDerive {
-    fn default() -> CanDerive {
-        CanDerive::Yes
-    }
-}
 
 impl CanDerive {
     /// Take the least upper bound of `self` and `rhs`.

bindgen/ir/item.rs

@@ -1807,8 +1807,9 @@ impl Item {
             spelling: &str,
         ) -> bool {
             static ANON_TYPE_PARAM_RE: OnceLock<regex::Regex> = OnceLock::new();
-            let anon_type_param_re = ANON_TYPE_PARAM_RE.get_or_init(||
-                    regex::Regex::new(r"^type\-parameter\-\d+\-\d+$").unwrap());
+            let anon_type_param_re = ANON_TYPE_PARAM_RE.get_or_init(|| {
+                regex::Regex::new(r"^type\-parameter\-\d+\-\d+$").unwrap()
+            });
 
             if refd.kind() != clang_sys::CXCursor_TemplateTypeParameter {
                 return false;