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. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: Ideally the output should mention that the user needs to use a turbofish here: cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --
the help message seems to only be missing if there are 2 const arguments: using type parameters or just one const param causes a useful help message
claim
It turns out 's repro is different than the original repro. My PR fixes 's examples but not the original one. I'll update it to fix the original one too.
All fixed.

Discussion:
let x = self.parse_seq_to_before_end( &token::Gt, SeqSep::trailing_allowed(token::Comma), <del> |p| p.parse_ty(), </del> <ins> |p| p.parse_generic_arg(), </ins> ); match x { Ok((_, _, false)) => {

/// Parse a generic argument in a path segment. /// This does not include constraints, e.g., `Item = u8`, which is handled in `parse_angle_arg`. <del> fn parse_generic_arg(&mut self) -> PResult<'a, Option<GenericArg>> { </del> <ins> pub(super) fn parse_generic_arg(&mut self) -> PResult<'a, Option<GenericArg>> { </ins> let start = self.token.span; let arg = if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) { // Parse lifetime argument.

} Err(err) => return Err(err), }; let ty = if self.eat(&token::Semi) { <del> TyKind::Array(elt_ty, self.parse_anon_const_expr()?) </del> <ins> let mut length = self.parse_anon_const_expr()?; if let Err(e) = self.expect(&token::CloseDelim(token::Bracket)) { // Try to recover from `X<Y, ...>` when `X::<Y, ...>` works self.check_mistyped_turbofish_with_multiple_type_params(e, &mut length.value)?; self.expect(&token::CloseDelim(token::Bracket))?; } TyKind::Array(elt_ty, length) </ins> } else { <ins> self.expect(&token::CloseDelim(token::Bracket))?; </ins> TyKind::Slice(elt_ty) }; <del> self.expect(&token::CloseDelim(token::Bracket))?; </del> Ok(ty) }

<ins> struct T1<const X1: usize>; struct T2<const X1: usize, const X2: usize>; struct T3<const X1: usize, const X2: usize, const X3: usize>; impl T1<1> { const C: () = (); } impl T2<1, 2> { const C: () = (); } impl T3<1, 2, 3> { const C: () = (); } fn main() { T1<1>::C; //~ ERROR: comparison operators cannot be chained T2<1, 2>::C; //~ ERROR: expected one of `.`, `;`, `?`, `}`, or an operator, found `,` T3<1, 2, 3>::C; //~ ERROR: expected one of `.`, `;`, `?`, `}`, or an operator, found `,` } </ins>

<ins> error: comparison operators cannot be chained --> $DIR/issue-82566-1.rs:18:7 | LL |     T1<1>::C; |       ^ ^ | help: use `::<...>` instead of `<...>` to specify type or const arguments | LL |     T1::<1>::C; |       ^^ error: expected one of `.`, `;`, `?`, `}`, or an operator, found `,` --> $DIR/issue-82566-1.rs:19:9 | LL |     T2<1, 2>::C; |         ^ expected one of `.`, `;`, `?`, `}`, or an operator | help: use `::<...>` instead of `<...>` to specify type or const arguments | LL |     T2::<1, 2>::C; |       ^^ error: expected one of `.`, `;`, `?`, `}`, or an operator, found `,` --> $DIR/issue-82566-1.rs:20:9 | LL |     T3<1, 2, 3>::C; |         ^ expected one of `.`, `;`, `?`, `}`, or an operator | help: use `::<...>` instead of `<...>` to specify type or const arguments | LL |     T3::<1, 2, 3>::C; |       ^^ error: aborting due to 3 previous errors </ins>

<ins> struct Foo1<const N1: usize>; struct Foo2<const N1: usize, const N2: usize>; struct Foo3<const N1: usize, const N2: usize, const N3: usize>; impl<const N1: usize> Foo1<N1> { const SUM: usize = N1; } impl<const N1: usize, const N2: usize> Foo2<N1, N2> { const SUM: usize = N1 + N2; } impl<const N1: usize, const N2: usize, const N3: usize> Foo3<N1, N2, N3> { const SUM: usize = N1 + N2 + N3; } fn foo1() -> [(); Foo1<10>::SUM] { //~ ERROR: comparison operators cannot be chained todo!() } fn foo2() -> [(); Foo2<10, 20>::SUM] { //~^ ERROR: expected one of `.`, `?`, `]`, or an operator, found `,` todo!() } fn foo3() -> [(); Foo3<10, 20, 30>::SUM] { //~^ ERROR: expected one of `.`, `?`, `]`, or an operator, found `,` todo!() } fn main() {} </ins>

<ins> error: comparison operators cannot be chained --> $DIR/issue-82566-2.rs:17:23 | LL | fn foo1() -> [(); Foo1<10>::SUM] { |                       ^  ^ | help: use `::<...>` instead of `<...>` to specify type or const arguments | LL | fn foo1() -> [(); Foo1::<10>::SUM] { |                       ^^ error: expected one of `.`, `?`, `]`, or an operator, found `,` --> $DIR/issue-82566-2.rs:21:26 | LL | fn foo2() -> [(); Foo2<10, 20>::SUM] { |                          ^ expected one of `.`, `?`, `]`, or an operator | help: use `::<...>` instead of `<...>` to specify type or const arguments | LL | fn foo2() -> [(); Foo2::<10, 20>::SUM] { |                       ^^ error: expected one of `.`, `?`, `]`, or an operator, found `,` --> $DIR/issue-82566-2.rs:26:26 | LL | fn foo3() -> [(); Foo3<10, 20, 30>::SUM] { |                          ^ expected one of `.`, `?`, `]`, or an operator | help: use `::<...>` instead of `<...>` to specify type or const arguments | LL | fn foo3() -> [(); Foo3::<10, 20, 30>::SUM] { |                       ^^ error: aborting due to 3 previous errors </ins>