Repository: rust
Issue: `rustc` prints the same type as found and expected for function item whose signature includes references
Labels: A-diagnostics,T-compiler

### Code

```Rust
// Playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=a508fc33782b233da242b24a6931c14e
use std::collections::HashMap;

struct Inner;
impl Inner {
    fn maybe_get(&self) -> Option<&String> {
        None
    }
}

#[derive(Default)]
struct Foo {
    m: HashMap<String, Inner>
}

impl Foo {
    fn get<R>(&self, retrieve: impl FnMut(&Inner) -> Option<R>) -> Option<R> {
        self.m.values().find_map(retrieve)
    }
}

fn main() {
    let f = Foo::default();
    f.get(Inner::maybe_get);
}
```


### Current output

```Shell
// Stable 1.69
Compiling playground v0.0.1 (/playground)
error[E0308]: mismatched types
  --> src/main.rs:23:5
   |
23 |     f.get(Inner::maybe_get);
   |     ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected trait `for<'a> <for<'a> fn(&'a Inner) -> Option<&'a String> {Inner::maybe_get} as FnOnce<(&'a Inner,)>>`
              found trait `for<'a> <for<'a> fn(&'a Inner) -> Option<&'a String> {Inner::maybe_get} as FnOnce<(&'a Inner,)>>`
note: the lifetime requirement is introduced here
  --> src/main.rs:16:54
   |
16 |     fn get<R>(&self, retrieve: impl FnMut(&Inner) -> Option<R>) -> Option<R> {
   |                                                      ^^^^^^^^^

// Nightly 1.71.0 2023-05-11
Compiling playground v0.0.1 (/playground)
error[E0308]: mismatched types
  --> src/main.rs:23:5
   |
23 |     f.get(Inner::maybe_get);
   |     ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected enum `Option<&String>`
              found enum `Option<&String>`
note: the lifetime requirement is introduced here
  --> src/main.rs:16:54
   |
16 |     fn get<R>(&self, retrieve: impl FnMut(&Inner) -> Option<R>) -> Option<R> {
   |                                                      ^^^^^^^^^
```


### Desired output

Should mention that the lifetimes of `self`, `retrieve` and `R` must match. 

The code compiles if you write `get` as 

```Shell
 fn get<'a, R>(&'a self, retrieve: impl FnMut(&'a Inner) -> Option<R>) -> Option<R> 
        where R: 'a
```


### Rationale and extra context

_No response_

### Other cases

The original code compiles fine when invoked with a closure like `f.get(|_i| None::<&String>);` that does not relate input and output lifetimes.

Calling `get` with a call to `maybe_get` as a closure (that _does_ relate the lifetimes) like `f.get(|i| i.maybe_get())` gives

```Rust
Compiling playground v0.0.1 (/playground)
error: lifetime may not live long enough
  --> src/main.rs:25:15
   |
25 |     f.get(|i| i.maybe_get());
   |            -- ^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`
   |            ||
   |            |return type of closure is Option<&'2 String>
   |            has type `&'1 Inner`
```

which I have mixed feelings about: on the one hand, you know from the error that the problem is the relation between the lifetimes. 
On the other, you could write `maybe_get` as `fn maybe_get<'s>(&'s self) -> Option<&'s String>` and still get the same error, even though the lifetimes are now the same in the definition (the actual problem is that `get` doesn't know this about `R`). 

Writing `get` as 

```Rust
fn get<'a, R>(&self, retrieve: impl FnMut(&'a Inner) -> Option<R>) -> Option<R> 
        where R: 'a
```

(note that the reference to `Inner` and `R` are constrained through `'a`, but not `self`) gives

```Rust
Compiling playground v0.0.1 (/playground)
error: lifetime may not live long enough
  --> src/main.rs:19:9
   |
16 |     fn get<'a, R>(&self, retrieve: impl FnMut(&'a Inner) -> Option<R>) -> Option<R> 
   |            --     - let's call the lifetime of this reference `'1`
   |            |
   |            lifetime `'a` defined here
...
19 |         self.m.values().find_map(retrieve)
   |         ^^^^^^^^^^^^^^^ argument requires that `'1` must outlive `'a
```
which is much more helpful in figuring out that one needs to bound `self`.



### Anything else?

_No response_