Trait implementation solving fails for a closure #138805

struct Foo<A, B>(A, B);

#[allow(non_camel_case_types, dead_code)]
trait Fn_require_outlives_in_method<A, B> {
    // a for<'a> alternative that is type checked
    // at the call site
    fn call<'a>(self, value: &'a A) -> &'a B;
}

// impl the trait for FnOnce(&A) -> &B
impl<A, B, F: for<'a> FnOnce(&'a A) -> &'a B /* where A: 'a, B: 'a (trivial bounds) */>
Fn_require_outlives_in_method<A, B> for F {
    #[inline(always)]
    fn call<'a>(self, value: &'a A) -> &'a B {
        self(value)
    }
}

impl<A, B> Foo<A, B> {
    fn new(_value: A, _callback: impl Fn_require_outlives_in_method<A, B>) -> Self {
        todo!()
    }
}

fn check_fn_once_impl_universal_over_lifetime_a(_: impl for<'a> FnOnce(&'a i32) -> &'a i32) {}

fn main() {
    Foo::new(0, |e| e);
}

fn check_fn_once_impl_universal_over_lifetime_a(_: impl for<'a> FnOnce(&'a i32) -> &'a i32) {}

fn main() {
    fn test(e: &i32) -> &i32 { e }

    // Foo::new(0, |e| e); // fails to compile (not general enough)
    // Foo::<i32, i32>::new(0, |e| e); // fails to compile (not general enough)

    check_fn_once_impl_universal_over_lifetime_a(|e| e); // ok

    Foo::new(0, for<'a> |e: &'a i32| -> &'a i32 { e }); // ok (experimental)
    Foo::new(0, test); // ok
}