reduce false positives of tail-expr-drop-order from consumed values

Author: dingxiangfei2009

Cargo.lock

@@ -4090,6 +4090,7 @@ dependencies = [
  "rustc_hir",
  "rustc_index",
  "rustc_infer",
+ "rustc_lint",
  "rustc_macros",
  "rustc_middle",
  "rustc_mir_build",

compiler/rustc_borrowck/src/lib.rs

@@ -690,7 +690,7 @@ impl<'a, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'a, 'tcx, R>
             TerminatorKind::SwitchInt { discr, targets: _ } => {
                 self.consume_operand(loc, (discr, span), state);
             }
-            TerminatorKind::Drop { place, target: _, unwind: _, replace } => {
+            TerminatorKind::Drop { place, target: _, scope: _, unwind: _, replace } => {
                 debug!(
                     "visit_terminator_drop \
                      loc: {:?} term: {:?} place: {:?} span: {:?}",

compiler/rustc_borrowck/src/polonius/loan_invalidations.rs

@@ -103,7 +103,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'a, 'tcx> {
             TerminatorKind::SwitchInt { discr, targets: _ } => {
                 self.consume_operand(location, discr);
             }
-            TerminatorKind::Drop { place: drop_place, target: _, unwind: _, replace } => {
+            TerminatorKind::Drop { place: drop_place, target: _, scope: _, unwind: _, replace } => {
                 let write_kind =
                     if *replace { WriteKind::Replace } else { WriteKind::StorageDeadOrDrop };
                 self.access_place(

compiler/rustc_codegen_cranelift/src/base.rs

@@ -549,7 +549,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
             | TerminatorKind::CoroutineDrop => {
                 bug!("shouldn't exist at codegen {:?}", bb_data.terminator());
             }
-            TerminatorKind::Drop { place, target, unwind: _, replace: _ } => {
+            TerminatorKind::Drop { place, target, unwind: _, scope: _, replace: _ } => {
                 let drop_place = codegen_place(fx, *place);
                 crate::abi::codegen_drop(fx, source_info, drop_place, *target);
             }

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1322,7 +1322,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 MergingSucc::False
             }
 
-            mir::TerminatorKind::Drop { place, target, unwind, replace: _ } => self
+            mir::TerminatorKind::Drop { place, target, unwind, scope: _, replace: _ } => self
                 .codegen_drop_terminator(
                     helper,
                     bx,

compiler/rustc_const_eval/src/interpret/step.rs

@@ -528,7 +528,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 }
             }
 
-            Drop { place, target, unwind, replace: _ } => {
+            Drop { place, target, unwind, scope: _, replace: _ } => {
                 let place = self.eval_place(place)?;
                 let instance = Instance::resolve_drop_in_place(*self.tcx, place.layout.ty);
                 if let ty::InstanceKind::DropGlue(_, None) = instance.def {

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -150,6 +150,50 @@ pub trait TypeInformationCtxt<'tcx> {
     fn tcx(&self) -> TyCtxt<'tcx>;
 }
 
+impl<'tcx> TypeInformationCtxt<'tcx> for (TyCtxt<'tcx>, LocalDefId) {
+    type TypeckResults<'a> = &'tcx ty::TypeckResults<'tcx>
+    where
+        Self: 'a;
+
+    type Error = !;
+
+    fn typeck_results(&self) -> Self::TypeckResults<'_> {
+        self.0.typeck(self.1)
+    }
+
+    fn resolve_vars_if_possible<T: TypeFoldable<TyCtxt<'tcx>>>(&self, t: T) -> T {
+        t
+    }
+
+    fn try_structurally_resolve_type(&self, _span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
+        ty
+    }
+
+    fn report_error(&self, span: Span, msg: impl ToString) -> Self::Error {
+        span_bug!(span, "{}", msg.to_string())
+    }
+
+    fn error_reported_in_ty(&self, _ty: Ty<'tcx>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn tainted_by_errors(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn type_is_copy_modulo_regions(&self, ty: Ty<'tcx>) -> bool {
+        ty.is_copy_modulo_regions(self.0, self.0.param_env(self.1))
+    }
+
+    fn body_owner_def_id(&self) -> LocalDefId {
+        self.1
+    }
+
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.0
+    }
+}
+
 impl<'tcx> TypeInformationCtxt<'tcx> for &FnCtxt<'_, 'tcx> {
     type TypeckResults<'a> = Ref<'a, ty::TypeckResults<'tcx>>
     where

compiler/rustc_hir_typeck/src/lib.rs

@@ -30,6 +30,7 @@ mod fallback;
 mod fn_ctxt;
 mod gather_locals;
 mod intrinsicck;
+mod lint;
 mod method;
 mod op;
 mod pat;
@@ -506,5 +507,6 @@ fn fatally_break_rust(tcx: TyCtxt<'_>, span: Span) -> ! {
 
 pub fn provide(providers: &mut Providers) {
     method::provide(providers);
+    lint::provide(providers);
     *providers = Providers { typeck, diagnostic_only_typeck, used_trait_imports, ..*providers };
 }

compiler/rustc_hir_typeck/src/lint.rs

@@ -0,0 +1,67 @@
+use rustc_hir::def_id::DefId;
+use rustc_hir::{HirId, HirIdSet};
+use rustc_middle::hir::place::{PlaceBase, PlaceWithHirId};
+use rustc_middle::mir::FakeReadCause;
+use rustc_middle::query::Providers;
+use rustc_middle::ty::{self, TyCtxt};
+use tracing::instrument;
+
+use crate::expr_use_visitor::{Delegate, ExprUseVisitor};
+
+#[derive(Default)]
+struct ExtractConsumingNodeDelegate {
+    nodes: HirIdSet,
+}
+
+impl<'tcx> Delegate<'tcx> for ExtractConsumingNodeDelegate {
+    #[instrument(level = "debug", skip(self))]
+    fn consume(&mut self, place_with_id: &PlaceWithHirId<'tcx>, _: HirId) {
+        match place_with_id.place.base {
+            PlaceBase::Rvalue => {
+                self.nodes.insert(place_with_id.hir_id);
+            }
+            PlaceBase::Local(id) => {
+                self.nodes.insert(id);
+            }
+            PlaceBase::Upvar(upvar) => {
+                self.nodes.insert(upvar.var_path.hir_id);
+            }
+            PlaceBase::StaticItem => {}
+        }
+    }
+
+    fn borrow(
+        &mut self,
+        _place_with_id: &PlaceWithHirId<'tcx>,
+        _diag_expr_id: HirId,
+        _bk: ty::BorrowKind,
+    ) {
+        // do nothing
+    }
+
+    fn mutate(&mut self, _assignee_place: &PlaceWithHirId<'tcx>, _diag_expr_id: HirId) {
+        // do nothing
+    }
+
+    fn fake_read(
+        &mut self,
+        _place_with_id: &PlaceWithHirId<'tcx>,
+        _cause: FakeReadCause,
+        _diag_expr_id: HirId,
+    ) {
+        // do nothing
+    }
+}
+
+fn extract_tail_expr_consuming_nodes<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx HirIdSet {
+    let hir = tcx.hir();
+    let body = hir.body_owned_by(def_id.expect_local());
+    let mut delegate = ExtractConsumingNodeDelegate::default();
+    let euv = ExprUseVisitor::new((tcx, def_id.expect_local()), &mut delegate);
+    let _ = euv.walk_expr(body.value);
+    tcx.arena.alloc(delegate.nodes)
+}
+
+pub(crate) fn provide(providers: &mut Providers) {
+    providers.extract_tail_expr_consuming_nodes = extract_tail_expr_consuming_nodes;
+}

compiler/rustc_lint/messages.ftl

@@ -789,9 +789,6 @@ lint_suspicious_double_ref_clone =
 lint_suspicious_double_ref_deref =
     using `.deref()` on a double reference, which returns `{$ty}` instead of dereferencing the inner type
 
-lint_tail_expr_drop_order = these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
-    .label = these values have significant drop implementation and will observe changes in drop order under Edition 2024
-
 lint_trailing_semi_macro = trailing semicolon in macro used in expression position
     .note1 = macro invocations at the end of a block are treated as expressions
     .note2 = to ignore the value produced by the macro, add a semicolon after the invocation of `{$name}`

compiler/rustc_lint/src/lib.rs

@@ -82,7 +82,6 @@ mod redundant_semicolon;
 mod reference_casting;
 mod shadowed_into_iter;
 mod static_mut_refs;
-mod tail_expr_drop_order;
 mod traits;
 mod types;
 mod unit_bindings;
@@ -122,7 +121,6 @@ use rustc_middle::ty::TyCtxt;
 use shadowed_into_iter::ShadowedIntoIter;
 pub use shadowed_into_iter::{ARRAY_INTO_ITER, BOXED_SLICE_INTO_ITER};
 use static_mut_refs::*;
-use tail_expr_drop_order::TailExprDropOrder;
 use traits::*;
 use types::*;
 use unit_bindings::*;
@@ -246,7 +244,6 @@ late_lint_methods!(
             AsyncFnInTrait: AsyncFnInTrait,
             NonLocalDefinitions: NonLocalDefinitions::default(),
             ImplTraitOvercaptures: ImplTraitOvercaptures,
-            TailExprDropOrder: TailExprDropOrder,
             IfLetRescope: IfLetRescope::default(),
             StaticMutRefs: StaticMutRefs,
         ]

compiler/rustc_lint/src/tail_expr_drop_order.rs

@@ -99,6 +99,7 @@ declare_lint_pass! {
         SINGLE_USE_LIFETIMES,
         SOFT_UNSTABLE,
         STABLE_FEATURES,
+        TAIL_EXPR_DROP_ORDER,
         TEST_UNSTABLE_LINT,
         TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
         TRIVIAL_CASTS,
@@ -4998,3 +4999,81 @@ declare_lint! {
         reference: "issue #124535 <https://github.com/rust-lang/rust/issues/124535>",
     };
 }
+
+declare_lint! {
+    /// The `tail_expr_drop_order` lint looks for those values generated at the tail expression location, that of type
+    /// with a significant `Drop` implementation, such as locks.
+    /// In case there are also local variables of type with significant `Drop` implementation as well,
+    /// this lint warns you of a potential transposition in the drop order.
+    /// Your discretion on the new drop order introduced by Edition 2024 is required.
+    ///
+    /// ### Example
+    /// ```rust,edition2024
+    /// #![cfg_attr(not(bootstrap), feature(shorter_tail_lifetimes))] // Simplify this in bootstrap bump.
+    /// #![warn(tail_expr_drop_order)]
+    /// struct Droppy(i32);
+    /// impl Droppy {
+    ///     fn get(&self) -> i32 {
+    ///         self.0
+    ///     }
+    /// }
+    /// impl Drop for Droppy {
+    ///     fn drop(&mut self) {
+    ///         // This is a custom destructor and it induces side-effects that is observable
+    ///         // especially when the drop order at a tail expression changes.
+    ///         println!("loud drop {}", self.0);
+    ///     }
+    /// }
+    /// fn edition_2024() -> i32 {
+    ///     let another_droppy = Droppy(0);
+    ///     Droppy(1).get()
+    /// }
+    /// fn main() {
+    ///     edition_2024();
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// In tail expression of blocks or function bodies,
+    /// values of type with significant `Drop` implementation has an ill-specified drop order
+    /// before Edition 2024 so that they are dropped only after dropping local variables.
+    /// Edition 2024 introduces a new rule with drop orders for them,
+    /// so that they are dropped first before dropping local variables.
+    ///
+    /// A significant `Drop::drop` destructor here refers to an explicit, arbitrary
+    /// implementation of the `Drop` trait on the type, with exceptions including `Vec`,
+    /// `Box`, `Rc`, `BTreeMap` and `HashMap` that are marked by the compiler otherwise
+    /// so long that the generic types have no significant destructor recursively.
+    /// In other words, a type has a significant drop destructor when it has a `Drop` implementation
+    /// or its destructor invokes a significant destructor on a type.
+    /// Since we cannot completely reason about the change by just inspecting the existence of
+    /// a significant destructor, this lint remains only a suggestion and is set to `allow` by default.
+    ///
+    /// This lint only points out the issue with `Droppy`, which will be dropped before `another_droppy`
+    /// does in Edition 2024.
+    /// No fix will be proposed by this lint.
+    /// However, the most probable fix is to hoist `Droppy` into its own local variable binding.
+    /// ```rust
+    /// struct Droppy(i32);
+    /// impl Droppy {
+    ///     fn get(&self) -> i32 {
+    ///         self.0
+    ///     }
+    /// }
+    /// fn edition_2024() -> i32 {
+    ///     let value = Droppy(0);
+    ///     let another_droppy = Droppy(1);
+    ///     value.get()
+    /// }
+    /// ```
+    pub TAIL_EXPR_DROP_ORDER,
+    Allow,
+    "Detect and warn on significant change in drop order in tail expression location",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
+        reference: "issue #123739 <https://github.com/rust-lang/rust/issues/123739>",
+    };
+}

compiler/rustc_lint_defs/src/builtin.rs

@@ -114,6 +114,7 @@ macro_rules! arena_types {
             [decode] specialization_graph: rustc_middle::traits::specialization_graph::Graph,
             [] crate_inherent_impls: rustc_middle::ty::CrateInherentImpls,
             [] hir_owner_nodes: rustc_hir::OwnerNodes<'tcx>,
+            [] hir_id_set: rustc_hir::HirIdSet,
         ]);
     )
 }

compiler/rustc_middle/src/arena.rs

@@ -6,7 +6,7 @@
 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece, Mutability};
 use rustc_data_structures::packed::Pu128;
 use rustc_hir::def_id::DefId;
-use rustc_hir::CoroutineKind;
+use rustc_hir::{CoroutineKind, ItemLocalId};
 use rustc_index::IndexVec;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
 use rustc_span::def_id::LocalDefId;
@@ -704,7 +704,13 @@ pub enum TerminatorKind<'tcx> {
     /// The `replace` flag indicates whether this terminator was created as part of an assignment.
     /// This should only be used for diagnostic purposes, and does not have any operational
     /// meaning.
-    Drop { place: Place<'tcx>, target: BasicBlock, unwind: UnwindAction, replace: bool },
+    Drop {
+        place: Place<'tcx>,
+        target: BasicBlock,
+        unwind: UnwindAction,
+        scope: Option<(DefId, ItemLocalId)>,
+        replace: bool,
+    },
 
     /// Roughly speaking, evaluates the `func` operand and the arguments, and starts execution of
     /// the referred to function. The operand types must match the argument types of the function.

compiler/rustc_middle/src/mir/syntax.rs

@@ -631,7 +631,7 @@ impl<'tcx> TerminatorKind<'tcx> {
             Goto { target } => TerminatorEdges::Single(target),
 
             Assert { target, unwind, expected: _, msg: _, cond: _ }
-            | Drop { target, unwind, place: _, replace: _ }
+            | Drop { target, unwind, place: _, scope: _, replace: _ }
             | FalseUnwind { real_target: target, unwind } => match unwind {
                 UnwindAction::Cleanup(unwind) => TerminatorEdges::Double(target, unwind),
                 UnwindAction::Continue | UnwindAction::Terminate(_) | UnwindAction::Unreachable => {

compiler/rustc_middle/src/mir/terminator.rs

@@ -511,6 +511,7 @@ macro_rules! make_mir_visitor {
                         target: _,
                         unwind: _,
                         replace: _,
+                        scope: _,
                     } => {
                         self.visit_place(
                             place,

compiler/rustc_middle/src/mir/visit.rs

@@ -26,7 +26,7 @@ use rustc_hir::def_id::{
     CrateNum, DefId, DefIdMap, DefIdSet, LocalDefId, LocalDefIdMap, LocalDefIdSet, LocalModDefId,
 };
 use rustc_hir::lang_items::{LangItem, LanguageItems};
-use rustc_hir::{Crate, ItemLocalId, ItemLocalMap, TraitCandidate};
+use rustc_hir::{Crate, HirIdSet, ItemLocalId, ItemLocalMap, TraitCandidate};
 use rustc_index::IndexVec;
 use rustc_macros::rustc_queries;
 use rustc_query_system::ich::StableHashingContext;
@@ -2274,6 +2274,10 @@ rustc_queries! {
         desc { "whether the item should be made inlinable across crates" }
         separate_provide_extern
     }
+
+    query extract_tail_expr_consuming_nodes(def_id: DefId) -> &'tcx HirIdSet {
+        desc { "extract hir nodes that consumes value" }
+    }
 }
 
 rustc_query_append! { define_callbacks! }

compiler/rustc_middle/src/query/mod.rs

@@ -264,6 +264,7 @@ TrivialTypeTraversalImpls! {
 // interners).
 TrivialTypeTraversalAndLiftImpls! {
     ::rustc_hir::def_id::DefId,
+    ::rustc_hir::hir_id::ItemLocalId,
     ::rustc_hir::Safety,
     ::rustc_target::spec::abi::Abi,
     crate::ty::ClosureKind,

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -70,6 +70,7 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
                     target: self.parse_return_to(args[1])?,
                     unwind: self.parse_unwind_action(args[2])?,
                     replace: false,
+                    scope: None,
                 })
             },
             @call(mir_call, args) => {

compiler/rustc_mir_build/src/build/custom/parse/instruction.rs

@@ -721,6 +721,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             );
             if let Operand::Move(to_drop) = value_operand {
                 let success = this.cfg.start_new_block();
+                let scope = scope
+                    .and_then(|scope| scope.hir_id(this.region_scope_tree))
+                    .map(|scope| (scope.owner.to_def_id(), scope.local_id));
                 this.cfg.terminate(
                     block,
                     outer_source_info,
@@ -729,6 +732,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         target: success,
                         unwind: UnwindAction::Continue,
                         replace: false,
+                        scope,
                     },
                 );
                 this.diverge_from(block);

compiler/rustc_mir_build/src/build/expr/as_rvalue.rs

@@ -151,6 +151,9 @@ struct DropData {
 
     /// Whether this is a value Drop or a StorageDead.
     kind: DropKind,
+
+    /// Scope for which the data is obliged to drop
+    scope: Option<region::Scope>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -274,8 +277,12 @@ impl DropTree {
         // represents the block in the tree that should be jumped to once all
         // of the required drops have been performed.
         let fake_source_info = SourceInfo::outermost(DUMMY_SP);
-        let fake_data =
-            DropData { source_info: fake_source_info, local: Local::MAX, kind: DropKind::Storage };
+        let fake_data = DropData {
+            source_info: fake_source_info,
+            local: Local::MAX,
+            kind: DropKind::Storage,
+            scope: None,
+        };
         let drops = IndexVec::from_raw(vec![DropNode { data: fake_data, next: DropIdx::MAX }]);
         Self { drops, entry_points: Vec::new(), existing_drops_map: FxHashMap::default() }
     }
@@ -311,12 +318,13 @@ impl DropTree {
         &mut self,
         cfg: &mut CFG<'tcx>,
         blocks: &mut IndexVec<DropIdx, Option<BasicBlock>>,
+        scope_tree: &region::ScopeTree,
     ) {
         debug!("DropTree::build_mir(drops = {:#?})", self);
         assert_eq!(blocks.len(), self.drops.len());
 
         self.assign_blocks::<T>(cfg, blocks);
-        self.link_blocks(cfg, blocks)
+        self.link_blocks(cfg, blocks, scope_tree)
     }
 
     /// Assign blocks for all of the drops in the drop tree that need them.
@@ -390,17 +398,24 @@ impl DropTree {
         &self,
         cfg: &mut CFG<'tcx>,
         blocks: &IndexSlice<DropIdx, Option<BasicBlock>>,
+        scope_tree: &region::ScopeTree,
     ) {
         for (drop_idx, drop_node) in self.drops.iter_enumerated().rev() {
             let Some(block) = blocks[drop_idx] else { continue };
             match drop_node.data.kind {
                 DropKind::Value => {
+                    let scope = drop_node
+                        .data
+                        .scope
+                        .and_then(|scope| scope.hir_id(scope_tree))
+                        .map(|scope| (scope.owner.to_def_id(), scope.local_id));
                     let terminator = TerminatorKind::Drop {
                         target: blocks[drop_node.next].unwrap(),
                         // The caller will handle this if needed.
                         unwind: UnwindAction::Terminate(UnwindTerminateReason::InCleanup),
                         place: drop_node.data.local.into(),
                         replace: false,
+                        scope,
                     };
                     cfg.terminate(block, drop_node.data.source_info, terminator);
                 }
@@ -767,7 +782,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     let local =
                         place.as_local().unwrap_or_else(|| bug!("projection in tail call args"));
 
-                    Some(DropData { source_info, local, kind: DropKind::Value })
+                    Some(DropData { source_info, local, kind: DropKind::Value, scope: None })
                 }
                 Operand::Constant(_) => None,
             })
@@ -806,6 +821,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         unwind_drops.add_entry_point(block, unwind_entry_point);
 
                         let next = self.cfg.start_new_block();
+                        let scope = scope
+                            .region_scope
+                            .hir_id(self.region_scope_tree)
+                            .map(|scope| (scope.owner.to_def_id(), scope.local_id));
                         self.cfg.terminate(
                             block,
                             source_info,
@@ -814,6 +833,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                 target: next,
                                 unwind: UnwindAction::Continue,
                                 replace: false,
+                                scope,
                             },
                         );
                         block = next;
@@ -849,6 +869,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             unwind_to,
             is_coroutine && needs_cleanup,
             self.arg_count,
+            self.region_scope_tree,
         )
         .into_block()
     }
@@ -1097,6 +1118,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     source_info: SourceInfo { span: scope_end, scope: scope.source_scope },
                     local,
                     kind: drop_kind,
+                    scope: Some(region_scope),
                 });
 
                 return;
@@ -1291,6 +1313,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 target: assign,
                 unwind: UnwindAction::Cleanup(assign_unwind),
                 replace: true,
+                scope: None,
             },
         );
         self.diverge_from(block);
