lifetime extension for blocks

dianne · dianne · commit 98f09fbb4f2f · 2025-09-19T17:27:46.000-07:00
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -8,7 +8,7 @@
 
 use std::mem;
 
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefId;
@@ -38,6 +38,14 @@ struct ScopeResolutionVisitor<'tcx> {
 
     cx: Context,
 
+    /// Tracks [extending] blocks and `if` expressions. This is used in performing lifetime
+    /// extension on block tail expressions: if we've already extended the temporary scopes of
+    /// extending borrows within a block's tail when checking a parent `let` statement or block, we
+    /// don't want to re-extend them to be shorter when checking the block itself.
+    ///
+    /// [extending]: https://doc.rust-lang.org/nightly/reference/destructors.html#extending-based-on-expressions
+    extended_blocks: FxHashSet<hir::ItemLocalId>,
+
     extended_super_lets: FxHashMap<hir::ItemLocalId, Option<Scope>>,
 }
 
@@ -160,6 +168,17 @@ fn resolve_block<'tcx>(
                     .backwards_incompatible_scope
                     .insert(local_id, Scope { local_id, data: ScopeData::Node });
             }
+            // If we haven't already checked for temporary lifetime extension due to a parent `let`
+            // statement initializer or block, do so. This, e.g., allows `temp()` in `{ &temp() }`
+            // to outlive the block even when the block itself is not in a `let` statement
+            // initializer. The same rules for `let` are used here, so non-extending borrows are
+            // unaffected: `{ f(&temp()) }` drops `temp()` at the end of the block in Rust 2024.
+            if !visitor.extended_blocks.contains(&blk.hir_id.local_id) {
+                let blk_result_scope = prev_cx.parent.and_then(|blk_parent| {
+                    visitor.scope_tree.default_temporary_scope(blk_parent).0
+                });
+                record_rvalue_scope_if_borrow_expr(visitor, tail_expr, blk_result_scope);
+            }
             resolve_expr(visitor, tail_expr, terminating);
         }
     }
