new suggestion format with extracted variable name

Author: dingxiangfei2009

compiler/rustc_mir_transform/messages.ftl

@@ -35,6 +35,17 @@ mir_transform_tail_expr_drop_order = relative drop order changing in Rust 2024
     .drop_location =
         temporary will be dropped on exiting the block, before the block's local variables
     .note_epilogue = most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects
+    .label_local_epilogue = {$is_dropped_first_edition_2024 ->
+        [true] up until Edition 2021 `{$name}` is dropped last but will be dropped earlier in Edition 2024
+        *[false] `{$name}` will be dropped later since Edition 2024
+    }
+
+mir_transform_tail_expr_dtor = `{$name}` invokes this custom destructor
+
+mir_transform_tail_expr_local = {$is_generated_name ->
+        [true] this calls a custom destructor and let us call it `{$name}`
+        *[false] `{$name}` calls a custom destructor
+    }
 
 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

compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs

@@ -4,21 +4,23 @@ use std::rc::Rc;
 
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::unord::UnordSet;
+use rustc_errors::Subdiagnostic;
 use rustc_hir::CRATE_HIR_ID;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_index::bit_set::ChunkedBitSet;
 use rustc_index::{IndexSlice, IndexVec};
-use rustc_macros::LintDiagnostic;
+use rustc_macros::{LintDiagnostic, Subdiagnostic};
+use rustc_middle::bug;
 use rustc_middle::mir::{
-    BasicBlock, Body, ClearCrossCrate, Local, Location, Place, StatementKind, TerminatorKind,
+    self, BasicBlock, Body, ClearCrossCrate, Local, Location, Place, StatementKind, TerminatorKind,
     dump_mir,
 };
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex};
 use rustc_mir_dataflow::{Analysis, MaybeReachable, ResultsCursor};
 use rustc_session::lint;
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 use rustc_type_ir::data_structures::IndexMap;
 use smallvec::{SmallVec, smallvec};
 use tracing::{debug, instrument};
@@ -279,6 +281,7 @@ pub(crate) fn run_lint<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId, body: &Body<
     }
 
     dump_mir(tcx, false, "lint_tail_expr_drop_order", &0 as _, body, |_, _| Ok(()));
+    let locals_with_user_names = collect_user_names(body);
     let param_env = tcx.param_env(def_id).with_reveal_all_normalized(tcx);
     let is_closure_like = tcx.is_closure_like(def_id.to_def_id());
     let move_data = MoveData::gather_moves(body, tcx, |_| true);
@@ -287,6 +290,8 @@ pub(crate) fn run_lint<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId, body: &Body<
     let mut block_drop_value_info =
         IndexVec::from_elem_n(MovePathIndexAtBlock::Unknown, body.basic_blocks.len());
     for (&block, candidates) in &bid_per_block {
+        // We will collect drops on locals on paths between BID points to their actual drop locations
+        // into `all_locals_dropped`.
         let mut all_locals_dropped = ChunkedBitSet::new_empty(move_data.move_paths.len());
         let mut drop_span = None;
         for &(_, place) in candidates.iter() {
@@ -352,16 +357,26 @@ pub(crate) fn run_lint<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId, body: &Body<
             all_locals_dropped.subtract(&to_exclude);
         }
         if all_locals_dropped.is_empty() {
+            // No drop effect is observable, so let us move on.
             continue;
         }
+        let local_names = assign_observables_names(
+            all_locals_dropped
+                .iter()
+                .map(|path_idx| move_data.move_paths[path_idx].place.local)
+                .chain(candidates.iter().map(|(_, place)| place.local)),
+            &locals_with_user_names,
+        );
 
         let mut lint_root = None;
-        let mut linted_spans = Vec::with_capacity(candidates.len());
-        let mut tys = Vec::with_capacity(candidates.len());
+        let mut local_labels = vec![];
         // We now collect the types with custom destructors.
         for &(_, place) in candidates {
             let linted_local_decl = &body.local_decls[place.local];
-            linted_spans.push(linted_local_decl.source_info.span);
+            let Some(&(ref name, is_generated_name)) = local_names.get(&place.local) else {
+                bug!("a name should have been assigned")
+            };
+            let name = name.as_str();
 
             if lint_root.is_none()
                 && let ClearCrossCrate::Set(data) =
@@ -370,62 +385,139 @@ pub(crate) fn run_lint<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId, body: &Body<
                 lint_root = Some(data.lint_root);
             }
 
-            tys.extend(extract_component_with_significant_dtor(
-                tcx,
-                param_env,
-                linted_local_decl.ty,
-            ));
+            // Collect spans of the custom destructors.
+            let destructors =
+                extract_component_with_significant_dtor(tcx, param_env, linted_local_decl.ty)
+                    .into_iter()
+                    .filter_map(|ty| ty_dtor_span(tcx, ty))
+                    .map(|span| DestructorLabel { span, name })
+                    .collect();
+            local_labels.push(LocalLabel {
+                span: linted_local_decl.source_info.span,
+                destructors,
+                name,
+                is_generated_name,
+                is_dropped_first_edition_2024: true,
+            });
         }
-        // Collect spans of the custom destructors.
-        let linted_dtors = tys.into_iter().filter_map(|ty| ty_dtor_span(tcx, ty)).collect();
 
         // Similarly, custom destructors of the observed drops.