@@ -1351,6 +1374,7 @@ fn build_scope_drops<'tcx>(
     mut unwind_to: DropIdx,
     storage_dead_on_unwind: bool,
     arg_count: usize,
+    scope_tree: &region::ScopeTree,
 ) -> BlockAnd<()> {
     debug!("build_scope_drops({:?} -> {:?})", block, scope);
 
@@ -1397,6 +1421,10 @@ fn build_scope_drops<'tcx>(
                 unwind_drops.add_entry_point(block, unwind_to);
 
                 let next = cfg.start_new_block();
+                let scope = drop_data
+                    .scope
+                    .and_then(|scope| scope.hir_id(scope_tree))
+                    .map(|scope| (scope.owner.to_def_id(), scope.local_id));
                 cfg.terminate(
                     block,
                     source_info,
@@ -1405,6 +1433,7 @@ fn build_scope_drops<'tcx>(
                         target: next,
                         unwind: UnwindAction::Continue,
                         replace: false,
+                        scope,
                     },
                 );
                 block = next;
@@ -1439,7 +1468,7 @@ impl<'a, 'tcx: 'a> Builder<'a, 'tcx> {
         let mut blocks = IndexVec::from_elem(None, &drops.drops);
         blocks[ROOT_NODE] = continue_block;
 
