Clippyup

clippy_lints/src/bool_assert_comparison.rs

@@ -42,7 +42,7 @@ fn is_bool_lit(e: &Expr<'_>) -> bool {
  ) && !e.span.from_expansion()
 }
 
-fn is_impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+fn is_impl_not_trait_with_bool_out(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
  let ty = cx.typeck_results().expr_ty(e);
 
  cx.tcx

clippy_lints/src/case_sensitive_file_extension_comparisons.rs

@@ -67,7 +67,7 @@ fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &
  None
 }
 
-impl LateLintPass<'tcx> for CaseSensitiveFileExtensionComparisons {
+impl<'tcx> LateLintPass<'tcx> for CaseSensitiveFileExtensionComparisons {
  fn check_expr(&mut self, ctx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
  if let Some(span) = check_case_sensitive_file_extension_comparison(ctx, expr) {
  span_lint_and_help(

clippy_lints/src/casts/cast_ptr_alignment.rs

@@ -9,7 +9,7 @@ use rustc_span::symbol::sym;
 
 use super::CAST_PTR_ALIGNMENT;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
  if let ExprKind::Cast(cast_expr, cast_to) = expr.kind {
  if is_hir_ty_cfg_dependant(cx, cast_to) {
  return;

clippy_lints/src/casts/cast_ref_to_mut.rs

@@ -6,7 +6,7 @@ use rustc_middle::ty;
 
 use super::CAST_REF_TO_MUT;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
  if_chain! {
  if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
  if let ExprKind::Cast(e, t) = &e.kind;

clippy_lints/src/casts/char_lit_as_u8.rs

@@ -9,7 +9,7 @@ use rustc_middle::ty::{self, UintTy};
 
 use super::CHAR_LIT_AS_U8;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
  if_chain! {
  if let ExprKind::Cast(e, _) = &expr.kind;
  if let ExprKind::Lit(l) = &e.kind;

clippy_lints/src/casts/ptr_as_ptr.rs

@@ -12,7 +12,7 @@ use rustc_semver::RustcVersion;
 
 use super::PTR_AS_PTR;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: &Option<RustcVersion>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVersion>) {
  if !meets_msrv(msrv.as_ref(), &msrvs::POINTER_CAST) {
  return;
  }

clippy_lints/src/copies.rs

@@ -316,7 +316,7 @@ struct BlockEqual {
 
 /// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `None` to
 /// abort any further processing and avoid duplicate lint triggers.
-fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<BlockEqual> {
+fn scan_block_for_eq(cx: &LateContext<'_>, blocks: &[&Block<'_>]) -> Option<BlockEqual> {
  let mut start_eq = usize::MAX;
  let mut end_eq = usize::MAX;
  let mut expr_eq = true;
@@ -385,11 +385,7 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<
  })
 }
 
-fn check_for_warn_of_moved_symbol(
- cx: &LateContext<'tcx>,
- symbols: &FxHashSet<Symbol>,
- if_expr: &'tcx Expr<'_>,
-) -> bool {
+fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &FxHashSet<Symbol>, if_expr: &Expr<'_>) -> bool {
  get_enclosing_block(cx, if_expr.hir_id).map_or(false, |block| {
  let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
 
@@ -419,13 +415,13 @@ fn check_for_warn_of_moved_symbol(
 }
 
 fn emit_branches_sharing_code_lint(
- cx: &LateContext<'tcx>,
+ cx: &LateContext<'_>,
  start_stmts: usize,
  end_stmts: usize,
  lint_end: bool,
  warn_about_moved_symbol: bool,
- blocks: &[&Block<'tcx>],
- if_expr: &'tcx Expr<'_>,
+ blocks: &[&Block<'_>],
+ if_expr: &Expr<'_>,
 ) {
  if start_stmts == 0 && !lint_end {
  return;

clippy_lints/src/default.rs

@@ -77,7 +77,7 @@ pub struct Default {
 
 impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
 
-impl LateLintPass<'_> for Default {
+impl<'tcx> LateLintPass<'tcx> for Default {
  fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  if_chain! {
  if !expr.span.from_expansion();
@@ -110,7 +110,7 @@ impl LateLintPass<'_> for Default {
  }
 
  #[allow(clippy::too_many_lines)]
- fn check_block<'tcx>(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
+ fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
  // start from the `let mut _ = _::default();` and look at all the following
  // statements, see if they re-assign the fields of the binding
  let stmts_head = match block.stmts {

clippy_lints/src/default_numeric_fallback.rs

@@ -54,7 +54,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
 
-impl LateLintPass<'_> for DefaultNumericFallback {
+impl<'tcx> LateLintPass<'tcx> for DefaultNumericFallback {
  fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
  let mut visitor = NumericFallbackVisitor::new(cx);
  visitor.visit_body(body);

clippy_lints/src/dereference.rs

@@ -355,7 +355,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
  }
 }
 
-fn try_parse_ref_op(
+fn try_parse_ref_op<'tcx>(
  tcx: TyCtxt<'tcx>,
  typeck: &'tcx TypeckResults<'_>,
  expr: &'tcx Expr<'_>,
@@ -387,7 +387,7 @@ fn try_parse_ref_op(
 
 // Checks whether the type for a deref call actually changed the type, not just the mutability of
 // the reference.
-fn deref_method_same_type(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
+fn deref_method_same_type(result_ty: Ty<'_>, arg_ty: Ty<'_>) -> bool {
  match (result_ty.kind(), arg_ty.kind()) {
  (ty::Ref(_, result_ty, _), ty::Ref(_, arg_ty, _)) => TyS::same_type(result_ty, arg_ty),
 
@@ -457,7 +457,7 @@ fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId,
 }
 
 /// Adjustments are sometimes made in the parent block rather than the expression itself.
-fn find_adjustments(
+fn find_adjustments<'tcx>(
  tcx: TyCtxt<'tcx>,
  typeck: &'tcx TypeckResults<'_>,
  expr: &'tcx Expr<'_>,
@@ -499,7 +499,7 @@ fn find_adjustments(
 }
 
 #[allow(clippy::needless_pass_by_value)]
-fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
+fn report(cx: &LateContext<'_>, expr: &Expr<'_>, state: State, data: StateData) {
  match state {
  State::DerefMethod {
  ty_changed_count,
@@ -568,7 +568,7 @@ fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: Stat
 }
 
 impl Dereferencing {
- fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, local: HirId) {
+ fn check_local_usage(&mut self, cx: &LateContext<'_>, e: &Expr<'_>, local: HirId) {
  if let Some(outer_pat) = self.ref_locals.get_mut(&local) {
  if let Some(pat) = outer_pat {
  // Check for auto-deref

clippy_lints/src/entry.rs

@@ -233,7 +233,7 @@ struct ContainsExpr<'tcx> {
  key: &'tcx Expr<'tcx>,
  call_ctxt: SyntaxContext,
 }
-fn try_parse_contains(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(MapType, ContainsExpr<'tcx>)> {
+fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(MapType, ContainsExpr<'tcx>)> {
  let mut negated = false;
  let expr = peel_hir_expr_while(expr, |e| match e.kind {
  ExprKind::Unary(UnOp::Not, e) => {
@@ -280,7 +280,7 @@ struct InsertExpr<'tcx> {
  key: &'tcx Expr<'tcx>,
  value: &'tcx Expr<'tcx>,
 }
-fn try_parse_insert(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<InsertExpr<'tcx>> {
+fn try_parse_insert<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<InsertExpr<'tcx>> {
  if let ExprKind::MethodCall(_, _, [map, key, value], _) = expr.kind {
  let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
  if match_def_path(cx, id, &paths::BTREEMAP_INSERT) || match_def_path(cx, id, &paths::HASHMAP_INSERT) {
@@ -301,7 +301,7 @@ enum Edit<'tcx> {
  /// An insertion into the map.
  Insertion(Insertion<'tcx>),
 }
-impl Edit<'tcx> {
+impl<'tcx> Edit<'tcx> {
  fn as_insertion(self) -> Option<Insertion<'tcx>> {
  if let Self::Insertion(i) = self { Some(i) } else { None }
  }
@@ -532,7 +532,7 @@ struct InsertSearchResults<'tcx> {
  allow_insert_closure: bool,
  is_single_insert: bool,
 }
-impl InsertSearchResults<'tcx> {
+impl<'tcx> InsertSearchResults<'tcx> {
  fn as_single_insertion(&self) -> Option<Insertion<'tcx>> {
  self.is_single_insert.then(|| self.edits[0].as_insertion().unwrap())
  }
@@ -633,7 +633,7 @@ impl InsertSearchResults<'tcx> {
  }
 }
 
-fn find_insert_calls(
+fn find_insert_calls<'tcx>(
  cx: &LateContext<'tcx>,
  contains_expr: &ContainsExpr<'tcx>,
  expr: &'tcx Expr<'_>,

clippy_lints/src/equatable_if_let.rs

@@ -56,7 +56,7 @@ fn unary_pattern(pat: &Pat<'_>) -> bool {
  }
 }
 
-fn is_structural_partial_eq(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool {
+fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool {
  if let Some(def_id) = cx.tcx.lang_items().eq_trait() {
  implements_trait(cx, ty, def_id, &[other.into()])
  } else {

clippy_lints/src/erasing_op.rs

@@ -50,13 +50,19 @@ impl<'tcx> LateLintPass<'tcx> for ErasingOp {
  }
 }
 
-fn different_types(tck: &TypeckResults<'tcx>, input: &'tcx Expr<'_>, output: &'tcx Expr<'_>) -> bool {
+fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>) -> bool {
  let input_ty = tck.expr_ty(input).peel_refs();
  let output_ty = tck.expr_ty(output).peel_refs();
  !same_type_and_consts(input_ty, output_ty)
 }
 
-fn check(cx: &LateContext<'cx>, tck: &TypeckResults<'cx>, op: &Expr<'cx>, other: &Expr<'cx>, parent: &Expr<'cx>) {
+fn check<'tcx>(
+ cx: &LateContext<'tcx>,
+ tck: &TypeckResults<'tcx>,
+ op: &Expr<'tcx>,
+ other: &Expr<'tcx>,
+ parent: &Expr<'tcx>,
+) {
  if constant_simple(cx, tck, op) == Some(Constant::Int(0)) {
  if different_types(tck, other, parent) {
  return;

clippy_lints/src/from_over_into.rs

@@ -53,7 +53,7 @@ impl FromOverInto {
 
 impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
 
-impl LateLintPass<'_> for FromOverInto {
+impl<'tcx> LateLintPass<'tcx> for FromOverInto {
  fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
  if !meets_msrv(self.msrv.as_ref(), &msrvs::RE_REBALANCING_COHERENCE) {
  return;

clippy_lints/src/from_str_radix_10.rs

@@ -43,7 +43,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
 
-impl LateLintPass<'tcx> for FromStrRadix10 {
+impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
  fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
  if_chain! {
  if let ExprKind::Call(maybe_path, arguments) = &exp.kind;

clippy_lints/src/functions/must_use.rs

@@ -18,7 +18,7 @@ use clippy_utils::{match_def_path, must_use_attr, return_ty, trait_ref_of_method
 
 use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
 
-pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
  let attrs = cx.tcx.hir().attrs(item.hir_id());
  let attr = must_use_attr(attrs);
  if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind {
@@ -40,7 +40,7 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
  }
 }
 
-pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
  if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
  let is_public = cx.access_levels.is_exported(item.def_id);
  let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -62,7 +62,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<
  }
 }
 
-pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
  if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
  let is_public = cx.access_levels.is_exported(item.def_id);
  let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());

clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs

@@ -9,7 +9,7 @@ use clippy_utils::{iter_input_pats, path_to_local};
 
 use super::NOT_UNSAFE_PTR_ARG_DEREF;
 
-pub(super) fn check_fn(
+pub(super) fn check_fn<'tcx>(
  cx: &LateContext<'tcx>,
  kind: intravisit::FnKind<'tcx>,
  decl: &'tcx hir::FnDecl<'tcx>,
@@ -25,14 +25,14 @@ pub(super) fn check_fn(
  check_raw_ptr(cx, unsafety, decl, body, cx.tcx.hir().local_def_id(hir_id));
 }
 
-pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
  if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind {
  let body = cx.tcx.hir().body(eid);
  check_raw_ptr(cx, sig.header.unsafety, sig.decl, body, item.def_id);
  }
 }
 
-fn check_raw_ptr(
+fn check_raw_ptr<'tcx>(
  cx: &LateContext<'tcx>,
  unsafety: hir::Unsafety,
  decl: &'tcx hir::FnDecl<'tcx>,

clippy_lints/src/functions/result_unit_err.rs

@@ -13,7 +13,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 
 use super::RESULT_UNIT_ERR;
 
-pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+pub(super) fn check_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
  if let hir::ItemKind::Fn(ref sig, ref _generics, _) = item.kind {
  let is_public = cx.access_levels.is_exported(item.def_id);
  let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -23,7 +23,7 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
  }
 }
 
-pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &hir::ImplItem<'_>) {
  if let hir::ImplItemKind::Fn(ref sig, _) = item.kind {
  let is_public = cx.access_levels.is_exported(item.def_id);
  let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -33,7 +33,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<
  }
 }
 
-pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+pub(super) fn check_trait_item(cx: &LateContext<'_>, item: &hir::TraitItem<'_>) {
  if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
  let is_public = cx.access_levels.is_exported(item.def_id);
  let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());

clippy_lints/src/functions/too_many_arguments.rs

@@ -9,9 +9,9 @@ use clippy_utils::is_trait_impl_item;
 use super::TOO_MANY_ARGUMENTS;
 
 pub(super) fn check_fn(
- cx: &LateContext<'tcx>,
- kind: intravisit::FnKind<'tcx>,
- decl: &'tcx hir::FnDecl<'_>,
+ cx: &LateContext<'_>,
+ kind: intravisit::FnKind<'_>,
+ decl: &hir::FnDecl<'_>,
  span: Span,
  hir_id: hir::HirId,
  too_many_arguments_threshold: u64,
@@ -39,11 +39,7 @@ pub(super) fn check_fn(
  }
 }
 
-pub(super) fn check_trait_item(
- cx: &LateContext<'tcx>,
- item: &'tcx hir::TraitItem<'_>,
- too_many_arguments_threshold: u64,
-) {
+pub(super) fn check_trait_item(cx: &LateContext<'_>, item: &hir::TraitItem<'_>, too_many_arguments_threshold: u64) {
  if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
  // don't lint extern functions decls, it's not their fault
  if sig.header.abi == Abi::Rust {

clippy_lints/src/functions/too_many_lines.rs

@@ -11,9 +11,9 @@ use super::TOO_MANY_LINES;
 
 pub(super) fn check_fn(
  cx: &LateContext<'_>,
- kind: FnKind<'tcx>,
+ kind: FnKind<'_>,
  span: Span,
- body: &'tcx hir::Body<'_>,
+ body: &hir::Body<'_>,
  too_many_lines_threshold: u64,
 ) {
  // Closures must be contained in a parent body, which will be checked for `too_many_lines`.

clippy_lints/src/if_then_some_else_none.rs

@@ -55,7 +55,7 @@ impl IfThenSomeElseNone {
 
 impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
-impl LateLintPass<'_> for IfThenSomeElseNone {
+impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
  fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
  if !meets_msrv(self.msrv.as_ref(), &msrvs::BOOL_THEN) {
  return;

clippy_lints/src/implicit_return.rs

@@ -94,8 +94,8 @@ fn get_call_site(span: Span, ctxt: SyntaxContext) -> Option<Span> {
 }
 
 fn lint_implicit_returns(
- cx: &LateContext<'tcx>,
- expr: &'tcx Expr<'_>,
+ cx: &LateContext<'_>,
+ expr: &Expr<'_>,
  // The context of the function body.
  ctxt: SyntaxContext,
  // Whether the expression is from a macro expansion.