Regression in clone impl of enum with variant that has a field with a bivariant substitution

[compiler-errors]

I tried this code:

trait Array {
    type Item;
}

trait Platform {
    type Assoc: Array<Item = Self::Assoc2>;
    type Assoc2;
}

struct Message<A, B>
where
    A: Array<Item = B>,
{
    pub field: A,
}

impl<A, B> Clone for Message<A, B>
where
    A: Array<Item = B>,
{
    fn clone(&self) -> Self {
        todo!()
    }
}

fn clone<P: Platform>(x: &Message<P::Assoc, P::Assoc2>) {
    let x: Message<_, _> = Clone::clone(x);
}

I expected it to work.

Instead, this happened:

error[E0282]: type annotations needed
  --> src/lib.rs:31:32
   |
31 |     Enum::Variant(Clone::clone(x))
   |                                ^ cannot infer type for reference `&Message<<P as Platform>::Assoc, _>`

I regressed this in #129059. I have no idea yet why it's happening! This also could be minimized further, I think.

[compiler-errors]

Weirdly, this also only happens when the Clone::clone call is being directly passed to Enum::Variant. Is this due to Expectation, perhaps?

edit: yep, it has to do with the Expectation. Minimized the code a bit more.

[compiler-errors]

rust/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

Lines 299 to 305 in 79611d9

	// 3. Check if the formal type is a supertype of the checked one
	// and register any such obligations for future type checks
	let supertype_error = self.at(&self.misc(provided_arg.span), self.param_env).sup(
	DefineOpaqueTypes::Yes,
	formal_input_ty,
	coerced_ty,
	);

lol we're not actually constraining the target of the coercion properly

[compiler-errors]

Minimal:

trait Trait {
    type Item;
}

struct Struct<A: Trait<Item = B>, B> {
    pub field: A,
}

fn identity<T>(x: T) -> T {
    x
}

fn test<A: Trait<Item = B>, B>(x: &Struct<A, B>) {
    let x: &Struct<_, _> = identity(x);
}