-        drops.build_mir::<ExitScopes>(&mut self.cfg, &mut blocks);
+        drops.build_mir::<ExitScopes>(&mut self.cfg, &mut blocks, self.region_scope_tree);
         let is_coroutine = self.coroutine.is_some();
 
         // Link the exit drop tree to unwind drop tree.
@@ -1486,6 +1515,7 @@ impl<'a, 'tcx: 'a> Builder<'a, 'tcx> {
                 &mut self.scopes.unwind_drops,
                 self.fn_span,
                 &mut None,
+                self.region_scope_tree,
             );
         }
     }
@@ -1496,7 +1526,7 @@ impl<'a, 'tcx: 'a> Builder<'a, 'tcx> {
         let cfg = &mut self.cfg;
         let fn_span = self.fn_span;
         let mut blocks = IndexVec::from_elem(None, &drops.drops);
-        drops.build_mir::<CoroutineDrop>(cfg, &mut blocks);
+        drops.build_mir::<CoroutineDrop>(cfg, &mut blocks, self.region_scope_tree);
         if let Some(root_block) = blocks[ROOT_NODE] {
             cfg.terminate(
                 root_block,
@@ -1508,7 +1538,7 @@ impl<'a, 'tcx: 'a> Builder<'a, 'tcx> {
         // Build the drop tree for unwinding in the normal control flow paths.
         let resume_block = &mut None;
         let unwind_drops = &mut self.scopes.unwind_drops;
-        Self::build_unwind_tree(cfg, unwind_drops, fn_span, resume_block);
+        Self::build_unwind_tree(cfg, unwind_drops, fn_span, resume_block, self.region_scope_tree);
 
         // Build the drop tree for unwinding when dropping a suspended
         // coroutine.
@@ -1523,18 +1553,19 @@ impl<'a, 'tcx: 'a> Builder<'a, 'tcx> {
                 drops.entry_points.push((drop_node.next, blocks[drop_idx].unwrap()));
             }
         }
