Regression: format_args!() no longer lifetime-extends some temporaries.

@rustbot

Note that unlike the other similar issues, this bug does not involve if let, and therefore will not be fixed by #145342.

I tried this code:

#[derive(Debug)]
struct Thing;

#[derive(Debug)]
struct Ref<'a>(&'a Thing);
impl Drop for Ref<'_> {
    fn drop(&mut self) {}
}

fn new_thing() -> Thing {
    Thing
}

fn new_ref(x: &Thing) -> Ref<'_> {
    Ref(x)
}

pub fn foo() {
    let _x = format_args!("{:?}, {:?}", 1, new_ref(&new_thing()));
}

The code compiled in version 1.88.0. However, in version 1.89.0, I get the following compile error:

error[E0716]: temporary value dropped while borrowed
  --> src/lib.rs:19:53
   |
19 |     let _x = format_args!("{:?}, {:?}", 1, new_ref(&new_thing()));
   |                                            ---------^^^^^^^^^^^- - temporary value is freed at the end of this statement
   |                                            |        |
   |                                            |        creates a temporary value which is freed while still in use
   |                                            a temporary with access to the borrow is created here ...
20 | }
   | - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `Ref`
   |
   = note: consider using a `let` binding to create a longer lived value

For more information about this error, try `rustc --explain E0716`.

I'm not sure how important this is though, since as far as I can tell, there is no way to actually be able to use the value of _x in version 1.88.0.

Presumably regressed in #140748

@rustbot labels +regression-from-stable-to-stable +F-super_let +A-destructors

Meta

Regression from stable rust version 1.88.0 to 1.89.0.

@dianne

@dianne's explanation of the issue, copied from #145342 (comment):

Oh nice, I think that's a different bug! Lifetime extension is happening there. Here's the pretty-printed HIR:
fn foo() {
    let _x =
        {
            super let args = (&1, &new_ref(&new_thing()));
            super let args =
                [format_argument::new_debug(args.0),
                        format_argument::new_debug(args.1)];
            format_arguments::new_v1(&["", ", "], &args)
        };
}
Unlike with write!, which doesn't put the super lets in a position where they can be lifetime-extended, these super lets are extended by the outer let, which ends up tangling up the drop order (I assume the tangled drop order is a bug).

This PR only changes non-lifetime-extended super let, so that regression is unaffected.

Additional diagnosis: this is maybe to be expected from the current expansion of format_args!. The inner new_thing() temp doesn't get lifetime-extended, whereas the outer new_ref(&that_temp) does. It's like normal let in that way, when in an extending expression in a parent let initializer (as in all these examples); pulling the super lets out of the block gives us

let args = (&1, &new_ref(&new_thing()));
// ...

which results in the same error.

With just one format argument, we run into a similar issue:

let _x =
    {
        super let args =
            [format_argument::new_debug(&new_ref(&new_thing()))];
        format_arguments::new_v1(&[""], &args)
    };

The format arguments can be assigned to _x, but _x can't be used because the temporaries aren't lifetime-extended.

So my feeling is this may be a limitation of format_args!'s expansion and of let's lifetime extension rules, rather than a bug in the implementation of super let. This didn't come up in the issue with assigning format arguments in if let, because temporaries from if let's scrutinee live into the success block.

Another case of format_args! being inconsistent with lifetime extension (same underlying cause) (playground):

// This works; the intermediate `super let` from having multiple arguments
// causes the `Droppy` temporary's lifetime to be extended:
let x = format_args!("{:?}, {:?}", 1, Droppy);
x;
// This doesn't work; no intermediate `super let` means no extension:
let y = format_args!("{:?}", Droppy);
y;

@rustbot

Assigning priority (discussion on Zulip).

@rustbot label -I-prioritize +P-medium

To make it more fun, the effect of an "optimization" is visible to users:

// This works. {:?} is not optimized.
let x = format_args!("{:?}, {:?}", 1, Droppy);
x;
// This fails. {} with a literals is optimized so the
// format macro becomes effectively:
// format_args!("1, {:?}", Droppy)
let y = format_args!("{}, {:?}", 1, Droppy);
y;

So my feeling is this may be a limitation of format_args!'s expansion and of let's lifetime extension rules, rather than a bug in the implementation of super let.

Yup, this is expected. It is technically a breaking change that it went from 'using it is an error' to 'defining it is an error', but it's extremely unlikely to result in any real life regressions.

What is not expected is that it behaves differently with one or with two+ arguments. I'll fix that.

What is not expected is that it behaves differently with one or with two+ arguments. I'll fix that.

Opened #145880 for that.

Navigation Menu

Repository navigation

Regression: format_args!() no longer lifetime-extends some temporaries. #145422

Meta

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Regression: format_args!() no longer lifetime-extends some temporaries. #145422

Description

Meta

Activity

rustbot commented on Aug 15, 2025

theemathas commented on Aug 15, 2025

dianne commented on Aug 15, 2025

dianne commented on Aug 16, 2025

apiraino commented on Aug 18, 2025

theemathas commented on Aug 26, 2025

m-ou-se commented on Aug 26, 2025

m-ou-se commented on Aug 26, 2025

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions