size_of_val is allowed on an uninitialized static

[theemathas]

I don't know if this is a bug or working as intended. So I'm filing an issue just in case.

trait Trait {}
impl Trait for usize {}

static X: usize = std::mem::size_of_val(&X as &dyn Trait);

fn main() {
    println!("{X}");
}

This code compiles and prints 8. I'm not sure if this code is supposed to compile.

See also #142532 and #142404 for shenanigans with uninitialized statics.

Meta

rustc --version --verbose:

rustc 1.89.0-nightly (be19eda0d 2025-06-22)
binary: rustc
commit-hash: be19eda0dc4c22c5cf5f1b48fd163acf9bd4b0a6
commit-date: 2025-06-22
host: aarch64-apple-darwin
release: 1.89.0-nightly
LLVM version: 20.1.7

@rustbot labels +A-const-eval

[workingjubilee]

@JakobDegen says with some conviction this is fine and honestly I'm willing to believe it... but I challenge him to present the docs which say referencing an uninit static is okay.

[workingjubilee]

It also is possible this is a wholesale duplicate of #142404 but I'm not sure!

[JakobDegen]

docs which say referencing an uninit static is okay

It's not really an uninit static - from the point of view of const eval, statics should always be thought of as being sort-of-uninit. This compiles, for example:

pub struct A(&'static B);

pub struct B(&'static A);

pub static Ainst: A = A(&Binst);

pub static Binst: B = B(&Ainst);

There's no "initialization order" for these statics that would make it correct to think about this in those terms.

The general thing to remember is just that consts can refer to the address of a static without issue - that's what makes this compile:

static mut S: i32 = 0;
const S_PTR: *const i32 = &raw const S;

So this example is just a natural extension of that. The only slightly interesting thing is that you can then take such a pointer to a static, coerce it to a &dyn, and then access the vtable of that thing, all still at const time. That seems worth documenting, but it doesn't seem like there's anything wrong with it

[theemathas]

On a related note: This also compiles

trait Trait: Sync {}

impl Trait for &dyn Trait {}

static X: &dyn Trait = &X;

[oli-obk]

Yea none of these ever read from the static, they just use type information

static X: & [usize] = & [std::mem::size_of_val(*&X)];

fn main() {
    println!("{X:?}");
}

Errors as expected. It does not use any of the weird code paths that skip checks

[Jules-Bertholet]

On a related note: This also compiles

trait Trait: Sync {}

impl Trait for &dyn Trait {}

static X: &dyn Trait = &X;

This is really fun!

use std::any::Any;

static X: &(dyn Any + Sync) = &X;

fn main() {
    let mut any: &dyn Any = X;
    loop {
        any = any.downcast_ref::<&(dyn Any + Sync)>().unwrap();
        println!("It's `Any` all the way down");
    }
}

trait Turtle: Sync {
    fn stack(&self) {} 
}

impl<T: Turtle + ?Sized> Turtle for &T {
    fn stack(&self) {
        <T as Turtle>::stack(*self);
    }
}

static X: &dyn Turtle = &X;

fn main() {
    X.stack(); // thread 'main' has overflowed its stack
}