error[E0308]: mismatched types `expected fn pointer, found fn item` about rust HOT 2 OPEN

type One = for<'a> fn(&'a ());
type Two = fn(&'static ());
// One is subtype of Two

fn same<T>(_: T, _: T) {}

// consistent behavior, same on stable and nightly
fn f(x: One) {
    let y: Two = x;
    [y, x]; // fails (also on stable, no regression)
    same(y, x); // works
    [(y,), (x,)]; // works
    ["", &String::new()]; // works
    [&String::new(), ""]; // works, wait… how‽…
    [(x,), (y,)];  // fails… as expected, if it takes the
                   // type of the first element as “correct” (also on stable, no regression)
    same(x, y); // fails as expected (also on stable, no regression)
}

pub fn foo(_: &i32) {}
pub const _: [fn(&'static i32); 2] = [foo, foo]; // fails (also on stable, no regression)

#![allow(unused)]

type One = for<'a> fn(&'a (), &'a ());
type Two = for<'a, 'b> fn(&'a (), &'b ());

fn f(x: One) {
    let y: Two = x; // okay
    let arr = [x, x]; // okay
    let _: [Two; 2] = arr; // okay
    let _: [Two; 2] = [x, x]; // fails (regression)
    [y, x]; // fails (regression)
    [x, y]; // fails (regression)
    same(x, y); // okay
    [x, y as _]; // fails (regression)
}
fn same<T>(_: T, _: T) {}

    [(x,), (y,)]; // okay
    let x_: (One,) = (x,);
    let y_: (Two,) = (y,);
    [x_, y_]; // okay

fn f() {}
fn g() {}

fn main() {
    let x = [f, g];
}

fn same<T>(_: T, _: T) {}

fn f() {}
fn g() {}

fn main() {
    same(f, g); // fails (expected, no regression here!)
    match () {
        _ => f,
        _ => g, // works
    };
}

type One = for<'a> fn(&'a (), &'a ());
type Two = for<'a, 'b> fn(&'a (), &'b ());

fn f(x: One) {
    let y: Two = x;
    match 0 {
        _ => x,
        _ => y, // fails (regression)
    };
}