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

[theemathas]

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.

[rustbot]

Unknown labels: F-if_let

[theemathas]

@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.

[dianne]

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.