Change:
<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This is a much abbreviated version of the code from my experiments with adding a shuffle API to the stdsimd repo, it probably needs further reduction but I wanted to file this before I forgot: I expected to see this happen: it works, provides a useful error, or even just ICEs. Instead, this happened: I got a request to input a type instead! And no, that doesn't work either if you put it in, because instead you get: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --
The fix is Due to parsing ambiguities generic arguments currently need to be put into braces, unless they are really simple (like or ), is not simple enough.
Oh, cool! That does compile! I knew about that but wasn't sure if that was the problem because I thought that was just for expressions? I guess that's technically an array expression? That is none of the errors I was presented with, though, which makes this a diagnostics problem I suppose?
I believe diagnostic for const generic (example taken from ) needs to be improved too before release, at least I thought that can be used instead, if one didn't know about then they need to search it up.
Arrays as const parameters still have bad error messages. same with tuples
claim

Discussion:
Err(err) } <ins> /// Try to recover from an unbraced const argument whose first token [could begin a type][ty]. /// /// [ty]: token::Token::can_begin_type pub(crate) fn recover_unbraced_const_arg_that_can_begin_ty( &mut self, mut snapshot: SnapshotParser<'a>, ) -> Option<P<ast::Expr>> { match snapshot.parse_expr_res(Restrictions::CONST_EXPR, None) { // Since we don't know the exact reason why we failed to parse the type or the // expression, employ a simple heuristic to weed out some pathological cases. Ok(expr) if let token::Comma | token::Gt = snapshot.token.kind => { self.restore_snapshot(snapshot); Some(expr) } Ok(_) => None, Err(err) => { err.cancel(); None } } } </ins> /// Creates a dummy const argument, and reports that the expression must be enclosed in braces pub fn dummy_const_arg_needs_braces( &self,

GenericArg::Const(self.parse_const_arg()?) } else if self.check_type() { // Parse type argument. <del> let is_const_fn = self.look_ahead(1, |t| t.kind == token::OpenDelim(Delimiter::Parenthesis)); let mut snapshot = self.create_snapshot_for_diagnostic(); </del> <ins> // Proactively create a parser snapshot enabling us to rewind and try to reparse the // input as a const expression in case we fail to parse a type. If we successfully // do so, we will report an error that it needs to be wrapped in braces. let mut snapshot = None; if self.may_recover() && self.token.can_begin_expr() { snapshot = Some(self.create_snapshot_for_diagnostic()); } </ins> match self.parse_ty() { <del> Ok(ty) => GenericArg::Type(ty), </del> <ins> Ok(ty) => { // Since the type parser recovers from some malformed slice and array types and // successfully returns a type, we need to look for `TyKind::Err`s in the // type to determine if error recovery has occurred and if the input is not a // syntactically valid type after all. if let ast::TyKind::Slice(inner_ty) | ast::TyKind::Array(inner_ty, _) = &ty.kind && let ast::TyKind::Err = inner_ty.kind && let Some(snapshot) = snapshot && let Some(expr) = self.recover_unbraced_const_arg_that_can_begin_ty(snapshot) { return Ok(Some(self.dummy_const_arg_needs_braces( self.struct_span_err(expr.span, "invalid const generic expression"), expr.span, ))); } GenericArg::Type(ty) } </ins> Err(err) => { <del> if is_const_fn { match (*snapshot).parse_expr_res(Restrictions::CONST_EXPR, None) { Ok(expr) => { self.restore_snapshot(snapshot); return Ok(Some(self.dummy_const_arg_needs_braces(err, expr.span))); } Err(err) => { err.cancel(); } } </del> <ins> if let Some(snapshot) = snapshot && let Some(expr) = self.recover_unbraced_const_arg_that_can_begin_ty(snapshot) { return Ok(Some(self.dummy_const_arg_needs_braces( err, expr.span, ))); </ins> } // Try to recover from possible `const` arg without braces. return self.recover_const_arg(start, err).map(Some);

let _: Wow<A.0>; //~^ ERROR expected one of //~| HELP expressions must be enclosed in braces to be used as const generic arguments <del> // FIXME(compiler-errors): This one is still unsatisfying, // and probably a case I could see someone typing by accident.. </del> <ins> let _: Wow<[]>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments </ins> let _: Wow<[12]>; <del> //~^ ERROR expected type, found //~| ERROR type provided when a constant was expected </del> <ins> //~^ ERROR expected type //~| ERROR invalid const generic expression //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<[0, 1, 3]>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<[0xff; 8]>; //~^ ERROR expected type //~| ERROR invalid const generic expression //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<[1, 2]>; // Regression test for issue #81698. //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<&0>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<("", 0)>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<(1 + 2) * 3>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments // FIXME(fmease): This one is pretty bad. let _: Wow<!0>; //~^ ERROR expected one of //~| HELP you might have meant to end the type parameters here </ins> }

LL |     let _: Wow<{ A.0 }>; |                +     + <ins> error: expected type, found `]` --> $DIR/bad-const-generic-exprs.rs:16:17 | LL |     let _: Wow<[]>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [] }>; |                +    + </ins> error: expected type, found `12` --> $DIR/bad-const-generic-exprs.rs:19:17 | LL |     let _: Wow<[12]>; |                 ^^ expected type <del> error[E0747]: type provided when a constant was expected </del> <ins> error: invalid const generic expression </ins> --> $DIR/bad-const-generic-exprs.rs:19:16 | LL |     let _: Wow<[12]>; |                ^^^^ <ins> | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [12] }>; |                +      + error: expected type, found `0` --> $DIR/bad-const-generic-exprs.rs:23:17 | LL |     let _: Wow<[0, 1, 3]>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [0, 1, 3] }>; |                +           + error: expected type, found `0xff` --> $DIR/bad-const-generic-exprs.rs:26:17 | LL |     let _: Wow<[0xff; 8]>; |                 ^^^^ expected type error: invalid const generic expression --> $DIR/bad-const-generic-exprs.rs:26:16 | LL |     let _: Wow<[0xff; 8]>; |                ^^^^^^^^^ | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [0xff; 8] }>; |                +           + error: expected type, found `1` --> $DIR/bad-const-generic-exprs.rs:30:17 | LL |     let _: Wow<[1, 2]>; // Regression test for issue #81698. |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [1, 2] }>; // Regression test for issue #81698. |                +        + error: expected type, found `0` --> $DIR/bad-const-generic-exprs.rs:33:17 | LL |     let _: Wow<&0>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ &0 }>; |                +    + error: expected type, found `""` --> $DIR/bad-const-generic-exprs.rs:36:17 | LL |     let _: Wow<("", 0)>; |                 ^^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ ("", 0) }>; |                +         + error: expected type, found `1` --> $DIR/bad-const-generic-exprs.rs:39:17 | LL |     let _: Wow<(1 + 2) * 3>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ (1 + 2) * 3 }>; |                +             + error: expected one of `,` or `>`, found `0` --> $DIR/bad-const-generic-exprs.rs:43:17 | LL |     let _: Wow<!0>; |         -       ^ expected one of `,` or `>` |         | |         while parsing the type for `_` | help: you might have meant to end the type parameters here | LL |     let _: Wow<!>0>; |                 + </ins> <del> error: aborting due to 6 previous errors </del> <ins> error: aborting due to 15 previous errors </ins> <del> For more information about this error, try `rustc --explain E0747`. </del>