`unused_parens`: False positive on parenthesized type-relative paths that would otherwise be interpreted as the start of a generic param list (`impl<T>`, `for<T>`, `where<T>`)

[kadiwa4]

Code

struct Something;
impl (<Something>::Item) {}

Current output

warning: unnecessary parentheses around type
 --> src/lib.rs:2:6
  |
2 | impl (<Something>::Item) {}
  |      ^                 ^
  |
  = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
  |
2 - impl (<Something>::Item) {}
2 + impl <Something>::Item {}
  |

error[E0223]: ambiguous associated type
 --> src/lib.rs:2:7
  |
2 | impl (<Something>::Item) {}
  |       ^^^^^^^^^^^^^^^^^ help: use the fully-qualified path: `<Something as IntoIterator>::Item`

For more information about this error, try `rustc --explain E0223`.
warning: `playground` (lib) generated 1 warning
error: could not compile `playground` (lib) due to previous error; 1 warning emitted

on rustc nightly 2023-07-29

Desired output

Same thing without the unused_parens warning.

Rationale and extra context

Without the parentheses, it would be equivalent to

impl<Something> ::Item {}

Note that Something is now a generic type and ::Item is a standalone item path.

[StrayLittlePunk]

@rustbot claim

[Arjentix]

I faced the same issue.
Also it's not only the lint problem, it's rustc interpretation problem.

Example

Looks like in this examplerustc interprets (Something) as just Something (while I expected it to be interpreted like a tuple) and raises the lint warning:

struct Something;

trait MyTrait {}

impl MyTrait for (Something) {} // warning: unnecessary parentheses around type

But it can be fixed by adding , which I find a very awkward solution:

struct Something;

trait MyTrait {}

impl MyTrait for (Something,) {}

Playground to try.

[fmease]

Similarly here:

pub fn f<T: Iterator>() where (<T>::Item): Copy {} //~ WARN unnecessary parentheses around type

Without parentheses, you'd get:

error: generic parameters on `where` clauses are reserved for future use
  --> src/lib.rs:10:31
   |
10 | pub fn f<T: Iterator>() where <T>::Item: Copy {}
   |                               ^^^ currently unsupported

Or here:

#![feature(more_qualified_paths)]

fn scope<T: Iterator<Item = String>>() {
    for (<T>::Item { .. }) in [] {} //~ WARN unnecessary parentheses around pattern
}

Without parentheses, you'd get:

error: expected one of `async`, `gen`, `move`, `static`, `use`, `|`, or `||`, found `::`
 --> src/lib.rs:4:12
  |
4 |     for <T>::Item { .. } in [] {}
  |            ^^ expected one of 7 possible tokens

error[E0658]: `for<...>` binders for closures are experimental
 --> src/lib.rs:4:5
  |
4 |     for <T>::Item { .. } in [] {}
  |     ^^^^^^^