src/tools/clippy/clippy_lints/src/significant_drop_tightening.rs - toolchain/rustc - Git at Google

 use clippy_utils::{
     diagnostics::span_lint_and_then,
     get_attr,
     source::{indent_of, snippet},
 };
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::{
     self as hir,
     intravisit::{walk_expr, Visitor},
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{subst::GenericArgKind, Ty, TypeAndMut};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::Ident, Span, DUMMY_SP};

 declare_clippy_lint! {
     /// ### What it does
     ///
     /// Searches for elements marked with `#[clippy::significant_drop]` that could be early
     /// dropped but are in fact dropped at the end of their scopes. In other words, enforces the
     /// "tightening" of their possible lifetimes.
     ///
     /// ### Why is this bad?
     ///
     /// Elements marked with `#[clippy::has_significant_drop]` are generally synchronizing
     /// primitives that manage shared resources, as such, it is desired to release them as soon as
     /// possible to avoid unnecessary resource contention.
     ///
     /// ### Example
     ///
     /// ```rust,ignore
     /// fn main() {
     ///   let lock = some_sync_resource.lock();
     ///   let owned_rslt = lock.do_stuff_with_resource();
     ///   // Only `owned_rslt` is needed but `lock` is still held.
     ///   do_heavy_computation_that_takes_time(owned_rslt);
     /// }
     /// ```
     ///
     /// Use instead:
     ///
     /// ```rust,ignore
     /// fn main() {
     ///     let owned_rslt = some_sync_resource.lock().do_stuff_with_resource();
     ///     do_heavy_computation_that_takes_time(owned_rslt);
     /// }
     /// ```
     #[clippy::version = "1.67.0"]
     pub SIGNIFICANT_DROP_TIGHTENING,
     nursery,
     "Searches for elements marked with `#[clippy::has_significant_drop]` that could be early dropped but are in fact dropped at the end of their scopes"
 }

 impl_lint_pass!(SignificantDropTightening<'_> => [SIGNIFICANT_DROP_TIGHTENING]);

 #[derive(Default)]
 pub struct SignificantDropTightening<'tcx> {
     /// Auxiliary structure used to avoid having to verify the same type multiple times.
     seen_types: FxHashSet<Ty<'tcx>>,
     type_cache: FxHashMap<Ty<'tcx>, bool>,
 }

 impl<'tcx> SignificantDropTightening<'tcx> {
     /// Unifies the statements of a block with its return expression.
     fn all_block_stmts<'ret, 'rslt, 'stmts>(
         block_stmts: &'stmts [hir::Stmt<'tcx>],
         dummy_ret_stmt: Option<&'ret hir::Stmt<'tcx>>,
     ) -> impl Iterator<Item = &'rslt hir::Stmt<'tcx>>
     where
         'ret: 'rslt,
         'stmts: 'rslt,
     {
         block_stmts.iter().chain(dummy_ret_stmt)
     }

     /// Searches for at least one statement that could slow down the release of a significant drop.
     fn at_least_one_stmt_is_expensive<'stmt>(stmts: impl Iterator<Item = &'stmt hir::Stmt<'tcx>>) -> bool
     where
         'tcx: 'stmt,
     {
         for stmt in stmts {
             match stmt.kind {
                 hir::StmtKind::Expr(expr) if let hir::ExprKind::Path(_) = expr.kind => {}
                 hir::StmtKind::Local(local) if let Some(expr) = local.init
                     && let hir::ExprKind::Path(_) = expr.kind => {},
                 _ => return true
             };
         }
         false
     }

     /// Verifies if the expression is of type `drop(some_lock_path)` to assert that the temporary
     /// is already being dropped before the end of its scope.
     fn has_drop(expr: &'tcx hir::Expr<'_>, init_bind_ident: Ident) -> bool {
         if let hir::ExprKind::Call(fun, args) = expr.kind
             && let hir::ExprKind::Path(hir::QPath::Resolved(_, fun_path)) = &fun.kind
             && let [fun_ident, ..] = fun_path.segments
             && fun_ident.ident.name == rustc_span::sym::drop
             && let [first_arg, ..] = args
             && let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
             && let [first_arg_ps, .. ] = arg_path.segments
         {
             first_arg_ps.ident == init_bind_ident
         }
         else {
             false
         }
     }

     /// Tries to find types marked with `#[has_significant_drop]` of an expression `expr` that is
     /// originated from `stmt` and then performs common logic on `sdap`.
     fn modify_sdap_if_sig_drop_exists(
         &mut self,
         cx: &LateContext<'tcx>,
         expr: &'tcx hir::Expr<'_>,
         idx: usize,
         sdap: &mut SigDropAuxParams,
         stmt: &hir::Stmt<'_>,
         cb: impl Fn(&mut SigDropAuxParams),
     ) {
         let mut sig_drop_finder = SigDropFinder::new(cx, &mut self.seen_types, &mut self.type_cache);
         sig_drop_finder.visit_expr(expr);
         if sig_drop_finder.has_sig_drop {
             cb(sdap);
             if sdap.number_of_stmts > 0 {
                 sdap.last_use_stmt_idx = idx;
                 sdap.last_use_stmt_span = stmt.span;
                 if let hir::ExprKind::MethodCall(_, _, _, span) = expr.kind {
                     sdap.last_use_method_span = span;
                 }
             }
             sdap.number_of_stmts = sdap.number_of_stmts.wrapping_add(1);
         }
     }

     /// Shows generic overall messages as well as specialized messages depending on the usage.
     fn set_suggestions(cx: &LateContext<'tcx>, block_span: Span, diag: &mut Diagnostic, sdap: &SigDropAuxParams) {
         match sdap.number_of_stmts {
             0 | 1 => {},
             2 => {
                 let indent = " ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0));
                 let init_method = snippet(cx, sdap.init_method_span, "..");
                 let usage_method = snippet(cx, sdap.last_use_method_span, "..");
                 let stmt = if let Some(last_use_bind_span) = sdap.last_use_bind_span {
                     format!(
                         "\n{indent}let {} = {init_method}.{usage_method};",
                         snippet(cx, last_use_bind_span, ".."),
                     )
                 } else {
                     format!("\n{indent}{init_method}.{usage_method};")
                 };
                 diag.span_suggestion_verbose(
                     sdap.init_stmt_span,
                     "merge the temporary construction with its single usage",
                     stmt,
                     Applicability::MaybeIncorrect,
                 );
                 diag.span_suggestion(
                     sdap.last_use_stmt_span,
                     "remove separated single usage",
                     "",
                     Applicability::MaybeIncorrect,
                 );
             },
             _ => {
                 diag.span_suggestion(
                     sdap.last_use_stmt_span.shrink_to_hi(),
                     "drop the temporary after the end of its last usage",
                     format!(
                         "\n{}drop({});",
                         " ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0)),
                         sdap.init_bind_ident
                     ),
                     Applicability::MaybeIncorrect,
                 );
             },
         }
         diag.note("this might lead to unnecessary resource contention");
         diag.span_label(
             block_span,
             format!(
                 "temporary `{}` is currently being dropped at the end of its contained scope",
                 sdap.init_bind_ident
             ),
         );
     }
 }

 impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
         let dummy_ret_stmt = block.expr.map(|expr| hir::Stmt {
             hir_id: hir::HirId::INVALID,
             kind: hir::StmtKind::Expr(expr),
             span: DUMMY_SP,
         });
         let mut sdap = SigDropAuxParams::default();
         for (idx, stmt) in Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).enumerate() {
             match stmt.kind {
                 hir::StmtKind::Expr(expr) => self.modify_sdap_if_sig_drop_exists(
                     cx,
                     expr,
                     idx,
                     &mut sdap,
                     stmt,
                     |_| {}
                 ),
                 hir::StmtKind::Local(local) if let Some(expr) = local.init => self.modify_sdap_if_sig_drop_exists(
                     cx,
                     expr,
                     idx,
                     &mut sdap,
                     stmt,
                     |local_sdap| {
                         if local_sdap.number_of_stmts == 0 {
                             if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
                                 local_sdap.init_bind_ident = ident;
                             }
                             if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr.kind {
                                 local_sdap.init_method_span = local_expr.span.to(span);
                             }
                             local_sdap.init_stmt_span = stmt.span;
                         }
                         else if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
                             local_sdap.last_use_bind_span = Some(ident.span);
                         }
                     }
                 ),
                 hir::StmtKind::Semi(expr) => {
                     if Self::has_drop(expr, sdap.init_bind_ident) {
                         return;
                     }
                     self.modify_sdap_if_sig_drop_exists(cx, expr, idx, &mut sdap, stmt, |_| {});
                 },
                 _ => {}
             };
         }

         let idx = sdap.last_use_stmt_idx.wrapping_add(1);
         let stmts_after_last_use = Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).skip(idx);
         if sdap.number_of_stmts > 1 && Self::at_least_one_stmt_is_expensive(stmts_after_last_use) {
             span_lint_and_then(
                 cx,
                 SIGNIFICANT_DROP_TIGHTENING,
                 sdap.init_bind_ident.span,
                 "temporary with significant `Drop` can be early dropped",
                 |diag| {
                     Self::set_suggestions(cx, block.span, diag, &sdap);
                 },
             );
         }
     }
 }

 /// Auxiliary parameters used on each block check.
 struct SigDropAuxParams {
     /// The binding or variable that references the initial construction of the type marked with
     /// `#[has_significant_drop]`.
     init_bind_ident: Ident,
     /// Similar to `init_bind_ident` but encompasses the right-hand method call.
     init_method_span: Span,
     /// Similar to `init_bind_ident` but encompasses the whole contained statement.
     init_stmt_span: Span,

     /// The last visited binding or variable span within a block that had any referenced inner type
     /// marked with `#[has_significant_drop]`.
     last_use_bind_span: Option<Span>,
     /// Index of the last visited statement within a block that had any referenced inner type
     /// marked with `#[has_significant_drop]`.
     last_use_stmt_idx: usize,
     /// Similar to `last_use_bind_span` but encompasses the whole contained statement.
     last_use_stmt_span: Span,
     /// Similar to `last_use_bind_span` but encompasses the right-hand method call.
     last_use_method_span: Span,

     /// Total number of statements within a block that have any referenced inner type marked with
     /// `#[has_significant_drop]`.
     number_of_stmts: usize,
 }

 impl Default for SigDropAuxParams {
     fn default() -> Self {
         Self {
             init_bind_ident: Ident::empty(),
             init_method_span: DUMMY_SP,
             init_stmt_span: DUMMY_SP,
             last_use_bind_span: None,
             last_use_method_span: DUMMY_SP,
             last_use_stmt_idx: 0,
             last_use_stmt_span: DUMMY_SP,
             number_of_stmts: 0,
         }
     }
 }

 /// Checks the existence of the `#[has_significant_drop]` attribute
 struct SigDropChecker<'cx, 'sdt, 'tcx> {
     cx: &'cx LateContext<'tcx>,
     seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
     type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
 }

 impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
     pub(crate) fn new(
         cx: &'cx LateContext<'tcx>,
         seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
         type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
     ) -> Self {
         seen_types.clear();
         Self {
             cx,
             seen_types,
             type_cache,
         }
     }

     pub(crate) fn has_sig_drop_attr_uncached(&mut self, ty: Ty<'tcx>) -> bool {
         if let Some(adt) = ty.ty_adt_def() {
             let mut iter = get_attr(
                 self.cx.sess(),
                 self.cx.tcx.get_attrs_unchecked(adt.did()),
                 "has_significant_drop",
             );
             if iter.next().is_some() {
                 return true;
             }
         }
         match ty.kind() {
             rustc_middle::ty::Adt(a, b) => {
                 for f in a.all_fields() {
                     let ty = f.ty(self.cx.tcx, b);
                     if !self.has_seen_ty(ty) && self.has_sig_drop_attr(ty) {
                         return true;
                     }
                 }
                 for generic_arg in b.iter() {
                     if let GenericArgKind::Type(ty) = generic_arg.unpack() {
                         if self.has_sig_drop_attr(ty) {
                             return true;
                         }
                     }
                 }
                 false
             },
             rustc_middle::ty::Array(ty, _)
             | rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
             | rustc_middle::ty::Ref(_, ty, _)
             | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(*ty),
             _ => false,
         }
     }

     pub(crate) fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
         // The borrow checker prevents us from using something fancier like or_insert_with.
         if let Some(ty) = self.type_cache.get(&ty) {
             return *ty;
         }
         let value = self.has_sig_drop_attr_uncached(ty);
         self.type_cache.insert(ty, value);
         value
     }

     fn has_seen_ty(&mut self, ty: Ty<'tcx>) -> bool {
         !self.seen_types.insert(ty)
     }
 }

 /// Performs recursive calls to find any inner type marked with `#[has_significant_drop]`.
 struct SigDropFinder<'cx, 'sdt, 'tcx> {
     cx: &'cx LateContext<'tcx>,
     has_sig_drop: bool,
     sig_drop_checker: SigDropChecker<'cx, 'sdt, 'tcx>,
 }

 impl<'cx, 'sdt, 'tcx> SigDropFinder<'cx, 'sdt, 'tcx> {
     fn new(
         cx: &'cx LateContext<'tcx>,
         seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
         type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
     ) -> Self {
         Self {
             cx,
             has_sig_drop: false,
             sig_drop_checker: SigDropChecker::new(cx, seen_types, type_cache),
         }
     }
 }

 impl<'cx, 'sdt, 'tcx> Visitor<'tcx> for SigDropFinder<'cx, 'sdt, 'tcx> {
     fn visit_expr(&mut self, ex: &'tcx hir::Expr<'_>) {
         if self
             .sig_drop_checker
             .has_sig_drop_attr(self.cx.typeck_results().expr_ty(ex))
         {
             self.has_sig_drop = true;
             return;
         }

         match ex.kind {
             hir::ExprKind::MethodCall(_, expr, ..) => {
                 self.visit_expr(expr);
             },
             hir::ExprKind::Array(..)
             | hir::ExprKind::Assign(..)
             | hir::ExprKind::AssignOp(..)
             | hir::ExprKind::Binary(..)
             | hir::ExprKind::Box(..)
             | hir::ExprKind::Call(..)
             | hir::ExprKind::Field(..)
             | hir::ExprKind::If(..)
             | hir::ExprKind::Index(..)
             | hir::ExprKind::Match(..)
             | hir::ExprKind::Repeat(..)
             | hir::ExprKind::Ret(..)
             | hir::ExprKind::Tup(..)
             | hir::ExprKind::Unary(..)
             | hir::ExprKind::Yield(..) => {
                 walk_expr(self, ex);
             },
             _ => {},
         }
     }
 }
	use clippy_utils::{
	diagnostics::span_lint_and_then,
	get_attr,
	source::{indent_of, snippet},
	};
	use rustc_data_structures::fx::{FxHashMap, FxHashSet};
	use rustc_errors::{Applicability, Diagnostic};
	use rustc_hir::{
	self as hir,
	intravisit::{walk_expr, Visitor},
	};
	use rustc_lint::{LateContext, LateLintPass, LintContext};
	use rustc_middle::ty::{subst::GenericArgKind, Ty, TypeAndMut};
	use rustc_session::{declare_tool_lint, impl_lint_pass};
	use rustc_span::{symbol::Ident, Span, DUMMY_SP};

	declare_clippy_lint! {
	/// ### What it does
	///
	/// Searches for elements marked with `#[clippy::significant_drop]` that could be early
	/// dropped but are in fact dropped at the end of their scopes. In other words, enforces the
	/// "tightening" of their possible lifetimes.
	///
	/// ### Why is this bad?
	///
	/// Elements marked with `#[clippy::has_significant_drop]` are generally synchronizing
	/// primitives that manage shared resources, as such, it is desired to release them as soon as
	/// possible to avoid unnecessary resource contention.
	///
	/// ### Example
	///
	/// ```rust,ignore
	/// fn main() {
	/// let lock = some_sync_resource.lock();
	/// let owned_rslt = lock.do_stuff_with_resource();
	/// // Only `owned_rslt` is needed but `lock` is still held.
	/// do_heavy_computation_that_takes_time(owned_rslt);
	/// }
	/// ```
	///
	/// Use instead:
	///
	/// ```rust,ignore
	/// fn main() {
	/// let owned_rslt = some_sync_resource.lock().do_stuff_with_resource();
	/// do_heavy_computation_that_takes_time(owned_rslt);
	/// }
	/// ```
	#[clippy::version = "1.67.0"]
	pub SIGNIFICANT_DROP_TIGHTENING,
	nursery,
	"Searches for elements marked with `#[clippy::has_significant_drop]` that could be early dropped but are in fact dropped at the end of their scopes"
	}

	impl_lint_pass!(SignificantDropTightening<'_> => [SIGNIFICANT_DROP_TIGHTENING]);

	#[derive(Default)]
	pub struct SignificantDropTightening<'tcx> {
	/// Auxiliary structure used to avoid having to verify the same type multiple times.
	seen_types: FxHashSet<Ty<'tcx>>,
	type_cache: FxHashMap<Ty<'tcx>, bool>,
	}

	impl<'tcx> SignificantDropTightening<'tcx> {
	/// Unifies the statements of a block with its return expression.
	fn all_block_stmts<'ret, 'rslt, 'stmts>(
	block_stmts: &'stmts [hir::Stmt<'tcx>],
	dummy_ret_stmt: Option<&'ret hir::Stmt<'tcx>>,
	) -> impl Iterator<Item = &'rslt hir::Stmt<'tcx>>
	where
	'ret: 'rslt,
	'stmts: 'rslt,
	{
	block_stmts.iter().chain(dummy_ret_stmt)
	}

	/// Searches for at least one statement that could slow down the release of a significant drop.
	fn at_least_one_stmt_is_expensive<'stmt>(stmts: impl Iterator<Item = &'stmt hir::Stmt<'tcx>>) -> bool
	where
	'tcx: 'stmt,
	{
	for stmt in stmts {
	match stmt.kind {
	hir::StmtKind::Expr(expr) if let hir::ExprKind::Path(_) = expr.kind => {}
	hir::StmtKind::Local(local) if let Some(expr) = local.init
	&& let hir::ExprKind::Path(_) = expr.kind => {},
	_ => return true
	};
	}
	false
	}

	/// Verifies if the expression is of type `drop(some_lock_path)` to assert that the temporary
	/// is already being dropped before the end of its scope.
	fn has_drop(expr: &'tcx hir::Expr<'_>, init_bind_ident: Ident) -> bool {
	if let hir::ExprKind::Call(fun, args) = expr.kind
	&& let hir::ExprKind::Path(hir::QPath::Resolved(_, fun_path)) = &fun.kind
	&& let [fun_ident, ..] = fun_path.segments
	&& fun_ident.ident.name == rustc_span::sym::drop
	&& let [first_arg, ..] = args
	&& let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
	&& let [first_arg_ps, .. ] = arg_path.segments
	{
	first_arg_ps.ident == init_bind_ident
	}
	else {
	false
	}
	}

	/// Tries to find types marked with `#[has_significant_drop]` of an expression `expr` that is
	/// originated from `stmt` and then performs common logic on `sdap`.
	fn modify_sdap_if_sig_drop_exists(
	&mut self,
	cx: &LateContext<'tcx>,
	expr: &'tcx hir::Expr<'_>,
	idx: usize,
	sdap: &mut SigDropAuxParams,
	stmt: &hir::Stmt<'_>,
	cb: impl Fn(&mut SigDropAuxParams),
	) {
	let mut sig_drop_finder = SigDropFinder::new(cx, &mut self.seen_types, &mut self.type_cache);
	sig_drop_finder.visit_expr(expr);
	if sig_drop_finder.has_sig_drop {
	cb(sdap);
	if sdap.number_of_stmts > 0 {
	sdap.last_use_stmt_idx = idx;
	sdap.last_use_stmt_span = stmt.span;
	if let hir::ExprKind::MethodCall(_, _, _, span) = expr.kind {
	sdap.last_use_method_span = span;
	}
	}
	sdap.number_of_stmts = sdap.number_of_stmts.wrapping_add(1);
	}
	}

	/// Shows generic overall messages as well as specialized messages depending on the usage.
	fn set_suggestions(cx: &LateContext<'tcx>, block_span: Span, diag: &mut Diagnostic, sdap: &SigDropAuxParams) {
	match sdap.number_of_stmts {
	0 \| 1 => {},
	2 => {
	let indent = " ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0));
	let init_method = snippet(cx, sdap.init_method_span, "..");
	let usage_method = snippet(cx, sdap.last_use_method_span, "..");
	let stmt = if let Some(last_use_bind_span) = sdap.last_use_bind_span {
	format!(
	"\n{indent}let {} = {init_method}.{usage_method};",
	snippet(cx, last_use_bind_span, ".."),
	)
	} else {
	format!("\n{indent}{init_method}.{usage_method};")
	};
	diag.span_suggestion_verbose(
	sdap.init_stmt_span,
	"merge the temporary construction with its single usage",
	stmt,
	Applicability::MaybeIncorrect,
	);
	diag.span_suggestion(
	sdap.last_use_stmt_span,
	"remove separated single usage",
	"",
	Applicability::MaybeIncorrect,
	);
	},
	_ => {
	diag.span_suggestion(
	sdap.last_use_stmt_span.shrink_to_hi(),
	"drop the temporary after the end of its last usage",
	format!(
	"\n{}drop({});",
	" ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0)),
	sdap.init_bind_ident
	),
	Applicability::MaybeIncorrect,
	);
	},
	}
	diag.note("this might lead to unnecessary resource contention");
	diag.span_label(
	block_span,
	format!(
	"temporary `{}` is currently being dropped at the end of its contained scope",
	sdap.init_bind_ident
	),
	);
	}
	}

	impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
	fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
	let dummy_ret_stmt = block.expr.map(\|expr\| hir::Stmt {
	hir_id: hir::HirId::INVALID,
	kind: hir::StmtKind::Expr(expr),
	span: DUMMY_SP,
	});
	let mut sdap = SigDropAuxParams::default();
	for (idx, stmt) in Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).enumerate() {
	match stmt.kind {
	hir::StmtKind::Expr(expr) => self.modify_sdap_if_sig_drop_exists(
	cx,
	expr,
	idx,
	&mut sdap,
	stmt,
	\|_\| {}
	),
	hir::StmtKind::Local(local) if let Some(expr) = local.init => self.modify_sdap_if_sig_drop_exists(
	cx,
	expr,
	idx,
	&mut sdap,
	stmt,
	\|local_sdap\| {
	if local_sdap.number_of_stmts == 0 {
	if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
	local_sdap.init_bind_ident = ident;
	}
	if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr.kind {
	local_sdap.init_method_span = local_expr.span.to(span);
	}
	local_sdap.init_stmt_span = stmt.span;
	}
	else if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
	local_sdap.last_use_bind_span = Some(ident.span);
	}
	}
	),
	hir::StmtKind::Semi(expr) => {
	if Self::has_drop(expr, sdap.init_bind_ident) {
	return;
	}
	self.modify_sdap_if_sig_drop_exists(cx, expr, idx, &mut sdap, stmt, \|_\| {});
	},
	_ => {}
	};
	}

	let idx = sdap.last_use_stmt_idx.wrapping_add(1);
	let stmts_after_last_use = Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).skip(idx);
	if sdap.number_of_stmts > 1 && Self::at_least_one_stmt_is_expensive(stmts_after_last_use) {
	span_lint_and_then(
	cx,
	SIGNIFICANT_DROP_TIGHTENING,
	sdap.init_bind_ident.span,
	"temporary with significant `Drop` can be early dropped",
	\|diag\| {
	Self::set_suggestions(cx, block.span, diag, &sdap);
	},
	);
	}
	}
	}

	/// Auxiliary parameters used on each block check.
	struct SigDropAuxParams {
	/// The binding or variable that references the initial construction of the type marked with
	/// `#[has_significant_drop]`.
	init_bind_ident: Ident,
	/// Similar to `init_bind_ident` but encompasses the right-hand method call.
	init_method_span: Span,
	/// Similar to `init_bind_ident` but encompasses the whole contained statement.
	init_stmt_span: Span,

	/// The last visited binding or variable span within a block that had any referenced inner type
	/// marked with `#[has_significant_drop]`.
	last_use_bind_span: Option<Span>,
	/// Index of the last visited statement within a block that had any referenced inner type
	/// marked with `#[has_significant_drop]`.
	last_use_stmt_idx: usize,
	/// Similar to `last_use_bind_span` but encompasses the whole contained statement.
	last_use_stmt_span: Span,
	/// Similar to `last_use_bind_span` but encompasses the right-hand method call.
	last_use_method_span: Span,

	/// Total number of statements within a block that have any referenced inner type marked with
	/// `#[has_significant_drop]`.
	number_of_stmts: usize,
	}

	impl Default for SigDropAuxParams {
	fn default() -> Self {
	Self {
	init_bind_ident: Ident::empty(),
	init_method_span: DUMMY_SP,
	init_stmt_span: DUMMY_SP,
	last_use_bind_span: None,
	last_use_method_span: DUMMY_SP,
	last_use_stmt_idx: 0,
	last_use_stmt_span: DUMMY_SP,
	number_of_stmts: 0,
	}
	}
	}

	/// Checks the existence of the `#[has_significant_drop]` attribute
	struct SigDropChecker<'cx, 'sdt, 'tcx> {
	cx: &'cx LateContext<'tcx>,
	seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
	type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
	}

	impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
	pub(crate) fn new(
	cx: &'cx LateContext<'tcx>,
	seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
	type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
	) -> Self {
	seen_types.clear();
	Self {
	cx,
	seen_types,
	type_cache,
	}
	}

	pub(crate) fn has_sig_drop_attr_uncached(&mut self, ty: Ty<'tcx>) -> bool {
	if let Some(adt) = ty.ty_adt_def() {
	let mut iter = get_attr(
	self.cx.sess(),
	self.cx.tcx.get_attrs_unchecked(adt.did()),
	"has_significant_drop",
	);
	if iter.next().is_some() {
	return true;
	}
	}
	match ty.kind() {
	rustc_middle::ty::Adt(a, b) => {
	for f in a.all_fields() {
	let ty = f.ty(self.cx.tcx, b);
	if !self.has_seen_ty(ty) && self.has_sig_drop_attr(ty) {
	return true;
	}
	}
	for generic_arg in b.iter() {
	if let GenericArgKind::Type(ty) = generic_arg.unpack() {
	if self.has_sig_drop_attr(ty) {
	return true;
	}
	}
	}
	false
	},
	rustc_middle::ty::Array(ty, _)
	\| rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
	\| rustc_middle::ty::Ref(_, ty, _)
	\| rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(*ty),
	_ => false,
	}
	}

	pub(crate) fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
	// The borrow checker prevents us from using something fancier like or_insert_with.
	if let Some(ty) = self.type_cache.get(&ty) {
	return *ty;
	}
	let value = self.has_sig_drop_attr_uncached(ty);
	self.type_cache.insert(ty, value);
	value
	}

	fn has_seen_ty(&mut self, ty: Ty<'tcx>) -> bool {
	!self.seen_types.insert(ty)
	}
	}

	/// Performs recursive calls to find any inner type marked with `#[has_significant_drop]`.
	struct SigDropFinder<'cx, 'sdt, 'tcx> {
	cx: &'cx LateContext<'tcx>,
	has_sig_drop: bool,
	sig_drop_checker: SigDropChecker<'cx, 'sdt, 'tcx>,
	}

	impl<'cx, 'sdt, 'tcx> SigDropFinder<'cx, 'sdt, 'tcx> {
	fn new(
	cx: &'cx LateContext<'tcx>,
	seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
	type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
	) -> Self {
	Self {
	cx,
	has_sig_drop: false,
	sig_drop_checker: SigDropChecker::new(cx, seen_types, type_cache),
	}
	}
	}

	impl<'cx, 'sdt, 'tcx> Visitor<'tcx> for SigDropFinder<'cx, 'sdt, 'tcx> {
	fn visit_expr(&mut self, ex: &'tcx hir::Expr<'_>) {
	if self
	.sig_drop_checker
	.has_sig_drop_attr(self.cx.typeck_results().expr_ty(ex))
	{
	self.has_sig_drop = true;
	return;
	}

	match ex.kind {
	hir::ExprKind::MethodCall(_, expr, ..) => {
	self.visit_expr(expr);
	},
	hir::ExprKind::Array(..)
	\| hir::ExprKind::Assign(..)
	\| hir::ExprKind::AssignOp(..)
	\| hir::ExprKind::Binary(..)
	\| hir::ExprKind::Box(..)
	\| hir::ExprKind::Call(..)
	\| hir::ExprKind::Field(..)
	\| hir::ExprKind::If(..)
	\| hir::ExprKind::Index(..)
	\| hir::ExprKind::Match(..)
	\| hir::ExprKind::Repeat(..)
	\| hir::ExprKind::Ret(..)
	\| hir::ExprKind::Tup(..)
	\| hir::ExprKind::Unary(..)
	\| hir::ExprKind::Yield(..) => {
	walk_expr(self, ex);
	},
	_ => {},
	}
	}
	}