@@ -354,6 +373,22 @@ fn resolve_expr<'tcx>(
 
         hir::ExprKind::If(cond, then, Some(otherwise)) => {
             let expr_cx = visitor.cx;
+            // If we haven't already checked for temporary lifetime extension due to a parent `let`
+            // statement initializer or block, do so. This, e.g., allows `format!("temp")` in
+            // `if cond { &format!("temp") } else { "" }` to outlive the block even when the `if`
+            // expression itself is not in a `let` statement initializer. The same rules for `let`
+            // are used here, so non-extending borrows are unaffected:
+            // `if cond { f(&format!("temp")) } else { "" }`
+            // drops `format!("temp")` at the end of the block in all editions.
+            // This also allows `super let` in the then and else blocks to have the scope of the
+            // result of the block, as expected.
+            if !visitor.extended_blocks.contains(&expr.hir_id.local_id) {
+                let blk_result_scope = expr_cx
+                    .parent
+                    .and_then(|if_parent| visitor.scope_tree.default_temporary_scope(if_parent).0);
+                record_rvalue_scope_if_borrow_expr(visitor, then, blk_result_scope);
+                record_rvalue_scope_if_borrow_expr(visitor, otherwise, blk_result_scope);
+            }
             let data = if expr.span.at_least_rust_2024() {
                 ScopeData::IfThenRescope
             } else {
@@ -369,6 +404,13 @@ fn resolve_expr<'tcx>(
 
         hir::ExprKind::If(cond, then, None) => {
             let expr_cx = visitor.cx;
+            // As above, perform lifetime extension on the consequent block.
+            if !visitor.extended_blocks.contains(&expr.hir_id.local_id) {
+                let blk_result_scope = expr_cx
+                    .parent
+                    .and_then(|if_parent| visitor.scope_tree.default_temporary_scope(if_parent).0);
+                record_rvalue_scope_if_borrow_expr(visitor, then, blk_result_scope);
+            }
             let data = if expr.span.at_least_rust_2024() {
                 ScopeData::IfThenRescope
             } else {
@@ -473,7 +515,7 @@ fn resolve_local<'tcx>(
             if let Some(scope) =
                 visitor.extended_super_lets.remove(&pat.unwrap().hir_id.local_id) =>
         {
-            // This expression was lifetime-extended by a parent let binding. E.g.
+            // This expression was lifetime-extended by a parent let binding or block. E.g.
             //
             //     let a = {
             //         super let b = temp();
@@ -489,7 +531,8 @@ fn resolve_local<'tcx>(
             true
         }
         LetKind::Super => {
-            // This `super let` is not subject to lifetime extension from a parent let binding. E.g.
+            // This `super let` is not subject to lifetime extension from a parent let binding or
+            // block. E.g.
             //
             //     identity({ super let x = temp(); &x }).method();
             //
@@ -500,10 +543,16 @@ fn resolve_local<'tcx>(
             if let Some(inner_scope) = visitor.cx.var_parent {
                 (visitor.cx.var_parent, _) = visitor.scope_tree.default_temporary_scope(inner_scope)
             }
-            // Don't lifetime-extend child `super let`s or block tail expressions' temporaries in
-            // the initializer when this `super let` is not itself extended by a parent `let`
-            // (#145784). Block tail expressions are temporary drop scopes in Editions 2024 and
-            // later, their temps shouldn't outlive the block in e.g. `f(pin!({ &temp() }))`.
+            // Don't apply lifetime extension to the initializer of non-extended `super let`.
+            // This helps ensure that `{ super let x = &$EXPR; x }` is equivalent to `&$EXPR` in
+            // non-extending contexts: we want to avoid extending temporaries in `$EXPR` past what
+            // their temporary scopes would otherwise be (#145784).
+            // Currently, this shouldn't do anything. The discrepancy in #145784 was due to
+            // `{ super let x = &{ &temp() }; x }` extending `temp()` to outlive its immediately
+            // enclosing temporary scope (the block tail expression in Rust 2024), whereas in a
+            // non-extending context, `&{ &temp() }` would drop `temp()` at the end of the block.
+            // This particular quirk no longer exists: lifetime extension rules are applied to block
+            // tail expressions, so `temp()` is extended past the block in the latter case as well.
             false
         }
     };
@@ -645,6 +694,9 @@ fn record_rvalue_scope_if_borrow_expr<'tcx>(
             record_rvalue_scope_if_borrow_expr(visitor, subexpr, blk_id)
         }
         hir::ExprKind::Block(block, _) => {
+            // Mark the block as extending, so we know its extending borrows and `super let`s have
+            // extended scopes when checking the block itself.
+            visitor.extended_blocks.insert(block.hir_id.local_id);
             if let Some(subexpr) = block.expr {
                 record_rvalue_scope_if_borrow_expr(visitor, subexpr, blk_id);
             }
@@ -657,6 +709,9 @@ fn record_rvalue_scope_if_borrow_expr<'tcx>(
             }
         }
         hir::ExprKind::If(_, then_block, else_block) => {
+            // Mark the expression as extending, so we know its extending borrows and `super let`s
+            // have extended scopes when checking the `if` expression's blocks.
+            visitor.extended_blocks.insert(expr.hir_id.local_id);
             record_rvalue_scope_if_borrow_expr(visitor, then_block, blk_id);
             if let Some(else_block) = else_block {
                 record_rvalue_scope_if_borrow_expr(visitor, else_block, blk_id);
@@ -822,6 +877,7 @@ pub(crate) fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree {
             tcx,
             scope_tree: ScopeTree::default(),
             cx: Context { parent: None, var_parent: None },
+            extended_blocks: Default::default(),
             extended_super_lets: Default::default(),
         };
 
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-unwind.mir
@@ -66,8 +66,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range<usize>) -> &[u32] {
         StorageDead(_10);
         StorageDead(_9);
         _0 = &(*_12);
-        StorageDead(_12);
         StorageDead(_8);
+        StorageDead(_12);
         return;
     }
 
diff --git a/tests/ui/borrowck/format-args-temporary-scopes.e2021.stderr b/tests/ui/borrowck/format-args-temporary-scopes.e2021.stderr
@@ -1,11 +1,11 @@
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/format-args-temporary-scopes.rs:25:41
+  --> $DIR/format-args-temporary-scopes.rs:33:64
    |
-LL |     println!("{:?}{:?}", (), if true { &format!("") } else { "" });
-   |                              -----------^^^^^^^^^^^--------------
-   |                              |          |           |
-   |                              |          |           temporary value is freed at the end of this statement
-   |                              |          creates a temporary value which is freed while still in use
+LL |     println!("{:?}{:?}", (), if true { std::convert::identity(&format!("")) } else { "" });
+   |                              ----------------------------------^^^^^^^^^^^---------------
+   |                              |                                 |            |
+   |                              |                                 |            temporary value is freed at the end of this statement
+   |                              |                                 creates a temporary value which is freed while still in use
    |                              borrow later used here
    |
    = note: consider using a `let` binding to create a longer lived value
diff --git a/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr b/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr
@@ -1,35 +1,35 @@
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/format-args-temporary-scopes.rs:12:25
+  --> $DIR/format-args-temporary-scopes.rs:17:48
    |
-LL |     println!("{:?}", { &temp() });
-   |                      ---^^^^^---
-   |                      |  |    |
-   |                      |  |    temporary value is freed at the end of this statement
-   |                      |  creates a temporary value which is freed while still in use
+LL |     println!("{:?}", { std::convert::identity(&temp()) });
+   |                      --------------------------^^^^^^---
+   |                      |                         |     |
+   |                      |                         |     temporary value is freed at the end of this statement
+   |                      |                         creates a temporary value which is freed while still in use
    |                      borrow later used here
    |
    = note: consider using a `let` binding to create a longer lived value
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/format-args-temporary-scopes.rs:18:29
+  --> $DIR/format-args-temporary-scopes.rs:24:52
    |
-LL |     println!("{:?}{:?}", { &temp() }, ());
-   |                          ---^^^^^---
-   |                          |  |    |
-   |                          |  |    temporary value is freed at the end of this statement
-   |                          |  creates a temporary value which is freed while still in use
+LL |     println!("{:?}{:?}", { std::convert::identity(&temp()) }, ());
+   |                          --------------------------^^^^^^---
+   |                          |                         |     |
+   |                          |                         |     temporary value is freed at the end of this statement
+   |                          |                         creates a temporary value which is freed while still in use
    |                          borrow later used here
    |
    = note: consider using a `let` binding to create a longer lived value
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/format-args-temporary-scopes.rs:25:41
+  --> $DIR/format-args-temporary-scopes.rs:33:64
    |
-LL |     println!("{:?}{:?}", (), if true { &format!("") } else { "" });
-   |                                        -^^^^^^^^^^-
-   |                                        ||         |
-   |                                        ||         temporary value is freed at the end of this statement
-   |                                        |creates a temporary value which is freed while still in use
+LL |     println!("{:?}{:?}", (), if true { std::convert::identity(&format!("")) } else { "" });
+   |                                        ------------------------^^^^^^^^^^^-
+   |                                        |                       |          |
+   |                                        |                       |          temporary value is freed at the end of this statement
+   |                                        |                       creates a temporary value which is freed while still in use
    |                                        borrow later used here
    |
    = note: consider using a `let` binding to create a longer lived value
diff --git a/tests/ui/borrowck/format-args-temporary-scopes.rs b/tests/ui/borrowck/format-args-temporary-scopes.rs
@@ -7,21 +7,29 @@
 fn temp() {}
 
 fn main() {
-    // In Rust 2024, block tail expressions are temporary scopes, so the result of `temp()` is
-    // dropped after evaluating `&temp()`.
+    // In Rust 2024, block tail expressions are temporary scopes, but temporary lifetime extension
+    // rules apply: `&temp()` here is an extending borrow expression, so `temp()`'s lifetime is
+    // extended past the block.
     println!("{:?}", { &temp() });
+
+    // Arguments to function calls aren't extending expressions, so `temp()` is dropped at the end
+    // of the block in Rust 2024.
+    println!("{:?}", { std::convert::identity(&temp()) });
     //[e2024]~^ ERROR: temporary value dropped while borrowed [E0716]
 
-    // In Rust 1.89, `format_args!` extended the lifetime of all extending expressions in its
-    // arguments when provided with two or more arguments. This caused the result of `temp()` to
-    // outlive the result of the block, making this compile.
+    // In Rust 1.89, `format_args!` had different lifetime extension behavior dependent on how many
+    // formatting arguments it had (#145880), so let's test that too.
     println!("{:?}{:?}", { &temp() }, ());
+
+    println!("{:?}{:?}", { std::convert::identity(&temp()) }, ());
     //[e2024]~^ ERROR: temporary value dropped while borrowed [E0716]
 
     // In real-world projects, this typically appeared in `if` expressions with a `&str` in one
     // branch and a reference to a `String` temporary in the other. Since the consequent and `else`
     // blocks of `if` expressions are temporary scopes in all editions, this affects Rust 2021 and
     // earlier as well.
     println!("{:?}{:?}", (), if true { &format!("") } else { "" });
+
+    println!("{:?}{:?}", (), if true { std::convert::identity(&format!("")) } else { "" });
     //~^ ERROR: temporary value dropped while borrowed [E0716]
 }
diff --git a/tests/ui/borrowck/super-let-in-if-block.rs b/tests/ui/borrowck/super-let-in-if-block.rs
@@ -1,5 +1,6 @@
 //! Test that `super let` bindings in `if` expressions' blocks have the same scope as the result
 //! of the block.
+//@ check-pass
 #![feature(super_let)]
 
 fn main() {
@@ -16,14 +17,11 @@ fn main() {
 
     // For `super let` in non-extending `if`, the binding `temp` should live in the temporary scope
     // the `if` expression is in.
-    // TODO: make this not an error
     std::convert::identity(if true {
         super let temp = ();
         &temp
-        //~^ ERROR `temp` does not live long enough
     } else {
         super let temp = ();
         &temp
-        //~^ ERROR `temp` does not live long enough
     });
 }
diff --git a/tests/ui/borrowck/super-let-in-if-block.stderr b/tests/ui/borrowck/super-let-in-if-block.stderr
diff --git a/tests/ui/drop/destructuring-assignments.rs b/tests/ui/drop/destructuring-assignments.rs
@@ -14,11 +14,11 @@
 
 fn main() {
     assert_drop_order(1..=3, |e| {
-        &({ &raw const *&e.log(1) }, drop(e.log(2)));
+        &({ &raw const *&e.log(2) }, drop(e.log(1)));
         drop(e.log(3));
     });
     assert_drop_order(1..=3, |e| {
-        { let _x; _x = &({ &raw const *&e.log(1) }, drop(e.log(2))); }
+        { let _x; _x = &({ &raw const *&e.log(2) }, drop(e.log(1))); }
         drop(e.log(3));
     });
     assert_drop_order(1..=3, |e| {
diff --git a/tests/ui/drop/lint-tail-expr-drop-order-borrowck.rs b/tests/ui/drop/lint-tail-expr-drop-order-borrowck.rs
@@ -28,7 +28,7 @@ fn should_lint_with_unsafe_block() {
 fn should_lint_with_big_block() {
     fn f<T>(_: T) {}
     f({
-        &mut || 0
+        std::convert::identity(&mut || 0)
         //~^ ERROR: relative drop order changing
         //~| WARN: this changes meaning in Rust 2024
         //~| NOTE: this temporary value will be dropped at the end of the block
@@ -40,12 +40,17 @@ fn should_lint_with_big_block() {
 fn another_temp_that_is_copy_in_arg() {
     fn f() {}
     fn g(_: &()) {}
-    g({ &f() });
+    g({ std::convert::identity(&f()) });
     //~^ ERROR: relative drop order changing
     //~| WARN: this changes meaning in Rust 2024
     //~| NOTE: this temporary value will be dropped at the end of the block
     //~| NOTE: borrow later used by call
     //~| NOTE: for more information, see
 }
 
+fn do_not_lint_extending_borrow() {
+    fn f<T>(_: T) {}
+    f({ &mut || 0 });
+}
+
 fn main() {}
diff --git a/tests/ui/drop/lint-tail-expr-drop-order-borrowck.stderr b/tests/ui/drop/lint-tail-expr-drop-order-borrowck.stderr
@@ -26,22 +26,22 @@ LL |     f(unsafe { String::new().as_str() }.len());
    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order-borrowck.rs:31:9
+  --> $DIR/lint-tail-expr-drop-order-borrowck.rs:31:32
    |
-LL |         &mut || 0
-   |         ^^^^^^^^^
-   |         |
-   |         this temporary value will be dropped at the end of the block
+LL |         std::convert::identity(&mut || 0)
+   |         -----------------------^^^^^^^^^-
+   |         |                      |
+   |         |                      this temporary value will be dropped at the end of the block
    |         borrow later used here
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/temporary-tail-expr-scope.html>
 
 error: relative drop order changing in Rust 2024
-  --> $DIR/lint-tail-expr-drop-order-borrowck.rs:43:9
+  --> $DIR/lint-tail-expr-drop-order-borrowck.rs:43:32
    |
-LL |     g({ &f() });
-   |     -   ^^^^ this temporary value will be dropped at the end of the block
+LL |     g({ std::convert::identity(&f()) });
+   |     -                          ^^^^ this temporary value will be dropped at the end of the block
    |     |
    |     borrow later used by call
    |
diff --git a/tests/ui/drop/super-let-tail-expr-drop-order.rs b/tests/ui/drop/super-let-tail-expr-drop-order.rs

Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range<usize>) -> &[u32] {`
`66`	`66`	`StorageDead(_10);`
`67`	`67`	`StorageDead(_9);`
`68`	`68`	`_0 = &(*_12);`
`69`		`- StorageDead(_12);`
`70`	`69`	`StorageDead(_8);`
	`70`	`+ StorageDead(_12);`
`71`	`71`	`return;`
`72`	`72`	`}`
`73`	`73`