Fix trivially_copy_pass_by_ref lint

nyurik · emilio · commit 493fba9cd9c3 · 2025-02-01T20:16:38.000Z
diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs
@@ -3188,14 +3188,14 @@ pub enum EnumVariation {
 }
 
 impl EnumVariation {
-    fn is_rust(&self) -> bool {
-        matches!(*self, EnumVariation::Rust { .. })
+    fn is_rust(self) -> bool {
+        matches!(self, EnumVariation::Rust { .. })
     }
 
     /// Both the `Const` and `ModuleConsts` variants will cause this to return
     /// true.
-    fn is_const(&self) -> bool {
-        matches!(*self, EnumVariation::Consts | EnumVariation::ModuleConsts)
+    fn is_const(self) -> bool {
+        matches!(self, EnumVariation::Consts | EnumVariation::ModuleConsts)
     }
 }
 
@@ -5701,7 +5701,7 @@ pub(crate) mod utils {
 
     pub(crate) fn fnsig_argument_type(
         ctx: &BindgenContext,
-        ty: &TypeId,
+        ty: TypeId,
     ) -> syn::Type {
         use super::ToPtr;
 
@@ -5753,7 +5753,7 @@ pub(crate) mod utils {
         let mut unnamed_arguments = 0;
         let mut args = args_iter
             .map(|(name, ty)| {
-                let arg_ty = fnsig_argument_type(ctx, ty);
+                let arg_ty = fnsig_argument_type(ctx, *ty);
 
                 let arg_name = if let Some(ref name) = *name {
                     ctx.rust_mangle(name).into_owned()
diff --git a/bindgen/ir/analysis/derive.rs b/bindgen/ir/analysis/derive.rs
@@ -451,7 +451,7 @@ impl CannotDerive<'_> {
 }
 
 impl DeriveTrait {
-    fn not_by_name(&self, ctx: &BindgenContext, item: &Item) -> bool {
+    fn not_by_name(self, ctx: &BindgenContext, item: &Item) -> bool {
         match self {
             DeriveTrait::Copy => ctx.no_copy_by_name(item),
             DeriveTrait::Debug => ctx.no_debug_by_name(item),
@@ -463,21 +463,21 @@ impl DeriveTrait {
         }
     }
 
-    fn consider_edge_comp(&self) -> EdgePredicate {
+    fn consider_edge_comp(self) -> EdgePredicate {
         match self {
             DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
             _ => |kind| matches!(kind, EdgeKind::BaseMember | EdgeKind::Field),
         }
     }
 
-    fn consider_edge_typeref(&self) -> EdgePredicate {
+    fn consider_edge_typeref(self) -> EdgePredicate {
         match self {
             DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
             _ => |kind| kind == EdgeKind::TypeReference,
         }
     }
 
-    fn consider_edge_tmpl_inst(&self) -> EdgePredicate {
+    fn consider_edge_tmpl_inst(self) -> EdgePredicate {
         match self {
             DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
             _ => |kind| {
@@ -489,31 +489,31 @@ impl DeriveTrait {
         }
     }
 
-    fn can_derive_large_array(&self, ctx: &BindgenContext) -> bool {
+    fn can_derive_large_array(self, ctx: &BindgenContext) -> bool {
         if ctx.options().rust_features().larger_arrays {
             !matches!(self, DeriveTrait::Default)
         } else {
             matches!(self, DeriveTrait::Copy)
         }
     }
 
-    fn can_derive_union(&self) -> bool {
+    fn can_derive_union(self) -> bool {
         matches!(self, DeriveTrait::Copy)
     }
 
-    fn can_derive_compound_with_destructor(&self) -> bool {
+    fn can_derive_compound_with_destructor(self) -> bool {
         !matches!(self, DeriveTrait::Copy)
     }
 
-    fn can_derive_compound_with_vtable(&self) -> bool {
+    fn can_derive_compound_with_vtable(self) -> bool {
         !matches!(self, DeriveTrait::Default)
     }
 
-    fn can_derive_compound_forward_decl(&self) -> bool {
+    fn can_derive_compound_forward_decl(self) -> bool {
         matches!(self, DeriveTrait::Copy | DeriveTrait::Debug)
     }
 
-    fn can_derive_incomplete_array(&self) -> bool {
+    fn can_derive_incomplete_array(self) -> bool {
         !matches!(
             self,
             DeriveTrait::Copy |
@@ -522,7 +522,7 @@ impl DeriveTrait {
         )
     }
 
-    fn can_derive_fnptr(&self, f: &FunctionSig) -> CanDerive {
+    fn can_derive_fnptr(self, f: &FunctionSig) -> CanDerive {
         match (self, f.function_pointers_can_derive()) {
             (DeriveTrait::Copy | DeriveTrait::Default, _) | (_, true) => {
                 trace!("    function pointer can derive {self}");
@@ -539,8 +539,8 @@ impl DeriveTrait {
         }
     }
 
-    fn can_derive_vector(&self) -> CanDerive {
-        if *self == DeriveTrait::PartialEqOrPartialOrd {
+    fn can_derive_vector(self) -> CanDerive {
+        if self == DeriveTrait::PartialEqOrPartialOrd {
             // FIXME: vectors always can derive PartialEq, but they should
             // not derive PartialOrd:
             // https://github.com/rust-lang-nursery/packed_simd/issues/48
@@ -552,8 +552,8 @@ impl DeriveTrait {
         }
     }
 
-    fn can_derive_pointer(&self) -> CanDerive {
-        if *self == DeriveTrait::Default {
+    fn can_derive_pointer(self) -> CanDerive {
+        if self == DeriveTrait::Default {
             trace!("    pointer cannot derive Default");
             CanDerive::No
         } else {
@@ -562,7 +562,7 @@ impl DeriveTrait {
         }
     }
 
-    fn can_derive_simple(&self, kind: &TypeKind) -> CanDerive {
+    fn can_derive_simple(self, kind: &TypeKind) -> CanDerive {
         match (self, kind) {
             // === Default ===
             (
diff --git a/bindgen/ir/comp.rs b/bindgen/ir/comp.rs
@@ -56,16 +56,16 @@ pub(crate) enum MethodKind {
 
 impl MethodKind {
     /// Is this a destructor method?
-    pub(crate) fn is_destructor(&self) -> bool {
+    pub(crate) fn is_destructor(self) -> bool {
         matches!(
-            *self,
+            self,
             MethodKind::Destructor | MethodKind::VirtualDestructor { .. }
         )
     }
 
     /// Is this a pure virtual method?
-    pub(crate) fn is_pure_virtual(&self) -> bool {
-        match *self {
+    pub(crate) fn is_pure_virtual(self) -> bool {
+        match self {
             MethodKind::Virtual { pure_virtual } |
             MethodKind::VirtualDestructor { pure_virtual } => pure_virtual,
             _ => false,
diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs
@@ -198,8 +198,8 @@ impl From<ItemId> for usize {
 
 impl ItemId {
     /// Get a numeric representation of this ID.
-    pub(crate) fn as_usize(&self) -> usize {
-        (*self).into()
+    pub(crate) fn as_usize(self) -> usize {
+        self.into()
     }
 }
 
diff --git a/bindgen/ir/function.rs b/bindgen/ir/function.rs
@@ -247,8 +247,8 @@ pub(crate) enum ClangAbi {
 
 impl ClangAbi {
     /// Returns whether this Abi is known or not.
-    fn is_unknown(&self) -> bool {
-        matches!(*self, ClangAbi::Unknown(..))
+    fn is_unknown(self) -> bool {
+        matches!(self, ClangAbi::Unknown(..))
     }
 }
 
diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs
@@ -103,6 +103,7 @@ impl DebugOnlyItemSet {
         DebugOnlyItemSet
     }
 
+    #[allow(clippy::trivially_copy_pass_by_ref)]
     fn contains(&self, _id: &ItemId) -> bool {
         false
     }

Original file line number	Diff line number	Diff line change
`@@ -451,7 +451,7 @@ impl CannotDerive<'_> {`
`451`	`451`	`}`
`452`	`452`
`453`	`453`	`impl DeriveTrait {`
`454`		`- fn not_by_name(&self, ctx: &BindgenContext, item: &Item) -> bool {`
	`454`	`+ fn not_by_name(self, ctx: &BindgenContext, item: &Item) -> bool {`
`455`	`455`	`match self {`
`456`	`456`	`DeriveTrait::Copy => ctx.no_copy_by_name(item),`
`457`	`457`	`DeriveTrait::Debug => ctx.no_debug_by_name(item),`
`@@ -463,21 +463,21 @@ impl DeriveTrait {`
`463`	`463`	`}`
`464`	`464`	`}`
`465`	`465`
`466`		`- fn consider_edge_comp(&self) -> EdgePredicate {`
	`466`	`+ fn consider_edge_comp(self) -> EdgePredicate {`
`467`	`467`	`match self {`
`468`	`468`	`DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,`
`469`	`469`	`_ => \|kind\| matches!(kind, EdgeKind::BaseMember \| EdgeKind::Field),`
`470`	`470`	`}`
`471`	`471`	`}`
`472`	`472`
`473`		`- fn consider_edge_typeref(&self) -> EdgePredicate {`
	`473`	`+ fn consider_edge_typeref(self) -> EdgePredicate {`
`474`	`474`	`match self {`
`475`	`475`	`DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,`
`476`	`476`	`_ => \|kind\| kind == EdgeKind::TypeReference,`
`477`	`477`	`}`
`478`	`478`	`}`
`479`	`479`
`480`		`- fn consider_edge_tmpl_inst(&self) -> EdgePredicate {`
	`480`	`+ fn consider_edge_tmpl_inst(self) -> EdgePredicate {`
`481`	`481`	`match self {`
`482`	`482`	`DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,`
`483`	`483`	`_ => \|kind\| {`
`@@ -489,31 +489,31 @@ impl DeriveTrait {`
`489`	`489`	`}`
`490`	`490`	`}`
`491`	`491`
`492`		`- fn can_derive_large_array(&self, ctx: &BindgenContext) -> bool {`
	`492`	`+ fn can_derive_large_array(self, ctx: &BindgenContext) -> bool {`
`493`	`493`	`if ctx.options().rust_features().larger_arrays {`
`494`	`494`	`!matches!(self, DeriveTrait::Default)`
`495`	`495`	`} else {`
`496`	`496`	`matches!(self, DeriveTrait::Copy)`
`497`	`497`	`}`
`498`	`498`	`}`
`499`	`499`
`500`		`- fn can_derive_union(&self) -> bool {`
	`500`	`+ fn can_derive_union(self) -> bool {`
`501`	`501`	`matches!(self, DeriveTrait::Copy)`
`502`	`502`	`}`
`503`	`503`
`504`		`- fn can_derive_compound_with_destructor(&self) -> bool {`
	`504`	`+ fn can_derive_compound_with_destructor(self) -> bool {`
`505`	`505`	`!matches!(self, DeriveTrait::Copy)`
`506`	`506`	`}`
`507`	`507`
`508`		`- fn can_derive_compound_with_vtable(&self) -> bool {`
	`508`	`+ fn can_derive_compound_with_vtable(self) -> bool {`
`509`	`509`	`!matches!(self, DeriveTrait::Default)`
`510`	`510`	`}`
`511`	`511`
`512`		`- fn can_derive_compound_forward_decl(&self) -> bool {`
	`512`	`+ fn can_derive_compound_forward_decl(self) -> bool {`
`513`	`513`	`matches!(self, DeriveTrait::Copy \| DeriveTrait::Debug)`
`514`	`514`	`}`
`515`	`515`
`516`		`- fn can_derive_incomplete_array(&self) -> bool {`
	`516`	`+ fn can_derive_incomplete_array(self) -> bool {`
`517`	`517`	`!matches!(`
`518`	`518`	`self,`
`519`	`519`	`DeriveTrait::Copy \|`
`@@ -522,7 +522,7 @@ impl DeriveTrait {`
`522`	`522`	`)`
`523`	`523`	`}`
`524`	`524`
`525`		`- fn can_derive_fnptr(&self, f: &FunctionSig) -> CanDerive {`
	`525`	`+ fn can_derive_fnptr(self, f: &FunctionSig) -> CanDerive {`
`526`	`526`	`match (self, f.function_pointers_can_derive()) {`
`527`	`527`	`(DeriveTrait::Copy \| DeriveTrait::Default, _) \| (_, true) => {`
`528`	`528`	`trace!(" function pointer can derive {self}");`
`@@ -539,8 +539,8 @@ impl DeriveTrait {`
`539`	`539`	`}`
`540`	`540`	`}`
`541`	`541`
`542`		`- fn can_derive_vector(&self) -> CanDerive {`
`543`		`- if *self == DeriveTrait::PartialEqOrPartialOrd {`
	`542`	`+ fn can_derive_vector(self) -> CanDerive {`
	`543`	`+ if self == DeriveTrait::PartialEqOrPartialOrd {`
`544`	`544`	`// FIXME: vectors always can derive PartialEq, but they should`
`545`	`545`	`// not derive PartialOrd:`
`546`	`546`	`// https://github.com/rust-lang-nursery/packed_simd/issues/48`
`@@ -552,8 +552,8 @@ impl DeriveTrait {`
`552`	`552`	`}`
`553`	`553`	`}`
`554`	`554`
`555`		`- fn can_derive_pointer(&self) -> CanDerive {`
`556`		`- if *self == DeriveTrait::Default {`
	`555`	`+ fn can_derive_pointer(self) -> CanDerive {`
	`556`	`+ if self == DeriveTrait::Default {`
`557`	`557`	`trace!(" pointer cannot derive Default");`
`558`	`558`	`CanDerive::No`
`559`	`559`	`} else {`
`@@ -562,7 +562,7 @@ impl DeriveTrait {`
`562`	`562`	`}`
`563`	`563`	`}`
`564`	`564`
`565`		`- fn can_derive_simple(&self, kind: &TypeKind) -> CanDerive {`
	`565`	`+ fn can_derive_simple(self, kind: &TypeKind) -> CanDerive {`
`566`	`566`	`match (self, kind) {`
`567`	`567`	`// === Default ===`
`568`	`568`	`(`
Original file line number	Diff line number	Diff line change
`@@ -198,8 +198,8 @@ impl From<ItemId> for usize {`
`198`	`198`
`199`	`199`	`impl ItemId {`
`200`	`200`	`/// Get a numeric representation of this ID.`
`201`		`- pub(crate) fn as_usize(&self) -> usize {`
`202`		`- (*self).into()`
	`201`	`+ pub(crate) fn as_usize(self) -> usize {`
	`202`	`+ self.into()`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
Original file line number	Diff line number	Diff line change
`@@ -247,8 +247,8 @@ pub(crate) enum ClangAbi {`
`247`	`247`
`248`	`248`	`impl ClangAbi {`
`249`	`249`	`/// Returns whether this Abi is known or not.`
`250`		`- fn is_unknown(&self) -> bool {`
`251`		`- matches!(*self, ClangAbi::Unknown(..))`
	`250`	`+ fn is_unknown(self) -> bool {`
	`251`	`+ matches!(self, ClangAbi::Unknown(..))`
`252`	`252`	`}`
`253`	`253`	`}`
`254`	`254`
Original file line number	Diff line number	Diff line change
`@@ -103,6 +103,7 @@ impl DebugOnlyItemSet {`
`103`	`103`	`DebugOnlyItemSet`
`104`	`104`	`}`
`105`	`105`
	`106`	`+ #[allow(clippy::trivially_copy_pass_by_ref)]`
`106`	`107`	`fn contains(&self, _id: &ItemId) -> bool {`
`107`	`108`	`false`
`108`	`109`	`}`