-        Self::build_unwind_tree(cfg, drops, fn_span, resume_block);
+        Self::build_unwind_tree(cfg, drops, fn_span, resume_block, self.region_scope_tree);
     }
 
     fn build_unwind_tree(
         cfg: &mut CFG<'tcx>,
         drops: &mut DropTree,
         fn_span: Span,
         resume_block: &mut Option<BasicBlock>,
+        scope_tree: &region::ScopeTree,
     ) {
         let mut blocks = IndexVec::from_elem(None, &drops.drops);
         blocks[ROOT_NODE] = *resume_block;
-        drops.build_mir::<Unwind>(cfg, &mut blocks);
+        drops.build_mir::<Unwind>(cfg, &mut blocks, scope_tree);
         if let (None, Some(resume)) = (*resume_block, blocks[ROOT_NODE]) {
             cfg.terminate(resume, SourceInfo::outermost(fn_span), TerminatorKind::UnwindResume);
 

compiler/rustc_mir_build/src/build/scope.rs

@@ -1,6 +1,8 @@
 use std::{fmt, iter};
 
+use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
+use rustc_hir::ItemLocalId;
 use rustc_index::Idx;
 use rustc_middle::mir::patch::MirPatch;
 use rustc_middle::mir::*;
@@ -167,6 +169,10 @@ where
     path: D::Path,
     succ: BasicBlock,
     unwind: Unwind,
+
+    /// Scope from which the drop is obliged
+    /// which is the HIR node for the "scope"
+    scope: Option<(DefId, ItemLocalId)>,
 }
 
 /// "Elaborates" a drop of `place`/`path` and patches `bb`'s terminator to execute it.
@@ -185,11 +191,12 @@ pub fn elaborate_drop<'b, 'tcx, D>(
     succ: BasicBlock,
     unwind: Unwind,
     bb: BasicBlock,
+    scope: Option<(DefId, ItemLocalId)>,
 ) where
     D: DropElaborator<'b, 'tcx>,
     'tcx: 'b,
 {
-    DropCtxt { elaborator, source_info, place, path, succ, unwind }.elaborate_drop(bb)
+    DropCtxt { elaborator, source_info, place, scope, path, succ, unwind }.elaborate_drop(bb)
 }
 
 impl<'a, 'b, 'tcx, D> DropCtxt<'a, 'b, 'tcx, D>
@@ -240,6 +247,7 @@ where
                         target: self.succ,
                         unwind: self.unwind.into_action(),
                         replace: false,
+                        scope: self.scope,
                     },
                 );
             }
