Auto merge of #9698 - kraktus:xc_bool, r=xFrednet

 [`fn_params_excessive_bools`] Make it possible to allow the lint at the method level

changelog: FP: [`fn_params_excessive_bools`]: `#[allow]` now works on methods

fix https://github.com/rust-lang/rust-clippy/issues/9687

Tested without committing but `#[allow]`ing now works. Also rewrote the lint to be a late lint while at it :)
r? `@xFrednet`

diff --combined clippy_lints/src/lib.rs
index a4bacb780349bd56e2015b451e322f9e87336762,e96075a2673f172275c377f60822911f3e49dec5..f847490be27ffddd9a59d1bf3916b71476638921
--- 1/clippy_lints/src/lib.rs
--- 2/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@@ -173,7 -173,6 +173,7 @@@ mod manual_async_fn
  mod manual_bits;
  mod manual_clamp;
  mod manual_instant_elapsed;
 +mod manual_is_ascii_check;
  mod manual_let_else;
  mod manual_non_exhaustive;
  mod manual_rem_euclid;
@@@ -269,7 -268,6 +269,7 @@@ mod strings
  mod strlen_on_c_strings;
  mod suspicious_operation_groupings;
  mod suspicious_trait_impl;
 +mod suspicious_xor_used_as_pow;
  mod swap;
  mod swap_ptr_to_ref;
  mod tabs_in_doc_comments;
