Temporary lifetime extension for blocks

compiler/rustc_middle/src/middle/region.rs

@@ -226,7 +226,7 @@ pub struct ScopeTree {
     /// `rustc_hir_analysis::check::region` and in the [Reference].
     ///
     /// [Reference]: https://doc.rust-lang.org/nightly/reference/destructors.html#temporary-lifetime-extension
-    extended_temp_scopes: ItemLocalMap<Option<Scope>>,
+    extended_temp_scopes: ItemLocalMap<TempLifetime>,
 
     /// Backwards incompatible scoping that will be introduced in future editions.
     /// This information is used later for linting to identify locals and
@@ -235,7 +235,7 @@ pub struct ScopeTree {
 }
 
 /// Temporary lifetime information for expressions, used when lowering to MIR.
-#[derive(Clone, Copy, Debug, HashStable)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, HashStable)]
 pub struct TempLifetime {
     /// The scope in which a temporary should be dropped. If `None`, no drop is scheduled; this is
     /// the case for lifetime-extended temporaries extended by a const/static item or const block.
@@ -262,12 +262,13 @@ impl ScopeTree {
     }
 
     /// Make an association between a sub-expression and an extended lifetime
-    pub fn record_extended_temp_scope(&mut self, var: hir::ItemLocalId, lifetime: Option<Scope>) {
+    pub fn record_extended_temp_scope(&mut self, var: hir::ItemLocalId, lifetime: TempLifetime) {
         debug!(?var, ?lifetime);
-        if let Some(lifetime) = lifetime {
+        if let Some(lifetime) = lifetime.temp_lifetime {
             assert!(var != lifetime.local_id);
         }
-        self.extended_temp_scopes.insert(var, lifetime);
+        let old_lifetime = self.extended_temp_scopes.insert(var, lifetime);
+        assert!(old_lifetime.is_none_or(|old| old == lifetime));
     }
 
     /// Returns the narrowest scope that encloses `id`, if any.
@@ -347,7 +348,7 @@ impl ScopeTree {
         // Check for a designated extended temporary scope.
         if let Some(&s) = self.extended_temp_scopes.get(&expr_id) {
             debug!("temporary_scope({expr_id:?}) = {s:?} [custom]");
-            return TempLifetime { temp_lifetime: s, backwards_incompatible: None };
+            return s;
         }
 
         // Otherwise, locate the innermost terminating scope.

tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-abort.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;
     }
 

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;
     }
 

tests/ui/borrowck/format-args-temporary-scopes.e2021.stderr

@@ -0,0 +1,16 @@
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/format-args-temporary-scopes.rs:33:64
+   |
+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
+   = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0716`.

tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr

@@ -1,27 +1,40 @@
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/format-args-temporary-scopes.rs:13: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:19: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: aborting due to 2 previous errors
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/format-args-temporary-scopes.rs:33:64
+   |
+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
+   = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0716`.

tests/ui/borrowck/format-args-temporary-scopes.rs

@@ -1,21 +1,38 @@
 //! Test for #145784 as it relates to format arguments: arguments to macros such as `println!`
 //! should obey normal temporary scoping rules.
 //@ revisions: e2021 e2024
-//@ [e2021] check-pass
 //@ [e2021] edition: 2021
 //@ [e2024] edition: 2024
 
 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]
+
+    // This has likewise occurred with `match`, affecting all editions.
+    println!("{:?}{:?}", (), match true { true => &"" as &dyn std::fmt::Debug, false => &temp() });
 }

tests/ui/borrowck/super-let-in-if-block.rs

@@ -0,0 +1,27 @@
+//! 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() {
+    // For `super let` in an extending `if`, the binding `temp` should live in the scope of the
+    // outer `let` statement.
+    let x = if true {
+        super let temp = ();
+        &temp
+    } else {
+        super let temp = ();
+        &temp
+    };
+    x;
+
+    // For `super let` in non-extending `if`, the binding `temp` should live in the temporary scope
+    // the `if` expression is in.
+    std::convert::identity(if true {
+        super let temp = ();
+        &temp
+    } else {
+        super let temp = ();
+        &temp
+    });
+}

tests/ui/borrowck/super-let-projection-extension.rs

