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; 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 that if this is a bug, it may be with how format_args! expands rather than with the implementation of super let.