`pin!()` changed temporary lifetime extension behavior in version 1.88.0 with edition 2024 tail expression temporary scopes

[theemathas]

I tried this code (edition 2024):

#![allow(unused_braces)]

use std::pin::{Pin, pin};

struct HasDrop;

impl Drop for HasDrop {
    fn drop(&mut self) {
        println!("drop");
    }
}

fn main() {
    foo(pin!({ &HasDrop as *const HasDrop }));
}

fn foo(_: Pin<&mut *const HasDrop>) {
    println!("foo");
}

In version 1.87.0, the code printed drop then foo. In version 1.88.0, the code printed foo then drop.

Since version 1.88.0, the macro expands to super let mut pinned = { &HasDrop };, which extends the lifetime of HasDrop to be as long as pinned. (Thanks to @dianne for figuring this out.)

The reason for the different behavior in version 1.87.0 is presumably due to the edition 2024 temporary scope change.

This issue won't be fixed by #145342, since this issue doesn't involve if let.

Presumably regressed in #139114 cc @m-ou-se

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

Meta

Reproducible on godbolt, with --edition=2024.

[theemathas]

The issue also occurs even when the cast is implicit. The following code has the same behavior:

#![allow(unused_braces, dead_code)]

use std::pin::{Pin, pin};

struct HasDrop;

impl Drop for HasDrop {
    fn drop(&mut self) {
        println!("drop");
    }
}

struct Ptr {
    ptr: *const HasDrop,
}

fn main() {
    foo(pin!({ Ptr { ptr: &HasDrop } }));
}

fn foo(_: Pin<&mut Ptr>) {
    println!("foo");
}

[theemathas]

This issue probably needs a decision on what the correct behavior of super let is. And changing that is a breaking change.

@rustbot labels +I-lang-nominated +I-libs-api-nominated

[theemathas]

Note that, without the cast to a raw pointer, the code produces a compile error in 1.87.0, but compiles fine in 1.88.0.

In edition 2021, both 1.87.0 and 1.88.0 prints foo then drop.

[dianne]

Possibly of note: I think the temporary lifetime change here only affects pin! outside of an extending expression. For example,

let x = pin!({ &HasDrop });

would extend the HasDrop even in Rust 1.87. From what I can tell, it previously expanded¹ to

let x = Pin { __pointer: &mut {{ &HasDrop }} };

and now it expands¹ to

let x =
    {
        super let mut pinned = { &HasDrop };
        unsafe { Pin::new_unchecked(&mut pinned) }
    };

both of which allow let's temporary lifetime extension to apply to the HasDrop temporary.

Footnotes

1. with simplified paths for clarity ↩ ↩²