borrowck can impact type inference

[lcnr]

opaque types + leak check is somewaht tragic

struct SendIfEq<'a, 'b>(Option<*mut (&'a (), &'b ())>);
unsafe impl<'a> Send for SendIfEq<'a, 'a> {}

trait Trait<'a, 'hr> {}
impl<'a, 'hr, F, R> Trait<'a, 'hr> for F
where
    F: FnOnce(&'a (), &'hr ()) -> R,
    R: Send,
{}

trait HigherRanked<'a, T> {}
impl<'a, F: for<'hr> Trait<'a, 'hr>> HigherRanked<'a, u32> for F {}
impl<'a, F> HigherRanked<'a, i32> for F {}

fn check_bound<'a, T>(_: impl HigherRanked<'a, T>) -> T { todo!() }

fn different<'a, 'b>(_: &'a (), _: &'b ()) -> impl Sized {
    SendIfEq::<'a, 'b>(None)
}

fn equal<'a, 'b>(_: &'a (), _: &'b ()) -> impl Sized {
    SendIfEq::<'a, 'a>(None)
}

fn ok() {
    check_bound(different);
}

fn ambig() {
    check_bound(equal);
}

fn ok currently compiles with -Znext-solver while ambig never does. I think that's because the leak check in evaluate is quite jank and we don't return constraints from nested trait goals.

[lcnr]

given that we also sometimes leak-check after fulfill, the same thing also impacts the old solver if we were to encounter this during e.g. method selection https://rust.godbolt.org/z/z8168K4rP

struct SendIfEq<'a, 'b>(Option<*mut (&'a (), &'b ())>);

unsafe impl<'a> Send for SendIfEq<'a, 'a> {}

trait Trait<'a, 'hr> {
    type Assoc;
}
impl<'a, 'hr, F, R> Trait<'a, 'hr> for F
where
    F: FnOnce(&'a (), &'hr ()) -> R,
    R: Send,
{
    type Assoc = ();
}

struct Foo<'a, T, F>(F, Option<(&'a (), T)>);
impl<'a, F: for<'hr> Trait<'a, 'hr, Assoc = ()>> Foo<'a, u32, F> {
    fn foo(&self) {}
}
impl<'a, F> Foo<'a, i32, F> {
    fn foo(&self) {}
}

fn different<'a, 'b>(_: &'a (), _: &'b ()) -> impl Sized {
    SendIfEq::<'a, 'b>(None)
}
fn equal<'a, 'b>(_: &'a (), _: &'b ()) -> impl Sized {
    SendIfEq::<'a, 'a>(None)
}

fn ok() {
    Foo(different, None).foo();
}

fn ambig() {
    Foo(equal, None).foo();
}