Change:
Given an invalid call such as: The following diagnostic is issued: This gets much worse on multiline calls: Which just prints out a diagnostic nowhere near the error: Ideally this should mention something about either missing a missing turbofish (e.g. ), or a missing identifier (e.g. ). This would at least get the error pointing to the correct spot. Latest playground nightly (2024-02-09) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --
Oh, wow, it didn't even occur to me until now that the expression is syntactically valid .< Edit: Wow, even is syntactically well-formed.
This should pretty easy to fix, basically if we fail to parse a type here we should first of all attach a label to the saying something akin to while parsing this list of parenthesized type arguments starting here and we should suggest removing the trailing path separator if the is , the parenthesized generics aren't followed by or and if the list of non-types we encountered can be successfully parsed as a list of expressions (using a snapshot parser). Furthermore, if the is we can try to reparse the list as a list of patterns and provide the same structured suggestion. I will gladly mentor & review any PR for this.
claim
Hello , is this issue still open for mentoring? I can see that already claimed the issue, but there seems to be no progress.
I read the code but no time to finish it at the moment. You can do it.

Discussion:
use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign}; use super::{Parser, Restrictions, TokenType}; use crate::errors::PathSingleColon; <ins> use crate::parser::{CommaRecoveryMode, RecoverColon, RecoverComma}; </ins> use crate::{errors, maybe_whole}; use ast::token::IdentIsRaw; use rustc_ast::ptr::P;

AssocConstraintKind, BlockCheckMode, GenericArg, GenericArgs, Generics, ParenthesizedArgs, Path, PathSegment, QSelf, }; <del> use rustc_errors::{Applicability, PResult}; </del> <ins> use rustc_errors::{Applicability, Diag, PResult}; </ins> use rustc_span::symbol::{kw, sym, Ident}; use rustc_span::{BytePos, Span}; use std::mem;

.into() } else { // `(T, U) -> R` <del> let (inputs, _) = self.parse_paren_comma_seq(|p| p.parse_ty())?; </del> <ins> let prev_token_before_parsing = self.prev_token.clone(); let token_before_parsing = self.token.clone(); let mut snapshot = None; if self.may_recover() && prev_token_before_parsing.kind == token::ModSep && (style == PathStyle::Expr && self.token.can_begin_expr() || style == PathStyle::Pat && self.token.can_begin_pattern()) { snapshot = Some(self.create_snapshot_for_diagnostic()); } let (inputs, _) = match self.parse_paren_comma_seq(|p| p.parse_ty()) { Ok(output) => output, Err(mut error) if prev_token_before_parsing.kind == token::ModSep => { error.span_label( prev_token_before_parsing.span.to(token_before_parsing.span), "while parsing this parenthesized list of type arguments starting here", ); if let Some(mut snapshot) = snapshot { snapshot.recover_fn_call_leading_path_sep( style, prev_token_before_parsing, &mut error, ) } return Err(error); } Err(error) => return Err(error), }; </ins> let inputs_span = lo.to(self.prev_token.span); let output = self.parse_ret_ty(AllowPlus::No, RecoverQPath::No, RecoverReturnSign::No)?;

} } <ins> /// Recover `$path::(...)` as `$path(...)`. /// /// ```ignore (diagnostics) /// foo::(420, "bar") ///    ^^ remove extra separator to make the function call /// // or /// match x { ///    Foo::(420, "bar") => { ... }, ///       ^^ remove extra separator to turn this into tuple struct pattern ///    _ => { ... }, /// } /// ``` fn recover_fn_call_leading_path_sep( &mut self, style: PathStyle, prev_token_before_parsing: Token, error: &mut Diag<'_>, ) { if ((style == PathStyle::Expr && self.parse_paren_comma_seq(|p| p.parse_expr()).is_ok()) || (style == PathStyle::Pat && self .parse_paren_comma_seq(|p| { p.parse_pat_allow_top_alt( None, RecoverComma::No, RecoverColon::No, CommaRecoveryMode::LikelyTuple, ) }) .is_ok())) && !matches!(self.token.kind, token::ModSep | token::RArrow) { error.span_suggestion_verbose( prev_token_before_parsing.span, format!( "consider removing the `::` here to {}", match style { PathStyle::Expr => "call the expression", PathStyle::Pat => "turn this into a tuple struct pattern", _ => { return; } } ), "", Applicability::MaybeIncorrect, ); } } </ins> /// Parses generic args (within a path segment) with recovery for extra leading angle brackets. /// For the purposes of understanding the parsing logic of generic arguments, this function /// can be thought of being the same as just calling `self.parse_angle_args()` if the source

<ins> fn main() { foo::( //~ HELP: consider removing the `::` here to call the expression //~^ NOTE: while parsing this parenthesized list of type arguments starting bar(x, y, z), bar(x, y, z), bar(x, y, z), bar(x, y, z), bar(x, y, z), bar(x, y, z), bar(x, y, z), baz("test"), //~ ERROR: expected type, found `"test"` //~^ NOTE: expected type ) } </ins>

<ins> error: expected type, found `"test"` --> $DIR/diagnostics-parenthesized-type-arguments-issue-120892-1.rs:11:9 | LL |   foo::( |      --- while parsing this parenthesized list of type arguments starting here ... LL |     baz("test"), |         ^^^^^^ expected type | help: consider removing the `::` here to call the expression | LL -   foo::( LL +   foo( | error: aborting due to 1 previous error </ins>

<ins> fn main() { foo::/* definitely not harmful comment */(123, "foo") -> (u32); //~ ERROR: expected type, found `123` //~^ NOTE: while parsing this parenthesized list of type arguments starting //~^^ NOTE: expected type } </ins>

<ins> error: expected type, found `123` --> $DIR/diagnostics-parenthesized-type-arguments-issue-120892-2.rs:2:45 | LL |   foo::/* definitely not harmful comment */(123, "foo") -> (u32); |      ---------------------------------------^^^ expected type |      | |      while parsing this parenthesized list of type arguments starting here error: aborting due to 1 previous error </ins>

<ins> struct Foo(u32, u32); impl Foo { fn foo(&self) { match *self { Foo::(1, 2) => {}, //~ HELP: consider removing the `::` here to turn this into a tuple struct pattern //~^ NOTE: while parsing this parenthesized list of type arguments starting //~^^ ERROR: expected type, found `1` //~^^^ NOTE: expected type _ => {}, } } } fn main() {} </ins>

<ins> error: expected type, found `1` --> $DIR/diagnostics-parenthesized-type-arguments-issue-120892-3.rs:5:19 | LL |             Foo::(1, 2) => {}, |                ---^ expected type |                | |                while parsing this parenthesized list of type arguments starting here | help: consider removing the `::` here to turn this into a tuple struct pattern | LL -             Foo::(1, 2) => {}, LL +             Foo(1, 2) => {}, | error: aborting due to 1 previous error </ins>