ICE with higher order associated types about rust HOT 4 OPEN

pub fn into_vec<'inner>(dummy: impl FromRow<'inner>) {
    let _f = dummy.prepare();
}

pub fn test() {
    into_vec(Assume(Some("test")));
}

pub trait FromRow<'t> {
    type Out<'a>;
    fn prepare(self) -> impl for<'a> FnMut(&'a ()) -> Self::Out<'a>;
}

impl<'t, T: Value<'t>> FromRow<'t> for T
where
    <T as Value<'t>>::Typ: MyTyp,
{
    type Out<'a> = <T::Typ as MyTyp>::Out<'a>;

    fn prepare(self) -> impl for<'a> FnMut(&'a ()) -> Self::Out<'a> {
        move |_| loop {}
    }
}

pub struct Assume<A>(pub(crate) A);

impl<'t, T, A: Value<'t, Typ = Option<T>>> Value<'t> for Assume<A> {
    type Typ = T;
}

pub trait Value<'t> {
    type Typ;
}

impl<'t> Value<'t> for &str {
    type Typ = String;
}

impl<'t, T: Value<'t, Typ = X>, X: MyTyp> Value<'t> for Option<T> {
    type Typ = Option<T::Typ>;
}

pub trait MyTyp: 'static {
    type Out<'t>;
}

impl MyTyp for String {
    type Out<'t> = Self;
}

fn into_vec(dummy: impl FromRow) {
    let _f = dummy.prepare();
}

pub fn test() {
    into_vec(Assume(()));
}

trait FromRow {
    type Out<'a>;
    fn prepare(self) -> impl for<'a> FnMut(&'a ()) -> Self::Out<'a>;
}

impl<T: Value<Typ: MyTyp>> FromRow for T {
    type Out<'a> = <T::Typ as MyTyp>::Out<'a>;
    fn prepare(self) -> impl for<'a> FnMut(&'a ()) -> Self::Out<'a> {
        |_| loop {}
    }
}

struct Assume<A>(A);

impl<T, A: Value<Typ = T>> Value for Assume<A> {
    type Typ = T;
}

trait Value {
    type Typ;
}

impl Value for () {
    type Typ = ();
}

trait MyTyp {
    type Out<'t>;
}

impl MyTyp for () {
    type Out<'t> = ();
}

pub struct Wrapper<T>(T);
struct Struct;

pub trait TraitA {
    // NEEDS TO BE GAT
    type AssocA<'t>;
}
pub trait TraitB {
    type AssocB;
}

pub fn helper(v: impl MethodTrait) {
    // monomorphization instantiates something it then normalizes to:
    //
    // Closure(
    //   DefId(0:27 ~ unnamed_1[00e7]::{impl#0}::method::{closure#0}),
    //   [
    //     Wrapper1<StructX>,
    //     i16,
    //     Binder {
    //       value: extern "RustCall" fn((&'^0 (),)) -> Alias(Projection, AliasTy { args: [StructX, '^0], def_id: DefId(0:10 ~ unnamed_1[00e7]::TraitA::AssocA), .. }),
    //       bound_vars: [Region(BrAnon)]
    //     },
    //     ()
    //   ]
    // ),
    //
    // This should be completely normalized but isn't.
    // so, normalizing again gives (StructX is inserted) for
    // Alias(Projection, AliasTy { args: [StructX, '^0], def_id: DefId(0:10 ~ unnamed_1[00e7]::TraitA::AssocA), .. })
    //
    // Closure(
    //   DefId(0:27 ~ unnamed_1[00e7]::{impl#0}::method::{closure#0}),
    //   [
    //     Wrapper1<StructX>,
    //     i16,
    //     Binder {
    //       value: extern "RustCall" fn((&'^0 (),)) -> StructX, bound_vars: [Region(BrAnon)]
    //     },
    //     ()
    //   ]
    // ).
    let _local_that_causes_ice = v.method();
}

pub fn main() {
    helper(Wrapper(Struct));
}

pub trait MethodTrait {
    type Assoc<'a>;

    fn method(self) -> impl for<'a> FnMut(&'a ()) -> Self::Assoc<'a>;
}

impl<T: TraitB> MethodTrait for T
where
    <T as TraitB>::AssocB: TraitA,
{
    type Assoc<'a> = <T::AssocB as TraitA>::AssocA<'a>;

    // must be a method (through Self), the example below doesn't work (as a standalone function)
    // fn helper2<M: MethodTrait>(_v: M) -> impl for<'a> FnMut(&'a ()) -> M::Assoc<'a> {
    //    move |_| loop {}
    // }
    fn method(self) -> impl for<'a> FnMut(&'a ()) -> Self::Assoc<'a> {
        move |_| loop {}
    }
}

impl<T, B> TraitB for Wrapper<B>
where
    B: TraitB<AssocB = T>,
{
    type AssocB = T;
}

impl TraitB for Struct {
    type AssocB = Struct;
}

impl TraitA for Struct {
    type AssocA<'t> = Self;
}