@@@ -795,7 -793,7 +795,7 @@@ pub fn register_plugins(store: &mut rus
      store.register_early_pass(|| Box::new(single_component_path_imports::SingleComponentPathImports));
      let max_fn_params_bools = conf.max_fn_params_bools;
      let max_struct_bools = conf.max_struct_bools;
-     store.register_early_pass(move || {
+     store.register_late_pass(move |_| {
          Box::new(excessive_bools::ExcessiveBools::new(
              max_struct_bools,
              max_fn_params_bools,
@@@ -877,14 -875,13 +877,14 @@@
      store.register_late_pass(|_| Box::<only_used_in_recursion::OnlyUsedInRecursion>::default());
      let allow_dbg_in_tests = conf.allow_dbg_in_tests;
      store.register_late_pass(move |_| Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
 +    let allow_print_in_tests = conf.allow_print_in_tests;
 +    store.register_late_pass(move |_| Box::new(write::Write::new(allow_print_in_tests)));
      let cargo_ignore_publish = conf.cargo_ignore_publish;
      store.register_late_pass(move |_| {
          Box::new(cargo::Cargo {
              ignore_publish: cargo_ignore_publish,
          })
      });
 -    store.register_late_pass(|_| Box::<write::Write>::default());
      store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
      store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
      store.register_late_pass(|_| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
@@@ -919,8 -916,6 +919,8 @@@
      store.register_early_pass(|| Box::new(partial_pub_fields::PartialPubFields));
      store.register_late_pass(|_| Box::new(missing_trait_methods::MissingTraitMethods));
      store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
 +    store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
 +    store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv)));
      // add lints here, do not remove this comment, it's used in `new_lint`
  }
  

diff --combined clippy_lints/src/methods/mod.rs
index 82a2cc62d8205d00749e6efc3fb3288a0b70a501,996d4cb412344ae7e9ea01154ec3791cf6ffc0c7..5c8add5f3022612433100379cc5006297e91e434
--- 1/clippy_lints/src/methods/mod.rs
--- 2/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@@ -54,7 -54,6 +54,7 @@@ mod map_flatten
  mod map_identity;
  mod map_unwrap_or;
  mod mut_mutex_lock;
 +mod needless_collect;
  mod needless_option_as_deref;
  mod needless_option_take;
  mod no_effect_replace;
@@@ -105,11 -104,10 +105,10 @@@ use bind_instead_of_map::BindInsteadOfM
  use clippy_utils::consts::{constant, Constant};
  use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
  use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
- use clippy_utils::{contains_return, is_trait_method, iter_input_pats, meets_msrv, msrvs, return_ty};
+ use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, meets_msrv, msrvs, return_ty};
  use if_chain::if_chain;
  use rustc_hir as hir;
- use rustc_hir::def::Res;
- use rustc_hir::{Expr, ExprKind, PrimTy, QPath, TraitItem, TraitItemKind};
+ use rustc_hir::{Expr, ExprKind, TraitItem, TraitItemKind};
  use rustc_hir_analysis::hir_ty_to_ty;
  use rustc_lint::{LateContext, LateLintPass, LintContext};
  use rustc_middle::lint::in_external_macro;
@@@ -159,9 -157,9 +158,9 @@@ declare_clippy_lint! 
      /// ```
      /// Use instead:
      /// ```rust
 -    /// let hello = "hesuo worpd".replace(&['s', 'u', 'p'], "l");
 +    /// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");
      /// ```
 -    #[clippy::version = "1.64.0"]
 +    #[clippy::version = "1.65.0"]
      pub COLLAPSIBLE_STR_REPLACE,
      perf,
      "collapse consecutive calls to str::replace (2 or more) into a single call"
@@@ -1731,7 -1729,7 +1730,7 @@@ declare_clippy_lint! 
  
  declare_clippy_lint! {
      /// ### What it does
 -    /// Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).
 +    /// Checks for usage of `_.as_ref().map(Deref::deref)` or its aliases (such as String::as_str).
      ///
      /// ### Why is this bad?
      /// Readability, this can be written more concisely as
@@@ -2097,7 -2095,8 +2096,7 @@@ declare_clippy_lint! 
      /// let s = "Hello world!";
      /// let cow = Cow::Borrowed(s);
      ///
 -    /// let data = cow.into_owned();
 -    /// assert!(matches!(data, String))
 +    /// let _data: String = cow.into_owned();
      /// ```
      #[clippy::version = "1.65.0"]
      pub SUSPICIOUS_TO_OWNED,
@@@ -2428,7 -2427,7 +2427,7 @@@ declare_clippy_lint! 
      /// ### Known problems
      ///
      /// The type of the resulting iterator might become incompatible with its usage
 -    #[clippy::version = "1.64.0"]
 +    #[clippy::version = "1.65.0"]
      pub ITER_ON_SINGLE_ITEMS,
      nursery,
      "Iterator for array of length 1"
@@@ -2460,7 -2459,7 +2459,7 @@@ declare_clippy_lint! 
      /// ### Known problems
      ///
      /// The type of the resulting iterator might become incompatible with its usage
 -    #[clippy::version = "1.64.0"]
 +    #[clippy::version = "1.65.0"]
      pub ITER_ON_EMPTY_COLLECTIONS,
      nursery,
      "Iterator for empty array"
@@@ -3142,28 -3141,6 +3141,28 @@@ declare_clippy_lint! 
      "jumping to the start of stream using `seek` method"
  }
  
 +declare_clippy_lint! {
 +    /// ### What it does
 +    /// Checks for functions collecting an iterator when collect
 +    /// is not needed.
 +    ///
 +    /// ### Why is this bad?
 +    /// `collect` causes the allocation of a new data structure,
 +    /// when this allocation may not be needed.
 +    ///
 +    /// ### Example
 +    /// ```rust
 +    /// # let iterator = vec![1].into_iter();
 +    /// let len = iterator.clone().collect::<Vec<_>>().len();
 +    /// // should be
 +    /// let len = iterator.count();
 +    /// ```
 +    #[clippy::version = "1.30.0"]
 +    pub NEEDLESS_COLLECT,
 +    nursery,
 +    "collecting an iterator when collect is not needed"
 +}
 +
  pub struct Methods {
      avoid_breaking_exported_api: bool,
      msrv: Option<RustcVersion>,
@@@ -3290,17 -3267,16 +3289,17 @@@ impl_lint_pass!(Methods => 
      ITER_KV_MAP,
      SEEK_FROM_CURRENT,
      SEEK_TO_START_INSTEAD_OF_REWIND,
 +    NEEDLESS_COLLECT,
  ]);
  
  /// Extracts a method call name, args, and `Span` of the method name.
  fn method_call<'tcx>(
      recv: &'tcx hir::Expr<'tcx>,
 -) -> Option<(&'tcx str, &'tcx hir::Expr<'tcx>, &'tcx [hir::Expr<'tcx>], Span)> {
 -    if let ExprKind::MethodCall(path, receiver, args, _) = recv.kind {
 +) -> Option<(&'tcx str, &'tcx hir::Expr<'tcx>, &'tcx [hir::Expr<'tcx>], Span, Span)> {
 +    if let ExprKind::MethodCall(path, receiver, args, call_span) = recv.kind {
          if !args.iter().any(|e| e.span.from_expansion()) && !receiver.span.from_expansion() {
              let name = path.ident.name.as_str();
 -            return Some((name, receiver, args, path.ident.span));
 +            return Some((name, receiver, args, path.ident.span, call_span));
          }
      }
      None
@@@ -3486,7 -3462,7 +3485,7 @@@ impl<'tcx> LateLintPass<'tcx> for Metho
  impl Methods {
      #[allow(clippy::too_many_lines)]
      fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
 -        if let Some((name, recv, args, span)) = method_call(expr) {
 +        if let Some((name, recv, args, span, call_span)) = method_call(expr) {
              match (name, args) {
                  ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
                      zst_offset::check(cx, expr, recv);
@@@ -3505,31 -3481,28 +3504,31 @@@
                  ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                  ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
                  ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, self.msrv),
 -                ("collect", []) => match method_call(recv) {
 -                    Some((name @ ("cloned" | "copied"), recv2, [], _)) => {
 -                        iter_cloned_collect::check(cx, name, expr, recv2);
 -                    },
 -                    Some(("map", m_recv, [m_arg], _)) => {
 -                        map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
 -                    },
 -                    Some(("take", take_self_arg, [take_arg], _)) => {
 -                        if meets_msrv(self.msrv, msrvs::STR_REPEAT) {
 -                            manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
 -                        }
 -                    },
 -                    _ => {},
 +                ("collect", []) if is_trait_method(cx, expr, sym::Iterator) => {
 +                    needless_collect::check(cx, span, expr, recv, call_span);
 +                    match method_call(recv) {
 +                        Some((name @ ("cloned" | "copied"), recv2, [], _, _)) => {
 +                            iter_cloned_collect::check(cx, name, expr, recv2);
 +                        },
 +                        Some(("map", m_recv, [m_arg], _, _)) => {
 +                            map_collect_result_unit::check(cx, expr, m_recv, m_arg);
 +                        },
 +                        Some(("take", take_self_arg, [take_arg], _, _)) => {
 +                            if meets_msrv(self.msrv, msrvs::STR_REPEAT) {
 +                                manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
 +                            }
 +                        },
 +                        _ => {},
 +                    }
                  },
                  ("count", []) if is_trait_method(cx, expr, sym::Iterator) => match method_call(recv) {
 -                    Some(("cloned", recv2, [], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, true, false),
 -                    Some((name2 @ ("into_iter" | "iter" | "iter_mut"), recv2, [], _)) => {
 +                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, true, false),
 +                    Some((name2 @ ("into_iter" | "iter" | "iter_mut"), recv2, [], _, _)) => {
                          iter_count::check(cx, expr, recv2, name2);
                      },
 -                    Some(("map", _, [arg], _)) => suspicious_map::check(cx, expr, recv, arg),
 -                    Some(("filter", recv2, [arg], _)) => bytecount::check(cx, expr, recv2, arg),
 -                    Some(("bytes", recv2, [], _)) => bytes_count_to_len::check(cx, expr, recv, recv2),
 +                    Some(("map", _, [arg], _, _)) => suspicious_map::check(cx, expr, recv, arg),
 +                    Some(("filter", recv2, [arg], _, _)) => bytecount::check(cx, expr, recv2, arg),
 +                    Some(("bytes", recv2, [], _, _)) => bytes_count_to_len::check(cx, expr, recv, recv2),
                      _ => {},
                  },
                  ("drain", [arg]) => {
@@@ -3541,8 -3514,8 +3540,8 @@@
                      }
                  },
                  ("expect", [_]) => match method_call(recv) {
 -                    Some(("ok", recv, [], _)) => ok_expect::check(cx, expr, recv),
 -                    Some(("err", recv, [], err_span)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
 +                    Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
 +                    Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
                      _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
                  },
                  ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
@@@ -3562,13 -3535,13 +3561,13 @@@
                      flat_map_option::check(cx, expr, arg, span);
                  },
                  ("flatten", []) => match method_call(recv) {
 -                    Some(("map", recv, [map_arg], map_span)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
 -                    Some(("cloned", recv2, [], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, true),
 +                    Some(("map", recv, [map_arg], map_span, _)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
 +                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, true),
                      _ => {},
                  },
                  ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
                  ("for_each", [_]) => {
 -                    if let Some(("inspect", _, [_], span2)) = method_call(recv) {
 +                    if let Some(("inspect", _, [_], span2, _)) = method_call(recv) {
                          inspect_for_each::check(cx, expr, span2);
                      }
                  },
@@@ -3588,12 -3561,12 +3587,12 @@@
                      iter_on_single_or_empty_collections::check(cx, expr, name, recv);
                  },
                  ("join", [join_arg]) => {
 -                    if let Some(("collect", _, _, span)) = method_call(recv) {
 +                    if let Some(("collect", _, _, span, _)) = method_call(recv) {
                          unnecessary_join::check(cx, expr, recv, join_arg, span);
                      }
                  },
                  ("last", []) | ("skip", [_]) => {
 -                    if let Some((name2, recv2, args2, _span2)) = method_call(recv) {
 +                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
                          if let ("cloned", []) = (name2, args2) {
                              iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                          }
@@@ -3605,13 -3578,13 +3604,13 @@@
                  (name @ ("map" | "map_err"), [m_arg]) => {
                      if name == "map" {
                          map_clone::check(cx, expr, recv, m_arg, self.msrv);
 -                        if let Some((map_name @ ("iter" | "into_iter"), recv2, _, _)) = method_call(recv) {
 +                        if let Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) = method_call(recv) {
                              iter_kv_map::check(cx, map_name, expr, recv2, m_arg);
                          }
                      } else {
                          map_err_ignore::check(cx, expr, m_arg);
                      }
 -                    if let Some((name, recv2, args, span2)) = method_call(recv) {
 +                    if let Some((name, recv2, args, span2,_)) = method_call(recv) {
                          match (name, args) {
                              ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, self.msrv),
                              ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, self.msrv),
@@@ -3631,7 -3604,7 +3630,7 @@@
                      manual_ok_or::check(cx, expr, recv, def, map);
                  },
                  ("next", []) => {
 -                    if let Some((name2, recv2, args2, _)) = method_call(recv) {
 +                    if let Some((name2, recv2, args2, _, _)) = method_call(recv) {
                          match (name2, args2) {
                              ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
                              ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
@@@ -3644,10 -3617,10 +3643,10 @@@
                      }
                  },
                  ("nth", [n_arg]) => match method_call(recv) {
 -                    Some(("bytes", recv2, [], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
 -                    Some(("cloned", recv2, [], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
 -                    Some(("iter", recv2, [], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
 -                    Some(("iter_mut", recv2, [], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
 +                    Some(("bytes", recv2, [], _, _)) => bytes_nth::check(cx, expr, recv2, n_arg),
 +                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
 +                    Some(("iter", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
 +                    Some(("iter_mut", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
                      _ => iter_nth_zero::check(cx, expr, recv, n_arg),
                  },
                  ("ok_or_else", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or"),
@@@ -3712,7 -3685,7 +3711,7 @@@
                  },
                  ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
                  ("take", [_arg]) => {
 -                    if let Some((name2, recv2, args2, _span2)) = method_call(recv) {
 +                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
                          if let ("cloned", []) = (name2, args2) {
                              iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                          }
@@@ -3735,13 -3708,13 +3734,13 @@@
                  },
                  ("unwrap", []) => {
                      match method_call(recv) {
 -                        Some(("get", recv, [get_arg], _)) => {
 +                        Some(("get", recv, [get_arg], _, _)) => {
                              get_unwrap::check(cx, expr, recv, get_arg, false);
                          },
 -                        Some(("get_mut", recv, [get_arg], _)) => {
 +                        Some(("get_mut", recv, [get_arg], _, _)) => {
                              get_unwrap::check(cx, expr, recv, get_arg, true);
                          },
 -                        Some(("or", recv, [or_arg], or_span)) => {
 +                        Some(("or", recv, [or_arg], or_span, _)) => {
                              or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
                          },
                          _ => {},
@@@ -3750,19 -3723,19 +3749,19 @@@
                  },
                  ("unwrap_err", []) => unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests),
                  ("unwrap_or", [u_arg]) => match method_call(recv) {
 -                    Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), lhs, [rhs], _)) => {
 +                    Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), lhs, [rhs], _, _)) => {
                          manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                      },
 -                    Some(("map", m_recv, [m_arg], span)) => {
 +                    Some(("map", m_recv, [m_arg], span, _)) => {
                          option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
                      },
 -                    Some(("then_some", t_recv, [t_arg], _)) => {
 +                    Some(("then_some", t_recv, [t_arg], _, _)) => {
                          obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
                      },
                      _ => {},
                  },
                  ("unwrap_or_else", [u_arg]) => match method_call(recv) {
 -                    Some(("map", recv, [map_arg], _))
 +                    Some(("map", recv, [map_arg], _, _))
                          if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, self.msrv) => {},
                      _ => {
                          unwrap_or_else_default::check(cx, expr, recv, u_arg);
@@@ -3783,7 -3756,7 +3782,7 @@@
  }
  
  fn check_is_some_is_none(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, is_some: bool) {
 -    if let Some((name @ ("find" | "position" | "rposition"), f_recv, [arg], span)) = method_call(recv) {
 +    if let Some((name @ ("find" | "position" | "rposition"), f_recv, [arg], span, _)) = method_call(recv) {
          search_is_some::check(cx, expr, name, is_some, f_recv, arg, recv, span);
      }
  }
@@@ -3992,14 -3965,6 +3991,6 @@@ impl OutType 
      }
  }
  
- fn is_bool(ty: &hir::Ty<'_>) -> bool {
-     if let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
-         matches!(path.res, Res::PrimTy(PrimTy::Bool))
-     } else {
-         false
-     }
- }
- 
  fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
      expected.constness == actual.constness
          && expected.unsafety == actual.unsafety

diff --combined clippy_utils/src/lib.rs
index ac4d0b89f17e4c13e8056e165d8c9d9d40a1ee73,7ce8bbc1b7b339946ab1bd290acfcc3aa19c38ba..7458cc41ef79b893b559ac1d5c4634a8b389c243
--- 1/clippy_utils/src/lib.rs
--- 2/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@@ -66,7 -66,7 +66,7 @@@ pub mod visitors
  pub use self::attrs::*;
  pub use self::check_proc_macro::{is_from_proc_macro, is_span_if, is_span_match};
  pub use self::hir_utils::{
-     both, count_eq, eq_expr_value, hash_expr, hash_stmt, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
+     both, count_eq, eq_expr_value, hash_expr, hash_stmt, is_bool, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
  };
  
  use core::ops::ControlFlow;
@@@ -994,7 -994,7 +994,7 @@@ impl std::ops::BitOrAssign for CaptureK
  /// Note as this will walk up to parent expressions until the capture can be determined it should
  /// only be used while making a closure somewhere a value is consumed. e.g. a block, match arm, or
  /// function argument (other than a receiver).
 -pub fn capture_local_usage<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind {
 +pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind {
      fn pat_capture_kind(cx: &LateContext<'_>, pat: &Pat<'_>) -> CaptureKind {
          let mut capture = CaptureKind::Ref(Mutability::Not);
          pat.each_binding_or_first(&mut |_, id, span, _| match cx
@@@ -1780,6 -1780,10 +1780,10 @@@ pub fn has_attr(attrs: &[ast::Attribute
      attrs.iter().any(|attr| attr.has_name(symbol))
  }
  
+ pub fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+     has_attr(cx.tcx.hir().attrs(hir_id), sym::repr)
+ }
+ 
  pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
      let map = &tcx.hir();
      let mut prev_enclosing_node = None;
@@@ -1852,7 -1856,7 +1856,7 @@@ pub fn match_any_def_paths(cx: &LateCon
  }
  
  /// Checks if the given `DefId` matches the path.
 -pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
 +pub fn match_def_path(cx: &LateContext<'_>, did: DefId, syms: &[&str]) -> bool {
      // We should probably move to Symbols in Clippy as well rather than interning every time.
      let path = cx.get_def_path(did);
      syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().copied())
@@@ -1901,11 -1905,7 +1905,11 @@@ pub fn if_sequence<'tcx>(mut expr: &'tc
  
  /// Checks if the given function kind is an async function.
  pub fn is_async_fn(kind: FnKind<'_>) -> bool {
 -    matches!(kind, FnKind::ItemFn(_, _, header) if header.asyncness == IsAsync::Async)
 +    match kind {
 +        FnKind::ItemFn(_, _, header) => header.asyncness == IsAsync::Async,
 +        FnKind::Method(_, sig) => sig.header.asyncness == IsAsync::Async,
 +        FnKind::Closure => false,
 +    }
  }
  
  /// Peels away all the compiler generated code surrounding the body of an async function,