a few more lints

Author: nyurik

bindgen-tests/tests/quickchecking/src/lib.rs

@@ -6,13 +6,10 @@
 //! use quickcheck::{Arbitrary, Gen};
 //! use quickchecking::fuzzers;
 //!
-//! fn main() {
-//!     let generate_range: usize = 10; // Determines things like the length of
-//!                                     // arbitrary vectors generated.
-//!     let header = fuzzers::HeaderC::arbitrary(
-//!        &mut Gen::new(generate_range));
-//!     println!("{}", header);
-//! }
+//! let generate_range: usize = 10; // Determines things like the length of
+//!                                 // arbitrary vectors generated.
+//! let header = fuzzers::HeaderC::arbitrary(&mut Gen::new(generate_range));
+//! println!("{}", header);
 //! ```
 #![deny(missing_docs)]
 

bindgen/clang.rs

@@ -1016,7 +1016,7 @@ impl<'a> RawTokens<'a> {
     }
 }
 
-impl<'a> Drop for RawTokens<'a> {
+impl Drop for RawTokens<'_> {
     fn drop(&mut self) {
         if !self.tokens.is_null() {
             unsafe {
@@ -1090,7 +1090,7 @@ pub(crate) struct ClangTokenIterator<'a> {
     raw: slice::Iter<'a, CXToken>,
 }
 
-impl<'a> Iterator for ClangTokenIterator<'a> {
+impl Iterator for ClangTokenIterator<'_> {
     type Item = ClangToken;
 
     fn next(&mut self) -> Option<Self::Item> {

bindgen/codegen/impl_debug.rs

@@ -64,7 +64,7 @@ pub(crate) trait ImplDebug<'a> {
     ) -> Option<(String, Vec<proc_macro2::TokenStream>)>;
 }
 
-impl<'a> ImplDebug<'a> for FieldData {
+impl ImplDebug<'_> for FieldData {
     type Extra = ();
 
     fn impl_debug(
@@ -80,7 +80,7 @@ impl<'a> ImplDebug<'a> for FieldData {
     }
 }
 
-impl<'a> ImplDebug<'a> for BitfieldUnit {
+impl ImplDebug<'_> for BitfieldUnit {
     type Extra = ();
 
     fn impl_debug(

bindgen/codegen/mod.rs

@@ -372,15 +372,15 @@ impl<'a> CodegenResult<'a> {
     }
 }
 
-impl<'a> ops::Deref for CodegenResult<'a> {
+impl ops::Deref for CodegenResult<'_> {
     type Target = Vec<proc_macro2::TokenStream>;
 
     fn deref(&self) -> &Self::Target {
         &self.items
     }
 }
 
-impl<'a> ops::DerefMut for CodegenResult<'a> {
+impl ops::DerefMut for CodegenResult<'_> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.items
     }
@@ -727,7 +727,7 @@ impl CodeGenerator for Var {
                     if let Some(cstr) = cstr {
                         let cstr_ty = quote! { ::#prefix::ffi::CStr };
                         if rust_features.literal_cstr {
-                            let cstr = proc_macro2::Literal::c_string(&cstr);
+                            let cstr = proc_macro2::Literal::c_string(cstr);
                             result.push(quote! {
                                 #(#attrs)*
                                 pub const #canonical_ident: &#cstr_ty = #cstr;
@@ -1165,7 +1165,7 @@ impl<'a> Vtable<'a> {
     }
 }
 
-impl<'a> CodeGenerator for Vtable<'a> {
+impl CodeGenerator for Vtable<'_> {
     type Extra = Item;
     type Return = ();
 
@@ -1243,13 +1243,13 @@ impl<'a> CodeGenerator for Vtable<'a> {
     }
 }
 
-impl<'a> ItemCanonicalName for Vtable<'a> {
+impl ItemCanonicalName for Vtable<'_> {
     fn canonical_name(&self, ctx: &BindgenContext) -> String {
         format!("{}__bindgen_vtable", self.item_id.canonical_name(ctx))
     }
 }
 
-impl<'a> TryToRustTy for Vtable<'a> {
+impl TryToRustTy for Vtable<'_> {
     type Extra = ();
 
     fn try_to_rust_ty(
@@ -1375,7 +1375,7 @@ trait FieldCodegen<'a> {
         M: Extend<proc_macro2::TokenStream>;
 }
 
-impl<'a> FieldCodegen<'a> for Field {
+impl FieldCodegen<'_> for Field {
     type Extra = ();
 
     fn codegen<F, M>(
@@ -1453,7 +1453,7 @@ fn wrap_union_field_if_needed(
     }
 }
 
-impl<'a> FieldCodegen<'a> for FieldData {
+impl FieldCodegen<'_> for FieldData {
     type Extra = ();
 
     fn codegen<F, M>(
@@ -1713,7 +1713,7 @@ fn compute_visibility(
         })
 }
 
-impl<'a> FieldCodegen<'a> for BitfieldUnit {
+impl FieldCodegen<'_> for BitfieldUnit {
     type Extra = ();
 
     fn codegen<F, M>(

bindgen/codegen/serialize.rs

@@ -198,7 +198,7 @@ impl<'a> CSerialize<'a> for Function {
     }
 }
 
-impl<'a> CSerialize<'a> for TypeId {
+impl CSerialize<'_> for TypeId {
     type Extra = ();
 
     fn serialize<W: Write>(

bindgen/ir/analysis/derive.rs

@@ -104,7 +104,7 @@ fn consider_edge_default(kind: EdgeKind) -> bool {
     }
 }
 
-impl<'ctx> CannotDerive<'ctx> {
+impl CannotDerive<'_> {
     fn insert<Id: Into<ItemId>>(
         &mut self,
         id: Id,
@@ -217,9 +217,7 @@ impl<'ctx> CannotDerive<'ctx> {
             TypeKind::Reference(..) |
             TypeKind::ObjCInterface(..) |
             TypeKind::ObjCId |
-            TypeKind::ObjCSel => {
-                return self.derive_trait.can_derive_simple(ty.kind());
-            }
+            TypeKind::ObjCSel => self.derive_trait.can_derive_simple(ty.kind()),
             TypeKind::Pointer(inner) => {
                 let inner_type =
                     self.ctx.resolve_type(inner).canonical_type(self.ctx);

bindgen/ir/analysis/has_destructor.rs

@@ -39,7 +39,7 @@ pub(crate) struct HasDestructorAnalysis<'ctx> {
     dependencies: HashMap<ItemId, Vec<ItemId>>,
 }
 
-impl<'ctx> HasDestructorAnalysis<'ctx> {
+impl HasDestructorAnalysis<'_> {
     fn consider_edge(kind: EdgeKind) -> bool {
         // These are the only edges that can affect whether a type has a
         // destructor or not.

bindgen/ir/analysis/has_float.rs

@@ -39,7 +39,7 @@ pub(crate) struct HasFloat<'ctx> {
     dependencies: HashMap<ItemId, Vec<ItemId>>,
 }
 
-impl<'ctx> HasFloat<'ctx> {
+impl HasFloat<'_> {
     fn consider_edge(kind: EdgeKind) -> bool {
         match kind {
             EdgeKind::BaseMember |

bindgen/ir/analysis/has_type_param_in_array.rs

@@ -39,7 +39,7 @@ pub(crate) struct HasTypeParameterInArray<'ctx> {
     dependencies: HashMap<ItemId, Vec<ItemId>>,
 }
 
-impl<'ctx> HasTypeParameterInArray<'ctx> {
+impl HasTypeParameterInArray<'_> {
     fn consider_edge(kind: EdgeKind) -> bool {
         match kind {
             // These are the only edges that can affect whether a type has type parameter

bindgen/ir/analysis/has_vtable.rs

@@ -72,7 +72,7 @@ pub(crate) struct HasVtableAnalysis<'ctx> {
     dependencies: HashMap<ItemId, Vec<ItemId>>,
 }
 
-impl<'ctx> HasVtableAnalysis<'ctx> {
+impl HasVtableAnalysis<'_> {
     fn consider_edge(kind: EdgeKind) -> bool {
         // These are the only edges that can affect whether a type has a
         // vtable or not.