Auto merge of #147056 - dianne:fcw-super-let-init-borrow-shortening, r=jackh726

[beta-1.91] Warn on future errors from temporary lifetimes shortening in Rust 1.92

Pursuant to [discussion on Zulip](https://rust-lang.zulipchat.com/#narrow/channel/474880-t-compiler.2Fbackports/topic/.23145838.3A.20beta-nominated/near/540530631), this implements a future-compatibility warning lint `macro_extended_temporary_scopes` for errors in Rust 1.92 caused by #145838:

```
warning: temporary lifetime shortening in Rust 1.92
  --> $DIR/macro-extended-temporary-scopes.rs:54:14
   |
LL |             &struct_temp().field
   |              ^^^^^^^^^^^^^ this expression creates a temporary value...
...
LL |         } else {
   |         - ...which will be dropped at the end of this block in Rust 1.92
   |
   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
   = note: for more information, see <https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#macro-extended-temporary-scopes>
   = note: consider using a `let` binding to create a longer lived value
```

Implementation-wise, this reuses the existing temporary scoping FCW machinery introduced for the `tail_expr_drop_order` edition lint: this adds `BackwardIncompatibleDropHint` statements to the MIR at the end of the shortened scopes for affected temporaries; these are then checked in borrowck to warn if the temporary is used after the future drop hint. There are trade-offs here: on one hand, I believe this gives some assurance over ad-hoc pattern-recognition that there are no false positives[^1]. On the other hand, this fails to lint on future dangling raw pointers and it complicates the potential addition of explanatory diagnostics or suggestions[^2]. I'm hopeful that the limitation around dangling pointers won't be relevant in real code, though; the only real instance we've seen of breakage so far is future errors in formatting macro invocations, which this should be able to catch.

Release logistics notes:
- This PR targets the beta branch directly, since the breakage it's a FCW for is landing in the next Rust version.
- #146098 undoes the breakage this is a FCW for. If that behavior is merged and stabilizes in Rust 1.92, this PR should be reverted (or shouldn't be merged) in order to avoid spurious warnings.

cc `@traviscross`

`@rustbot` label +T-lang

[^1]: In particular, more syntactic approaches are complicated by having to avoid warning on promoted constants; they'd either be full of holes, they'd need a lot of extra logic, or they'd need to hack more MIR-to-HIR mapping into `PromoteTemps`.
[^2]: It's definitely possible to add more context and a suggestion, but the ways I've thought of to do so are either too hacky or too complex to feel appropriate for a last-minute direct-to-beta lint.

Author: bors

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -21,6 +21,7 @@ use rustc_middle::ty::print::Print;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult, MoveOutIndex};
+use rustc_session::lint::builtin::MACRO_EXTENDED_TEMPORARY_SCOPES;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Spanned;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
@@ -1580,4 +1581,32 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     pub(crate) fn local_excluded_from_unused_mut_lint(&self, index: Local) -> bool {
         self.local_name(index).is_none_or(|name| name.as_str().starts_with('_'))
     }
+
+    /// Report a temporary whose scope will shorten in Rust 1.92 due to #145838.
+    pub(crate) fn lint_macro_extended_temporary_scope(
+        &self,
+        future_drop: Location,
+        borrow: &BorrowData<'tcx>,
+    ) {
+        let tcx = self.infcx.tcx;
+        let temp_decl = &self.body.local_decls[borrow.borrowed_place.local];
+        let temp_span = temp_decl.source_info.span;
+        let lint_root = self.body.source_scopes[temp_decl.source_info.scope]
+            .local_data
+            .as_ref()
+            .unwrap_crate_local()
+            .lint_root;
+
+        let mut labels = MultiSpan::from_span(temp_span);
+        labels.push_span_label(temp_span, "this expression creates a temporary value...");
+        labels.push_span_label(
+            self.body.source_info(future_drop).span,
+            "...which will be dropped at the end of this block in Rust 1.92",
+        );
+
+        tcx.node_span_lint(MACRO_EXTENDED_TEMPORARY_SCOPES, lint_root, labels, |diag| {
+            diag.primary_message("temporary lifetime will be shortened in Rust 1.92");
+            diag.note("consider using a `let` binding to create a longer lived value");
+        });
+    }
 }

compiler/rustc_borrowck/src/lib.rs

@@ -843,8 +843,8 @@ impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a,
             | StatementKind::ConstEvalCounter
             | StatementKind::StorageLive(..) => {}
             // This does not affect borrowck
-            StatementKind::BackwardIncompatibleDropHint { place, reason: BackwardIncompatibleDropReason::Edition2024 } => {
-                self.check_backward_incompatible_drop(location, **place, state);
+            StatementKind::BackwardIncompatibleDropHint { place, reason } => {
+                self.check_backward_incompatible_drop(location, **place, state, *reason);
             }
             StatementKind::StorageDead(local) => {
                 self.access_place(
@@ -1386,6 +1386,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
         location: Location,
         place: Place<'tcx>,
         state: &BorrowckDomain,
+        reason: BackwardIncompatibleDropReason,
     ) {
         let tcx = self.infcx.tcx;
         // If this type does not need `Drop`, then treat it like a `StorageDead`.
@@ -1412,21 +1413,29 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 if matches!(borrow.kind, BorrowKind::Fake(_)) {
                     return ControlFlow::Continue(());
                 }
-                let borrowed = this.retrieve_borrow_spans(borrow).var_or_use_path_span();
-                let explain = this.explain_why_borrow_contains_point(
-                    location,
-                    borrow,
-                    Some((WriteKind::StorageDeadOrDrop, place)),
-                );
-                this.infcx.tcx.node_span_lint(
-                    TAIL_EXPR_DROP_ORDER,
-                    CRATE_HIR_ID,
-                    borrowed,
-                    |diag| {
-                        session_diagnostics::TailExprDropOrder { borrowed }.decorate_lint(diag);
-                        explain.add_explanation_to_diagnostic(&this, diag, "", None, None);
-                    },
-                );
+                match reason {
+                    BackwardIncompatibleDropReason::Edition2024 => {
+                        let borrowed = this.retrieve_borrow_spans(borrow).var_or_use_path_span();
+                        let explain = this.explain_why_borrow_contains_point(
+                            location,
+                            borrow,
+                            Some((WriteKind::StorageDeadOrDrop, place)),
+                        );
+                        this.infcx.tcx.node_span_lint(
+                            TAIL_EXPR_DROP_ORDER,
+                            CRATE_HIR_ID,
+                            borrowed,
+                            |diag| {
+                                session_diagnostics::TailExprDropOrder { borrowed }
+                                    .decorate_lint(diag);
+                                explain.add_explanation_to_diagnostic(&this, diag, "", None, None);
+                            },
+                        );
+                    }
+                    BackwardIncompatibleDropReason::MacroExtendedScope => {
+                        this.lint_macro_extended_temporary_scope(location, borrow);
+                    }
+                }
                 // We may stop at the first case
                 ControlFlow::Break(())
             },