Lang discussion: Item-level `const {}` blocks, and `const { assert!(...) }`

[joshtriplett]

In discussion of rust-lang/libs-team#325 (a proposal for a compile-time assert macro), the idea came up to allow const {} blocks at item level, and then have people use const { assert!(...) }.

@rust-lang/libs-api would like some guidance from @rust-lang/lang about whether lang is open to toplevel const { ... } blocks like this, which would influence whether we want to add a compile-time assert macro, as well as what we want to call it (e.g. static_assert! vs const_assert! vs some other name).

Filing this issue to discuss in a lang meeting. This issue is not seeking any hard commitment to add such a construct, just doing a temperature check.

[CAD97]

To ensure that it's noted: if both item and expression const blocks are valid in the same position (i.e. in statement position), a rule to disambiguate would be needed (like for statement versus expression if-else). IMO it would be quite unfortunate for item-level const blocks to be evaluated pre-mono if that same const block but statement-level would be evaluated post-mono.

Additionally: since const { assert!(...) } is post-mono (due to using the generic context), it's potentially desirable to push people towards using const _: () = assert!(...); (which is pre-mono) whenever possible (not capturing generics).

[traviscross]

It's worth mentioning too the presence of const (associated) items whose asserts fire post-mono, e.g.:

struct S<const N: usize, const M: usize>;
impl<const N: usize, const M: usize> S<N, M> {
    const _0: () = assert!(N * 2 == M);
    //~^ ERROR evaluation of `S::<2, 2>::_0` failed
}

fn main() {
    _ = S::<2, 2>::_0; //~ NOTE erroneous constant encountered
}

I mention this as, to consider what's asked here, we'd need to discuss what meaning, if any, we'd ascribe to:

struct S<const N: usize, const M: usize>;
impl<const N: usize, const M: usize> S<N, M> {
    const { assert!(N * 2 == M); }
    fn f();
}

fn main() {
    _ = S::<2, 2>::f();
}