-        let mut observer_spans = Vec::with_capacity(all_locals_dropped.count());
-        let mut observer_tys = Vec::with_capacity(all_locals_dropped.count());
         for path_idx in all_locals_dropped.iter() {
-            let move_path = &move_data.move_paths[path_idx];
-            let observer_ty = move_path.place.ty(body, tcx).ty;
+            let place = &move_data.move_paths[path_idx].place;
+            // We are not using the type of the local because the drop may be partial.
+            let observer_ty = place.ty(body, tcx).ty;
+
+            let observer_local_decl = &body.local_decls[place.local];
+            let Some(&(ref name, is_generated_name)) = local_names.get(&place.local) else {
+                bug!("a name should have been assigned")
+            };
+            let name = name.as_str();
 
-            let observer_local_decl = &body.local_decls[move_path.place.local];
-            observer_spans.push(observer_local_decl.source_info.span);
-            observer_tys.extend(extract_component_with_significant_dtor(
-                tcx,
-                param_env,
-                observer_ty,
-            ));
+            let destructors = extract_component_with_significant_dtor(tcx, param_env, observer_ty)
+                .into_iter()
+                .filter_map(|ty| ty_dtor_span(tcx, ty))
+                .map(|span| DestructorLabel { span, name })
+                .collect();
+            local_labels.push(LocalLabel {
+                span: observer_local_decl.source_info.span,
+                destructors,
+                name,
+                is_generated_name,
+                is_dropped_first_edition_2024: false,
+            });
         }
-        let observer_dtors =
-            observer_tys.into_iter().filter_map(|ty| ty_dtor_span(tcx, ty)).collect();
 
+        let span = local_labels[0].span;
         tcx.emit_node_span_lint(
             lint::builtin::TAIL_EXPR_DROP_ORDER,
             lint_root.unwrap_or(CRATE_HIR_ID),
-            linted_spans[0],
-            TailExprDropOrderLint {
-                linted_spans,
-                linted_dtors,
-                observer_spans,
-                observer_dtors,
-                drop_span,
-                _epilogue: (),
-            },
+            span,
+            TailExprDropOrderLint { local_labels, drop_span, _epilogue: () },
         );
     }
 }
 
+fn collect_user_names(body: &Body<'_>) -> IndexMap<Local, Symbol> {
+    let mut names = IndexMap::default();
+    for var_debug_info in &body.var_debug_info {
+        if let mir::VarDebugInfoContents::Place(place) = &var_debug_info.value
+            && let Some(local) = place.local_or_deref_local()
+        {
+            names.entry(local).or_insert(var_debug_info.name);
+        }
+    }
+    names
+}
+
+fn assign_observables_names(
+    locals: impl IntoIterator<Item = Local>,
+    user_names: &IndexMap<Local, Symbol>,
+) -> IndexMap<Local, (String, bool)> {
+    let mut names = IndexMap::default();
+    let mut assigned_names = FxHashSet::default();
+    let mut idx = 0u64;
+    let mut fresh_name = || {
+        idx += 1;
+        (format!("#{idx}"), true)
+    };
+    for local in locals {
+        let name = if let Some(name) = user_names.get(&local) {
+            let name = name.as_str();
+            if assigned_names.contains(name) { fresh_name() } else { (name.to_owned(), false) }
+        } else {
+            fresh_name()
+        };
+        assigned_names.insert(name.0.clone());
+        names.insert(local, name);
+    }
+    names
+}
+
 #[derive(LintDiagnostic)]
 #[diag(mir_transform_tail_expr_drop_order)]
-struct TailExprDropOrderLint {
-    #[label(mir_transform_temporaries)]
-    pub linted_spans: Vec<Span>,
-    #[note(mir_transform_note_dtors)]
-    pub linted_dtors: Vec<Span>,
-    #[label(mir_transform_observers)]
-    pub observer_spans: Vec<Span>,
-    #[note(mir_transform_note_observer_dtors)]
-    pub observer_dtors: Vec<Span>,
+struct TailExprDropOrderLint<'a> {
+    #[subdiagnostic]
+    local_labels: Vec<LocalLabel<'a>>,
     #[label(mir_transform_drop_location)]
-    pub drop_span: Option<Span>,
+    drop_span: Option<Span>,
     #[note(mir_transform_note_epilogue)]
-    pub _epilogue: (),
+    _epilogue: (),
+}
+
+struct LocalLabel<'a> {
+    span: Span,
+    name: &'a str,
+    is_generated_name: bool,
+    is_dropped_first_edition_2024: bool,
+    destructors: Vec<DestructorLabel<'a>>,
+}
+
+impl Subdiagnostic for LocalLabel<'_> {
+    fn add_to_diag_with<
+        G: rustc_errors::EmissionGuarantee,
+        F: rustc_errors::SubdiagMessageOp<G>,
+    >(
+        self,
+        diag: &mut rustc_errors::Diag<'_, G>,
+        f: &F,
+    ) {
+        diag.arg("name", self.name);
+        diag.arg("is_generated_name", self.is_generated_name);
+        diag.arg("is_dropped_first_edition_2024", self.is_dropped_first_edition_2024);
+        let msg = f(diag, crate::fluent_generated::mir_transform_tail_expr_local.into());
+        diag.span_label(self.span, msg);
+        for dtor in self.destructors {
+            dtor.add_to_diag_with(diag, f);
+        }
+        let msg = f(diag, crate::fluent_generated::mir_transform_label_local_epilogue.into());
+        diag.span_label(self.span, msg);
+    }
+}
+
+#[derive(Subdiagnostic)]
+#[note(mir_transform_tail_expr_dtor)]
+struct DestructorLabel<'a> {
+    #[primary_span]
+    span: Span,
+    name: &'a str,
 }