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

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.

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.

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

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);
}

Auto merge of rust-lang#129317 - compiler-errors:expectation-subtypin…

Navigation Menu

Repository navigation

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

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

	// 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,
	);

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

Description

Activity

compiler-errors commented on Aug 20, 2024

compiler-errors commented on Aug 20, 2024

compiler-errors commented on Aug 20, 2024

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions