associated-constants can not be used in constant expressions

[MaikKlein]

https://doc.rust-lang.org/book/associated-constants.html

#![feature(associated_consts)]

trait Foo {
    const ID: usize;
}

impl Foo for i32 {
    const ID: usize = 1;
}
fn main() {
    let arr: [i32; i32::ID];
}

https://is.gd/L4Fg4k

array length constant evaluation error: non-constant path in constant expression

I had a quick look at the rfc but I couldn't find out if it should be legal to use associated-constants in constant expressions.

[Aatch]

It should be allowed in the long run. It just requires some significant changes to how we handle both type-checking and constant evaluation.

[crumblingstatue]

I think this should be resolved before associated consts get stabilized.
Ref #29646

[burdges]

I've run into this problem as well. It creates minor issues with working around the larger limits discussed in rust-lang/rfcs#1772

[nwin]

Maybe related:

#![feature(associated_consts)]

pub trait ArrayTrait {
    const LENGTH: usize;
    fn get_array() -> [i32; Self::LENGTH];
}

https://is.gd/a1qsuL

unresolved path in constant expression

[raphaelcohn]

It's actually very irritating, and make associated consts in traits of limited value. For example, I need to model 4 different fixed large arrays of data that represent hash distributions. These are modelled as a trait. A consumer function trying to then use the size in a derived constant can't. (in this case, to compute a bit pattern from a size). It also means that one can't scope constants correctly (eg @nwin) and so rely on fallbacks to global constants. Yuck.

[gnzlbg]

I would like to fix this, would anybody be able to mentor me on it?

[przygienda]

Another problem currently is that if e.g. an associated constant is implemented on an enum and the enum imported in another module, the constant is invisible (today's nightly)

prz-mbp:mini_igp prz$ rustc --version
rustc 1.16.0-nightly (4ecc85b 2016-12-28)

it works if the mod is in same file?

https://is.gd/eKVLJR

[tforgione]

Furthermore, if you try to make generics with associated constants, it'll crash the compiler :

#![feature(associated_consts)]
trait Size {
    const size: usize;
}

struct One;
impl Size for One {
    const size: usize = 1;
}

struct MyArray<T: Size> {
    data: [i32; T::size],
}

fn main() { }

crashes with this error.

$ rustc --version
rustc 1.17.0-nightly (956e2bcba 2017-02-12)

Hope this can help.

[withoutboats]

Status update:

The example in the original post compiles today; as long as the type the associated const is associated with is a concrete type, this works.

The example that @tforgione posted, in which the const is associated with a type parameter returns an error today.

[nwin]

Which is essential identical with my example which doesn’t compile as well, at least the error message changed. to

error[E0402]: cannot use an outer type parameter in this context