@@ -0,0 +1,25 @@
+//! Demonstrates a case where `{ super let x = temp(); &x }` =/= `&temp()`, a variant of which is
+//! observable on stable Rust via the `pin!` macro: `pin!($EXPR)` and `&mut $EXPR` may use different
+//! scopes for their temporaries.
+
+#![feature(super_let)]
+
+use std::pin::pin;
+
+fn temp() {}
+
+fn main() {
+    // This is fine, since the temporary is extended to the end of the block:
+    let a = &*&temp();
+    a;
+    let b = &mut *&mut temp();
+    b;
+
+    // The temporary is dropped at the end of the outer `let` initializer:
+    let c = &*{ super let x = temp(); &x };
+    //~^ ERROR `x` does not live long enough
+    c;
+    let d = &mut *pin!(temp());
+    //~^ ERROR temporary value dropped while borrowed
+    d;
+}

tests/ui/borrowck/super-let-projection-extension.stderr

@@ -0,0 +1,30 @@
+error[E0597]: `x` does not live long enough
+  --> $DIR/super-let-projection-extension.rs:19:39
+   |
+LL |     let c = &*{ super let x = temp(); &x };
+   |                           -           ^^  - `x` dropped here while still borrowed
+   |                           |           |
+   |                           |           borrowed value does not live long enough
+   |                           binding `x` declared here
+LL |
+LL |     c;
+   |     - borrow later used here
+
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/super-let-projection-extension.rs:22:19
+   |
+LL |     let d = &mut *pin!(temp());
+   |                   ^^^^^^^^^^^^- temporary value is freed at the end of this statement
+   |                   |
+   |                   creates a temporary value which is freed while still in use
+LL |
+LL |     d;
+   |     - borrow later used here
+   |
+   = note: consider using a `let` binding to create a longer lived value
+   = note: this error originates in the macro `pin` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0597, E0716.
+For more information about an error, try `rustc --explain E0597`.

tests/ui/drop/destructuring-assignments.rs

@@ -0,0 +1,71 @@
+// Test drop order for destructuring assignments against
+// other expressions they should be consistent with.
+//
+// See:
+//
+// - https://github.com/rust-lang/rust/pull/145838
+//
+// Original author: TC
+// Date: 2025-08-30
+//@ edition: 2024
+//@ run-pass
+
+#![allow(unused_must_use)]
+
+fn main() {
+    assert_drop_order(1..=3, |e| {
+        &({ &*&e.log(2) }, drop(e.log(1)));
+        // &({ &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(2) }, drop(e.log(1))); }
+        drop(e.log(3));
+    });
+    assert_drop_order(1..=3, |e| {
+        _ = &({ &raw const *&e.log(2) }, drop(e.log(1)));
+        drop(e.log(3));
+    });
+    assert_drop_order(1..=3, |e| {
+        { let _ = &({ &raw const *&e.log(2) }, drop(e.log(1))); }
+        drop(e.log(3));
+    });
+    assert_drop_order(1..=3, |e| {
+        let _x; let _y;
+        (_x, _y) = ({ &raw const *&e.log(2) }, drop(e.log(1)));
+        drop(e.log(3));
+    });
+    */
+}
+
+// # Test scaffolding...
+
+use core::cell::RefCell;
+
+struct DropOrder(RefCell<Vec<u64>>);
+struct LogDrop<'o>(&'o DropOrder, u64);
+
+impl DropOrder {
+    fn log(&self, n: u64) -> LogDrop<'_> {
+        LogDrop(self, n)
+    }
+}
+
+impl<'o> Drop for LogDrop<'o> {
+    fn drop(&mut self) {
+        self.0 .0.borrow_mut().push(self.1);
+    }
+}
+
+#[track_caller]
+fn assert_drop_order(
+    ex: impl IntoIterator<Item = u64>,
+    f: impl Fn(&DropOrder),
+) {
+    let order = DropOrder(RefCell::new(Vec::new()));
+    f(&order);
+    let order = order.0.into_inner();
+    let expected: Vec<u64> = ex.into_iter().collect();
+    assert_eq!(order, expected);
+}

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,27 @@ 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_borrow_extended_past_all_blocks() {
+    fn f<T>(_: T) {}
+    f({ &mut || 0 });
+}
+
+fn should_lint_borrow_extended_past_only_some_blocks() {
+    fn f<T>(_: T) {}
+    f({ 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
+    //~| NOTE: borrow later used here
+    //~| NOTE: for more information, see
+}
+
 fn main() {}