Why can't Rust use the size of a generic parameter as an array length? [duplicate]

Question

I'm having a bit of trouble understanding the problem with this code:

fn doesnt_compile<T>() {
    println!("{}", std::mem::size_of::<[T; std::mem::size_of::<T>()]>());
}

fn main() {
    doesnt_compile::<i32>();
}

When run in the playground (or on my machine) the compiler seems to ignore the implicit trait bound 'Sized' for T.

This is the error:

error[E0277]: the size for values of type `T` cannot be known at compilation time
   --> src/main.rs:2:64
    |
2   |     println!("{}", std::mem::size_of::<[T; std::mem::size_of::<T>()]>());
    |                                                                ^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `T`
    = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
    = help: consider adding a `where T: std::marker::Sized` bound

I stared at it for a while and tried to rewrite it in different ways, but i can't figure out why it shouldn't compile. I find it especially confusing since the following code works just fine:

fn compiles<T>() {
    println!("{}", std::mem::size_of::<T>());
}

fn main() {
    compiles::<i32>();
}

Is there something I'm missing? Is it a compiler bug?

Answer 1

This is the result of a known compiler bug (#43408). Array length expressions cannot currently have type parameters, and apparently it isn't even possible to improve the error message without major refactoring.

There currently isn't a good workaround for this in general, though there might be one for your specific use case.