Constant promotion doesn't work in certain situations

[abacabadabacaba]

This code:

const C: *const *const i32 = [
    &{
        let x: i32 = 0;
        x
    } as *const i32,
]
.as_ptr();

fails to build with an error: error: encountered dangling pointer in final value of constant.

My belief is that the subexpression { let x: i32 = 0; x } should be promoted to a constant. It works if the final .as_ptr() is removed:

const C: [*const i32; 1] = [
    &{
        let x: i32 = 0;
        x
    } as *const i32,
];

If the inner subexpression is replaced with zero, it works as well:

const C: *const *const i32 = [
    &{
        0
    } as *const i32,
]
.as_ptr();

Tested in Rust 1.95.0-nightly (2026-02-24 859951e).

[theemathas]

The second code snippet actually compiles due to lifetime extension, not constant promotion. I will explain the compiler's reasoning.

• The initializer of a const item follows similar rules as let statements, except the extended temporaries will live for the duration of the program.
• The initializer (in this case, the entire thing after the =) is an extending expression.
• Since we have an array expression that's an extending expression, its operand (in this case, the &....*const i32 part) is also an extending expression.
• Since we have a cast expression (with as), its operand (in this case, the &{....} part) is also an extending expression.
• Since we have a borrow expression (with a &) that's an extending expression, its operand (in this case, the {....} part) has its temporary scope extended.
• Therefore, the i32 temporary created by the {....} block will live until the end of the program.

Intuitively, temporary lifetime extension happens when it's "obvious from the syntax" that the extension is required, even before looking at function signatures. Figuring out that your first code snippet "wants" the temporary to live forever requires looking at what the as_ptr method does, which the compiler does not do.

[theemathas]

As for your third snippet, the code compiles due to constant promotion, not temporary lifetime extension. The {0} expression is "simple enough" for the compiler to see that it's basically an integer literal with no side effects, so it gets constant-promoted. It would get similarly constant-promoted even if this entire thing was not in a const item (unlike your second snippet).

Unfortunately though, the exact rules for constant promotion is currently undocumented. But I believe the compiler is working as intended for all three of your code snippets.

[abacabadabacaba]

So the expression { let x: i32 = 0; x } is a constant expression (so the code const C: i32 = { let x: i32 = 0; x }; compiles), but the expression is not subject to constant promotion. This certainly needs to be better documented. I worked around this in my code by using an inner constant, but I feel that it shouldn't be needed.

[theemathas]

The simplest workaround would be to put a const {} block around whatever you need promoted/extended.