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();
}

[joshtriplett]

We discussed this in today's @rust-lang/lang meeting for a vibe check. The general feedback was positive.

The simple case of a top-level const { ... } block seemed straightforward, and completely equivalent to const _: () = ...; in that context. We were enthusiastic about seeing that.

It'll require more specification to support this inside functions or impl blocks. We were enthusiastic about seeing that too, but it'll require more specification, and in particular documentation of the distinction between pre-mono and post-mono.

[RalfJung]

inside functions

How's that supposed to work, given the ambiguity with const block expressions?