@@ -302,6 +310,7 @@ where
                 place,
                 succ,
                 unwind,
+                scope: self.scope,
             }
             .elaborated_drop_block()
         } else {
@@ -316,6 +325,7 @@ where
                 // Using `self.path` here to condition the drop on
                 // our own drop flag.
                 path: self.path,
+                scope: self.scope,
             }
             .complete_drop(succ, unwind)
         }
@@ -739,6 +749,7 @@ where
                 target: loop_block,
                 unwind: unwind.into_action(),
                 replace: false,
+                scope: self.scope,
             },
         );
 
@@ -920,6 +931,7 @@ where
             target,
             unwind: unwind.into_action(),
             replace: false,
+            scope: self.scope,
         };
         self.new_block(unwind, block)
     }

compiler/rustc_mir_dataflow/src/elaborate_drops.rs

@@ -368,7 +368,8 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
     ) -> TerminatorEdges<'mir, 'tcx> {
         let mut edges = terminator.edges();
         if self.skip_unreachable_unwind
-            && let mir::TerminatorKind::Drop { target, unwind, place, replace: _ } = terminator.kind
+            && let mir::TerminatorKind::Drop { target, unwind, place, scope: _, replace: _ } =
+                terminator.kind
             && matches!(unwind, mir::UnwindAction::Cleanup(_))
             && self.is_unwind_dead(place, state)
         {

compiler/rustc_mir_dataflow/src/impls/initialized.rs

@@ -17,6 +17,7 @@ rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
 rustc_infer = { path = "../rustc_infer" }
+rustc_lint = { path = "../rustc_lint" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_mir_build = { path = "../rustc_mir_build" }

compiler/rustc_mir_transform/Cargo.toml

@@ -23,6 +23,9 @@ mir_transform_must_not_suspend = {$pre}`{$def_path}`{$post} held across a suspen
     .help = consider using a block (`{"{ ... }"}`) to shrink the value's scope, ending before the suspend point
 mir_transform_operation_will_panic = this operation will panic at runtime
 
+mir_transform_tail_expr_drop_order = this value of type `{$ty}` has significant drop implementation that will have a different drop order from that of Edition 2021
+    .label = these local bindings with significant drop implementation may observe changes in drop order under Edition 2024
+
 mir_transform_unaligned_packed_ref = reference to packed field is unaligned
     .note = packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
     .note_ub = creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)

compiler/rustc_mir_transform/messages.ftl

@@ -79,7 +79,8 @@ fn add_move_for_packed_drop<'tcx>(
     is_cleanup: bool,
 ) {
     debug!("add_move_for_packed_drop({:?} @ {:?})", terminator, loc);
-    let TerminatorKind::Drop { ref place, target, unwind, replace } = terminator.kind else {
+    let TerminatorKind::Drop { ref place, target, unwind, scope: _, replace } = terminator.kind
+    else {
         unreachable!();
     };
 
@@ -102,6 +103,7 @@ fn add_move_for_packed_drop<'tcx>(
             target: storage_dead_block,
             unwind,
             replace,
+            scope: None,
         },
     );
 }

compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs

@@ -1086,15 +1086,15 @@ fn elaborate_coroutine_drops<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
     let mut elaborator = DropShimElaborator { body, patch: MirPatch::new(body), tcx, param_env };
 
     for (block, block_data) in body.basic_blocks.iter_enumerated() {
-        let (target, unwind, source_info) = match block_data.terminator() {
+        let (target, unwind, source_info, &scope) = match block_data.terminator() {
             Terminator {
                 source_info,
-                kind: TerminatorKind::Drop { place, target, unwind, replace: _ },
+                kind: TerminatorKind::Drop { place, target, unwind, scope, replace: _ },
             } => {
                 if let Some(local) = place.as_local()
                     && local == SELF_ARG
                 {
-                    (target, unwind, source_info)
+                    (target, unwind, source_info, scope)
                 } else {
                     continue;
                 }
@@ -1119,6 +1119,7 @@ fn elaborate_coroutine_drops<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             *target,
             unwind,
             block,
+            scope,
         );
     }
     elaborator.patch.apply(body);
@@ -1377,6 +1378,7 @@ fn insert_clean_drop(body: &mut Body<'_>) -> BasicBlock {
         target: return_block,
         unwind: UnwindAction::Continue,
         replace: false,
+        scope: None,
     };
     let source_info = SourceInfo::outermost(body.span);
 

compiler/rustc_mir_transform/src/coroutine.rs

@@ -330,7 +330,8 @@ impl<'a, 'tcx> ElaborateDropsCtxt<'a, 'tcx> {
         // This function should mirror what `collect_drop_flags` does.
         for (bb, data) in self.body.basic_blocks.iter_enumerated() {
             let terminator = data.terminator();
-            let TerminatorKind::Drop { place, target, unwind, replace } = terminator.kind else {
+            let TerminatorKind::Drop { place, target, unwind, scope, replace } = terminator.kind
+            else {
                 continue;
             };
 
@@ -366,7 +367,16 @@ impl<'a, 'tcx> ElaborateDropsCtxt<'a, 'tcx> {
                         }
                     };
                     self.init_data.seek_before(self.body.terminator_loc(bb));
-                    elaborate_drop(self, terminator.source_info, place, path, target, unwind, bb)
+                    elaborate_drop(
+                        self,
+                        terminator.source_info,
+                        place,
+                        path,
+                        target,
+                        unwind,
+                        bb,
+                        scope,
+                    )
                 }
                 LookupResult::Parent(None) => {}
                 LookupResult::Parent(Some(_)) => {

compiler/rustc_mir_transform/src/elaborate_drops.rs

@@ -535,7 +535,9 @@ impl<'tcx> Inliner<'tcx> {
             checker.visit_basic_block_data(bb, blk);
 
             let term = blk.terminator();
-            if let TerminatorKind::Drop { ref place, target, unwind, replace: _ } = term.kind {
+            if let TerminatorKind::Drop { ref place, target, unwind, scope: _, replace: _ } =
+                term.kind
+            {
                 work_list.push(target);
 
                 // If the place doesn't actually need dropping, treat it like a regular goto.

compiler/rustc_mir_transform/src/inline.rs

@@ -102,6 +102,7 @@ mod sanity_check;
 mod shim;
 mod ssa;
 // This pass is public to allow external drivers to perform MIR cleanup
+mod lint_tail_expr_drop_order;
 pub mod simplify;
 mod simplify_branches;
 mod simplify_comparison_integral;
@@ -355,6 +356,7 @@ fn mir_promoted(
         &[&promote_pass, &simplify::SimplifyCfg::PromoteConsts, &coverage::InstrumentCoverage],
         Some(MirPhase::Analysis(AnalysisPhase::Initial)),
     );
+    lint_tail_expr_drop_order::run_lint(tcx, def, &body);
 
     let promoted = promote_pass.promoted_fragments.into_inner();
     (tcx.alloc_steal_mir(body), tcx.alloc_steal_promoted(promoted))

compiler/rustc_mir_transform/src/lib.rs

@@ -288,6 +288,7 @@ fn build_drop_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, ty: Option<Ty<'tcx>>)
                 return_block,
                 elaborate_drops::Unwind::To(resume_block),
                 START_BLOCK,
+                None,
             );
             elaborator.patch
         };
@@ -616,6 +617,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
                     target: unwind,
                     unwind: UnwindAction::Terminate(UnwindTerminateReason::InCleanup),
                     replace: false,
+                    scope: None,
                 },
                 /* is_cleanup */ true,
             );
@@ -878,6 +880,7 @@ fn build_call_shim<'tcx>(
                 target: BasicBlock::new(2),
                 unwind: UnwindAction::Continue,
                 replace: false,
+                scope: None,
             },
             false,
         );
@@ -894,6 +897,7 @@ fn build_call_shim<'tcx>(
                 target: BasicBlock::new(4),
                 unwind: UnwindAction::Terminate(UnwindTerminateReason::InCleanup),
                 replace: false,
+                scope: None,
             },
             /* is_cleanup */ true,
         );

compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs

@@ -429,6 +429,7 @@ impl<'tcx> AsyncDestructorCtorShimBuilder<'tcx> {
                                         UnwindTerminateReason::InCleanup,
                                     ),
                                     replace: false,
+                                    scope: None,
                                 }
                             } else {
                                 TerminatorKind::Goto { target: *top_cleanup_bb }

compiler/rustc_mir_transform/src/shim.rs

@@ -621,7 +621,7 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> {
             mir::TerminatorKind::UnwindTerminate(_) => TerminatorKind::Abort,
             mir::TerminatorKind::Return => TerminatorKind::Return,
             mir::TerminatorKind::Unreachable => TerminatorKind::Unreachable,
-            mir::TerminatorKind::Drop { place, target, unwind, replace: _ } => {
+            mir::TerminatorKind::Drop { place, target, unwind, scope: _, replace: _ } => {
                 TerminatorKind::Drop {
                     place: place.stable(tables),
                     target: target.as_usize(),

compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs

@@ -1,6 +1,3 @@
-//@ compile-flags: -Z unstable-options
-//@ edition: 2024
-
 // Edition 2024 lint for change in drop order at tail expression
 // This lint is to capture potential change in program semantics
 // due to implementation of RFC 3606 <https://github.com/rust-lang/rfcs/pull/3606>
@@ -27,14 +24,32 @@ fn should_lint() -> i32 {
     let x = LoudDropper;
     // Should lint
     x.get() + LoudDropper.get()
-    //~^ ERROR: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+    //~^ ERROR: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
     //~| WARN: this changes meaning in Rust 2024
 }
 
 fn should_lint_closure() -> impl FnOnce() -> i32 {
     let x = LoudDropper;
-    move || x.get() + LoudDropper.get()
-    //~^ ERROR: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+    move || {
+        x.get() + LoudDropper.get()
+        //~^ ERROR: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+        //~| WARN: this changes meaning in Rust 2024
+    }
+}
+
+fn should_lint_in_nested_items() {
+    fn should_lint_me() -> i32 {
+        let x = LoudDropper;
+        // Should lint
+        x.get() + LoudDropper.get()
+        //~^ ERROR: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+        //~| WARN: this changes meaning in Rust 2024
+    }
+}
+
+fn should_lint_params(x: LoudDropper) -> i32 {
+    x.get() + LoudDropper.get()
+    //~^ ERROR: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
     //~| WARN: this changes meaning in Rust 2024
 }
 
@@ -44,10 +59,11 @@ fn should_not_lint() -> i32 {
     x.get()
 }
 
-fn should_not_lint_in_nested_block() -> i32 {
+fn should_lint_in_nested_block() -> i32 {
     let x = LoudDropper;
-    // Should not lint because Edition 2021 drops temporaries in blocks earlier already
     { LoudDropper.get() }
+    //~^ ERROR: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+    //~| WARN: this changes meaning in Rust 2024
 }
 
 fn should_not_lint_in_match_arm() -> i32 {
@@ -58,14 +74,28 @@ fn should_not_lint_in_match_arm() -> i32 {
     }
 }
 
-fn should_lint_in_nested_items() {
-    fn should_lint_me() -> i32 {
-        let x = LoudDropper;
-        // Should lint
-        x.get() + LoudDropper.get()
-        //~^ ERROR: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
-        //~| WARN: this changes meaning in Rust 2024
-    }
+fn should_not_lint_when_consumed() -> (LoudDropper, i32) {
+    let x = LoudDropper;
+    // Should not lint
+    (LoudDropper, x.get())
+}
+
+struct MyAdt {
+    a: LoudDropper,
+    b: LoudDropper,
+}
+
+fn should_not_lint_when_consumed_in_ctor() -> MyAdt {
+    let a = LoudDropper;
+    // Should not lint
+    MyAdt { a, b: LoudDropper }
+}
+
+fn should_not_lint_when_moved() -> i32 {
+    let x = LoudDropper;
+    drop(x);
+    // Should not lint
+    LoudDropper.get()
 }
 
 fn main() {}

compiler/rustc_smir/src/rustc_smir/convert/mir.rs

@@ -1,42 +1,69 @@
-error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
-  --> $DIR/lint-tail-expr-drop-order.rs:29:15
+error: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:34:19
    |
-LL |     let x = LoudDropper;
-   |         - these values have significant drop implementation and will observe changes in drop order under Edition 2024
-LL |     // Should lint
-LL |     x.get() + LoudDropper.get()
-   |               ^^^^^^^^^^^
+LL |       let x = LoudDropper;
+   |           - these local bindings with significant drop implementation may observe changes in drop order under Edition 2024
+LL | /     move || {
+LL | |         x.get() + LoudDropper.get()
+   | |                   ^^^^^^^^^^^
+LL | |
+LL | |
+LL | |     }
+   | |_____- these local bindings with significant drop implementation may observe changes in drop order under Edition 2024
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
 note: the lint level is defined here
-  --> $DIR/lint-tail-expr-drop-order.rs:8:9
+  --> $DIR/lint-tail-expr-drop-order.rs:5:9
    |
 LL | #![deny(tail_expr_drop_order)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
-  --> $DIR/lint-tail-expr-drop-order.rs:36:23
+error: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:26:15
    |
 LL |     let x = LoudDropper;
-   |         - these values have significant drop implementation and will observe changes in drop order under Edition 2024
-LL |     move || x.get() + LoudDropper.get()
-   |                       ^^^^^^^^^^^
+   |         - these local bindings with significant drop implementation may observe changes in drop order under Edition 2024
+LL |     // Should lint
+LL |     x.get() + LoudDropper.get()
+   |               ^^^^^^^^^^^
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
 
-error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
-  --> $DIR/lint-tail-expr-drop-order.rs:65:19
+error: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:44:19
    |
 LL |         let x = LoudDropper;
-   |             - these values have significant drop implementation and will observe changes in drop order under Edition 2024
+   |             - these local bindings with significant drop implementation may observe changes in drop order under Edition 2024
 LL |         // Should lint
 LL |         x.get() + LoudDropper.get()
    |                   ^^^^^^^^^^^
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
 
-error: aborting due to 3 previous errors
+error: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:51:15
+   |
+LL | fn should_lint_params(x: LoudDropper) -> i32 {
+   |                       - these local bindings with significant drop implementation may observe changes in drop order under Edition 2024
+LL |     x.get() + LoudDropper.get()
+   |               ^^^^^^^^^^^
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
+
+error: this value of type `LoudDropper` has significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:64:7
+   |
+LL |     let x = LoudDropper;
+   |         - these local bindings with significant drop implementation may observe changes in drop order under Edition 2024
+LL |     { LoudDropper.get() }
+   |       ^^^^^^^^^^^
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
+
+error: aborting due to 5 previous errors