Extremely confusing error around function pointers with inferred arguments

[jyn514]

Consider the following code (playground):

struct S<'a>(&'a str);

fn f(inner: fn(&str, &S)) {
}

#[allow(unreachable_code)]
fn main() {
    let inner: fn(_, _) = unimplemented!();
    f(inner);
}

Rustc gives an error:

error[E0308]: mismatched types
 --> src/main.rs:9:7
  |
9 |     f(inner);
  |       ^^^^^ one type is more general than the other
  |
  = note: expected fn pointer `for<'r, 's, 't0> fn(&'r str, &'s S<'t0>)`
             found fn pointer `fn(&str, &S<'_>)`

Here is the fixed code (playground):

    let inner: fn(&str, &S<'_>) = unimplemented!();
    f(inner);

In particular, the only thing that changed was fn(_, _) -> fn(&str, &S<'_>). But this is exactly the type that was printed in the diagnostic originally! What changed?

I don't understand why this error was emitted, but it would at least be nice to suggest the transformation that makes the code work.

Reduced from rust-lang/crater#542.

[Aaron1011]

This looks like the function-pointer version of #41078 - we don't convert a 'normal' region inference variable into a higher-ranked region. See #41078 (comment) for more details

[camsteffen]

Is this the same issue? The error fails to make any mention of lifetime 'a.

struct Bar<'a>(&'a str);

impl<'a> Bar<'a> {
    fn hello(&self, name: &'a str) {
        println!("Hello {}!", name);
    }
    
    fn say(&self, f: fn(&Self, &str), name: &str) {
        f(self, name)
    }
    
}

fn main() {
    Bar("").say(Bar::hello, "World");
}

Error:

error[E0308]: mismatched types
  --> src/main.rs:15:17
   |
15 |     Bar("").say(Bar::hello, "World");
   |                 ^^^^^^^^^^ one type is more general than the other
   |
   = note: expected fn pointer `for<'r, 's> fn(&'r Bar<'_>, &'s str)`
              found fn pointer `for<'r> fn(&'r Bar<'_>, &str)`

[jyn514]

@camjackson no, that one's because you explicitly restricted name: &'a str to one specific lifetime: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=428e0b2ea360140631ca300668635f97

https://doc.rust-lang.org/nomicon/hrtb.html

[camsteffen]

I know, but the compiler error is misleading.

[jyn514]

Ok, can you open a separate issue for that then? This issue is about when the error isn't necessary at all, the compiler just isn't smart enough to infer the higher-ranked type.

[estebank]

Current output

error[E0308]: mismatched types
 --> src/main.rs:9:7
  |
9 |     f(inner);
  |     - ^^^^^ one type is more general than the other
  |     |
  |     arguments to this function are incorrect
  |
  = note: expected fn pointer `for<'a, 'b, 'c> fn(&'a str, &'b S<'c>)`
             found fn pointer `fn(_, _)`
note: function defined here
 --> src/main.rs:3:4
  |
3 | fn f(inner: fn(&str, &S)) {
  |    ^ -------------------
help: consider removing the ``
  |
9 |     f(inner);
  |

error[E0308]: mismatched types
  --> src/main.rs:17:17
   |
17 |     Bar("").say(Bar::hello, "World");
   |             --- ^^^^^^^^^^ one type is more general than the other
   |             |
   |             arguments to this function are incorrect
   |
   = note: expected fn pointer `for<'a, 'b> fn(&'a Bar<'_>, &'b str)`
                 found fn item `for<'a> fn(&'a Bar<'_>, &str) {Bar::<'_>::hello}`
note: associated function defined here
  --> src/main.rs:10:8
   |
10 |     fn say(&self, f: fn(&Self, &str), name: &str) {
   |        ^^^        ------------------