Incorrect compiler hint for complicated type handler

[olegnn]

I was trying to implement custom macro parser but fall into strange issue.
Having following code

use proc_macro2::TokenStream;
use quote::quote;
use syn::parse::{Parse, ParseStream, Peek};
use syn::token::Token;

#[derive(Debug)]
struct ParseType {
    pub tokens: TokenStream,
}

mod custom {
    syn::custom_punctuation!(Arrow, ==>);
}

fn parse_until<T: Token>(
    input: ParseStream,
    ending_tokens: &[&impl Peek<Token = T>],
) -> syn::Result<TokenStream> {
    let mut tokens = TokenStream::new();
    while !input.is_empty() && !ending_tokens.into_iter().any(|token| input.peek(token)) {
        let next: proc_macro2::TokenTree = input.parse()?;
        tokens.extend(Some(next));
    }
    Ok(tokens)
}

impl Parse for ParseType {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(ParseType {
            tokens: parse_until(input, &[&custom::Arrow])?,
        })
    }
}

fn main() {
    let result: syn::Result<ParseType> =
        syn::parse2(quote! { { Ok::<usize, usize>(1) } ==> to the moon });
    println!("Parsed: {:?}", result.unwrap());
}

(Playground)

I got an error

error[E0277]: expected a `std::ops::Fn<(syn::lookahead::TokenMarker,)>` closure, found `impl Peek<Token = T>`
  --> src/main.rs:20:77
   |
20 |     while !input.is_empty() && !ending_tokens.into_iter().any(|token| input.peek(token)) {
   |                                                                             ^^^^ expected an `Fn<(syn::lookahead::TokenMarker,)>` closure, found `impl Peek<Token = T>`
   |
   = help: the trait `std::ops::Fn<(syn::lookahead::TokenMarker,)>` is not implemented for `impl Peek<Token = T>`
   = help: consider adding a `where impl Peek<Token = T>: std::ops::Fn<(syn::lookahead::TokenMarker,)>` bound
   = note: required because of the requirements on the impl of `std::ops::FnOnce<(syn::lookahead::TokenMarker,)>` for `&impl Peek<Token = T>`
   = note: required because of the requirements on the impl of `syn::lookahead::Peek` for `&&impl Peek<Token = T>`

So I added where impl Peek<Token = T>: std::ops::Fn<(syn::lookahead::TokenMarker,)> to the code and then situation became worse:

error[E0603]: module `lookahead` is private
  --> src/main.rs:18:78
   |
18 | ) -> syn::Result<TokenStream> where impl Peek<Token = T>: std::ops::Fn<(syn::lookahead::TokenMarker,)> {
   |                                                                              ^^^^^^^^^

error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
  --> src/main.rs:18:37
   |
18 | ) -> syn::Result<TokenStream> where impl Peek<Token = T>: std::ops::Fn<(syn::lookahead::TokenMarker,)> {
   |                                     ^^^^^^^^^^^^^^^^^^^^

error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead
  --> src/main.rs:18:59
   |
18 | ) -> syn::Result<TokenStream> where impl Peek<Token = T>: std::ops::Fn<(syn::lookahead::TokenMarker,)> {
   |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: for more information, see https://github.com/rust-lang/rust/issues/29625

For the first of them it's ok [for me at least] that compiler can't understand which module is private, however the second and the third make me very confused, because this's the code generated by compiler itself.

[olegnn]

input.peek(**token)

solved the problem but compiler hints in this case only made this little problem look so terrifying.

[cuviper]

#64565 offers a more succinct version of that hint, suggesting where impl Trait bounds that aren't actually valid to write. But any hint along those lines would still be misleading in your case.

[estebank]

Current output (minimal change to suggestion):

error[E0277]: expected a `std::ops::Fn<(syn::lookahead::TokenMarker,)>` closure, found `impl Peek<Token = T>`
  --> src/main.rs:20:82
   |
17 |     ending_tokens: &[&impl Peek<Token = T>],
   |                       -------------------- help: consider further restricting this bound: `impl Peek<Token = T> + std::ops::Fn<(syn::lookahead::TokenMarker,)>`
...
20 |     while !input.is_empty() && !ending_tokens.into_iter().any(|token| input.peek(token)) {
   |                                                                                  ^^^^^ expected an `Fn<(syn::lookahead::TokenMarker,)>` closure, found `impl Peek<Token = T>`
   |
   = help: the trait `std::ops::Fn<(syn::lookahead::TokenMarker,)>` is not implemented for `impl Peek<Token = T>`
   = note: required because of the requirements on the impl of `std::ops::FnOnce<(syn::lookahead::TokenMarker,)>` for `&impl Peek<Token = T>`
   = note: required because of the requirements on the impl of `syn::lookahead::Peek` for `&&impl Peek<Token = T>`

We now check if borrowing the argument would make the expression valid and suggest adding & if so. We should add a check that does the reverse (check if dereferencing the argument would make it valid) too.

[steveklabnik]

Triage: output has slightly changed:

  Compiling playground v0.0.1 (/playground)
error[E0277]: expected a `std::ops::Fn<(syn::lookahead::TokenMarker,)>` closure, found `impl Peek<Token = T>`
  --> src/main.rs:20:82
   |
20 |     while !input.is_empty() && !ending_tokens.into_iter().any(|token| input.peek(token)) {
   |                                                                                  ^^^^^ expected an `Fn<(syn::lookahead::TokenMarker,)>` closure, found `impl Peek<Token = T>`
   |
   = note: required because of the requirements on the impl of `FnOnce<(syn::lookahead::TokenMarker,)>` for `&impl Peek<Token = T>`
   = note: required because of the requirements on the impl of `Peek` for `&&impl Peek<Token = T>`
help: consider further restricting this bound
   |
17 |     ending_tokens: &[&impl Peek<Token = T> + std::ops::Fn<(syn::lookahead::TokenMarker,)>],
   |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to previous error

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

[Dylan-DPC]

Current output:

error[E0277]: the trait bound `&&impl Peek<Token = T>: Peek` is not satisfied
   --> src/main.rs:20:82
    |
20  |     while !input.is_empty() && !ending_tokens.into_iter().any(|token| input.peek(token)) {
    |                                                                             ---- ^^^^^ the trait `Fn(syn::lookahead::TokenMarker)` is not implemented for `impl Peek<Token = T>`, which is required by `&&impl Peek<Token = T>: Peek`
    |                                                                             |
    |                                                                             required by a bound introduced by this call
    |
    = note: required for `&impl Peek<Token = T>` to implement `FnOnce(syn::lookahead::TokenMarker)`
    = note: required for `&&impl Peek<Token = T>` to implement `Peek`
note: required by a bound in `ParseBuffer::<'a>::peek`
   --> /playground/.cargo/registry/src/index.crates.io-6f17d22bba15001f/syn-2.0.90/src/parse.rs:581:20
    |
581 |     pub fn peek<T: Peek>(&self, token: T) -> bool {
    |                    ^^^^ required by this bound in `ParseBuffer::<'a>::peek`
help: consider further restricting this bound
    |
17  |     ending_tokens: &[&impl Peek<Token = T> + Fn(syn::lookahead::TokenMarker)],
    |                                            +++++++++++++++++++++++++++++++++

For more information about this error, try `rustc --explain E0277`.