A `&mut` in a const in a referenced literal doesn't get const-promoted

[theemathas]

const A: &'static mut () = unsafe { std::mem::transmute(1usize) };

fn main() {
    let _x: &'static (&'static mut (),) = &(A,);
}

I think that the above code should compile, due to const promotion. Instead, I got the following error:

error[E0716]: temporary value dropped while borrowed
 --> src/main.rs:4:44
  |
4 |     let _x: &'static (&'static mut (),) = &(A,);
  |             ---------------------------    ^^^^ creates a temporary value which is freed while still in use
  |             |
  |             type annotation requires that borrow lasts for `'static`
5 | }
  | - temporary value is freed at the end of this statement

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

Using a struct literal or an array literal instead of a tuple literal also result in a similar error.

The following modifications to the code causes the code to compile:

Using `&` instead of `&mut` makes the code compile

const A: &'static () = unsafe { std::mem::transmute(1usize) };

fn main() {
    let _x: &'static (&'static (),) = &(A,);
}

Putting the `&mut` inside something else in the const makes the code compile

const A: Option<&'static mut ()> = Some(unsafe { std::mem::transmute(1usize) });

fn main() {
    let _x: &'static (Option<&'static mut ()>,) = &(A,);
}

Omitting the tuple literal makes the code compile

const A: &'static mut () = unsafe { std::mem::transmute(1usize) };

fn main() {
    let _x: &'static &'static mut () = &A;
}

This seems rather inconsistent.

Meta

Reproducible on the playground with version 1.91.0-nightly (2025-08-31 07d246fc6dc227903da2)

[RalfJung]

I think that the above code should compile, due to const promotion

We generally don't promote &mut (with the special exception of &mut []), so why do you think this?

If anything it is kind of odd that your A gets accepted...

Cc @rust-lang/wg-const-eval

[theemathas]

@RalfJung Sorry, but I'm rather confused by what you said.

It seems to me that the reference being promoted is a & reference, not a &mut reference. You seem to be implying that the contents being referenced also must not contain a &mut, but how would you explain above code modifications (collapsed in <details>) somehow compiling?

I don't see why A shouldn't be accepted, especially given #143046 which I think accepts similar code. There is no promotion or lifetime-extension inside the definition of A, and it is a "dangling" pointer to a ZST, which should be valid.

[RalfJung]

You seem to be implying that the contents being referenced also must not contain a &mut

That's at least how it used to be.

I guess now that &mut can be "hidden" inside consts, it's not so clear any more. We could probably allow promoting all non-drop consts. I am just slightly worried there might be gnarly corner cases we are missing...