fix let _: ty = expr subtyping error

[lcnr]

fn uwu<'b>(func: for<'a> fn(&'a ())) {
    let _: fn(&'b ()) = func;
}

Placeholder patterns _ end up getting converted to AscribeUserType(_1, UserTypeProjection { base: UserType(1), projs: [] }) in the mir. This type ascription is covariant.

In fn check_user_type_annotations we previously checked the type annotations without considering variance, breaking the above example. As lifetimes in the inferred_type get erased they don't have any relation to other lifetimes in the body, so

struct Foo<'a>(&'a ());
fn uwu<'a>(f: Foo<'static>) {
    let _: Foo<'a> = f;
}

does not error because 'static in the inferred_ty gets erased and then replaced with an unbound inference variable.
Note that the following example wouldn't have any issues here either way as there is an implicit reborrow before the assignment.

fn uwu<'a>(v: &'static i32) {
    let _: &'a i32 = v;
}

With this PR we now eagerly consider variance in check_user_type_annotations and then always use invariance when encountering user type annotation statements in the mir.

[rust-highfive]

r? @cjgillot

(rust-highfive has picked a reviewer for you, use r? to override)

[lcnr]

r? @rust-lang/wg-compiler-nll

[bors]

☔ The latest upstream changes (presumably #93148) made this pull request unmergeable. Please resolve the merge conflicts.

[nikomatsakis]

I'm trying to remember why we chose to use "type equality" here. I have a vague memory that there was a reason, but it seems there aren't any failing tests, at least.

[nikomatsakis]

r? @nikomatsakis

[nikomatsakis]

@bors rollup=never

[lcnr]

@nikomatsakis this is now ready for review.

I think we always eq the inferred_ty with some other type while typechecking the mir, and that other type should be checked to be wf. So I don't think that we also have to emit a wf obligation for inferred_ty here.

[nikomatsakis]

r=me with fresh comments + tests

[nikomatsakis]

It would be good to have a comment explaining:

let x: T = ...; // invariant
let _: T = ...; // covariant

[lcnr]

the following is still broken:

struct Foo<T>(T); // `T` is covariant.
fn foo<'b>(x: Foo<for<'a> fn(&'a ())>) {
    let Foo(y): Foo<fn(&'b ())> = x;
}

going to take some time to think about the bigger picture here

[bors]

☔ The latest upstream changes (presumably #94059) made this pull request unmergeable. Please resolve the merge conflicts.

[nikomatsakis]

@rustbot author

[Dylan-DPC]

@lcnr whats the status on this?

[lcnr]

this needs a bigger change to the mir, intend to continue this work at some point in the near future. Can close this PR for now