fn item can't coerce to trait object when a trait bound has a lifetime parameter

[Ralith]

trait Trait<'a> {}
impl<'a, T> Trait<'a> for T {}

fn func<'a, T: Trait<'a>>(x: &'a str) {}
const CONST: &dyn for<'a> Fn(&'a str) = &func::<i32>;

fails to typecheck with the errors:

error[E0631]: type mismatch in function arguments
 --> src/lib.rs:5:41
  |
4 | fn func<'a, T: Trait<'a>>(x: &'a str) {}
  | ------------------------------------- found signature of `fn(&str) -> _`
5 | const CONST: &dyn for<'a> Fn(&'a str) = &func::<i32>;
  |                                         ^^^^^^^^^^^^ expected signature of `for<'a> fn(&'a str) -> _`
  |
  = note: required for the cast to the object type `dyn for<'a> std::ops::Fn(&'a str)`

error[E0271]: type mismatch resolving `for<'a> <fn(&str) {func::<'_, i32>} as std::ops::FnOnce<(&'a str,)>>::Output == ()`
 --> src/lib.rs:5:41
  |
5 | const CONST: &dyn for<'a> Fn(&'a str) = &func::<i32>;
  |                                         ^^^^^^^^^^^^ expected bound lifetime parameter 'a, found concrete lifetime
  |
  = note: required for the cast to the object type `dyn for<'a> std::ops::Fn(&'a str)`

If Trait does not have a lifetime parameter, or if func::<i32> is replaced with |x| func::<i32>(x), the example compiles successfully.

Meta

rustc --version --verbose:

rustc 1.42.0 (b8cedc004 2020-03-09)
binary: rustc
commit-hash: b8cedc00407a4c56a3bda1ed605c6fc166655447
commit-date: 2020-03-09
host: x86_64-unknown-linux-gnu
release: 1.42.0
LLVM version: 9.0

[Globidev]

I tried to understand what rustc was doing here by implementing the Fn* traits on nightly:

#![feature(unboxed_closures, fn_traits)]

use std::marker::PhantomData;

trait Trait<'a> { }
impl<'a, T> Trait<'a> for T { }

struct Func<'a, T>(PhantomData<&'a T>);
const CONST: &dyn FnOnce(&str) = &Func::<u32>(PhantomData);

impl<'a, T: Trait<'a>> FnOnce<(&'a str,)> for Func<'a, T> {
    type Output = ();    
    extern "rust-call" fn call_once(self, _: (&'a str,)) { }
}

and this yields a similar error

It would compile if what was generated was more along the lines of

impl<'a, T: Trait<'a>> FnOnce<(&'a str,)> for Func<'_, T> { ... }

But I'm not sure I really know what that would imply

playground

[danielhenrymantilla]

This seems related to:

trait Trait<'a> {}
impl<'a> Trait<'a> for () {}

trait Foo {
    fn foo<'a> ()
    ;
}
impl Foo for () {
    fn foo<'a> ()
    where
        () : Trait<'a>,
    {}
}

• Playground

failing because even if the where clause on 'a is met for all lifetimes 'a, Rust still considers that the hrtb signature does not match / typecheck.

[fmease]

The reason is boundness (early bound vs. late bound) of lifetime parameters.

In the snippet found in the issue description, the 'a on func is forced to be early-bound because it appears in the where predicate T: Trait<'a>. If you for example change that bound to T: Trait<'static> while keeping everything intact, it'll compile because the 'a can stay late-bound.

Whenever a lifetime parameter appears in a where predicate (including ones like 'a: 'a or 'a: (sic!)), it can no longer stay late bound because at the time of writing rustc unfortunately doesn't support higher-ranked where clauses yet (with that I don't mean for<'a> …: … but e.g. for<'a: 'b> …). It'll eventually though 🤞.

Re. boundness, the instantiation time differs (hence "early" and "late") and you can't generalize something containing an arbitrary but fixed lifetime to a "truly arbitrary" lifetime for<'a> 'a (I'm grossly simplifying here, cc universe mismatches).

#69994 (comment):

failing because even if the where clause on 'a is met for all lifetimes 'a, Rust still considers that the hrtb signature does not match / typecheck.

Well, yeah kinda? Same reason. Just add where 'a: (sic!) to fn foo in trait Foo and it'll compile just fine since now both 'a's are early-bound.

The diagnostic emitted when boundness doesn't match (E0195) is always super bad. It's kinda annoying to fix and moreover hard to explain concisely.