Unhelpful error message when missing the final path segment for a function call

[Jarcho]

Given an invalid call such as:

fn main() {
  foo::("foo");
}

The following diagnostic is issued:

error: expected type, found `"foo"`
 --> src/main.rs:2:9
  |
2 |   foo::("foo");
  |         ^^^^^ expected type

This gets much worse on multiline calls:

fn main() {
  foo::(
    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"),
  ),
}

Which just prints out a diagnostic nowhere near the error:

error: expected type, found `"test"`
  --> src/main.rs:10:13
   |
10 |         baz("test"),
   |             ^^^^^^ expected type

Ideally this should mention something about either missing a missing turbofish (e.g. foo::<..>("foo")), or a missing identifier (e.g. foo::bar("foo")). This would at least get the error pointing to the correct spot.

---

Latest playground nightly (2024-02-09)

[fmease]

Oh, wow, it didn't even occur to me until now that the expression Option::(i32)::None::() is syntactically valid >.<

Edit: Wow, even let _ = Fn::() -> Option<i32>; is syntactically well-formed.

[fmease]

This should pretty easy to fix, basically if we fail to parse a type here

rust/compiler/rustc_parse/src/parser/path.rs

Line 375 in 7954c28

let (inputs, _) = self.parse_paren_comma_seq(|p| p.parse_ty())?;

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 PathStyle is Expr, 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 PathStyle is Pat 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.

[SummerGram]

@rustbot claim