Compiler Explorer

Source code

#![allow(dead_code, unused_variables)]

trait Foo<T> {
    type X: Clone;
}

// Note: `: Clone` *is* required here
impl<T: Clone> Foo<T> for () {
    type X = T;
}

// `: Clone` is *not* required here in 1.49+
trait Bar<T: Clone>: Foo<T, X = T> {
    type X: Clone;
}

impl<T: Clone, U: Foo<T, X = T>> Bar<T> for U {
    type X = <Self as Foo<T>>::X;
}

// In 1.49+ these functions *don't* need `A: Clone` in order to have `Witness: Foo<_, X = A>`
// but are unable to rely on `A: Clone` within the function body (yet callees must prove this)
//
// In 1.48 and below `A: Clone` is required.
fn example1<A, Witness: Foo<A, X = A>>(a: &A) -> A {
    // a.clone() // errors
    loop {}
}

fn example2<A, Witness: Foo<A, X = A>>(a: &<Witness as Foo<A>>::X) -> A {
    // a.clone() // errors
    loop {}
}

fn example3<A, Witness: Foo<A, X = A>>(a: &<Witness as Foo<A>>::X) -> <Witness as Foo<A>>::X {
    // a.clone() // errors
    loop {}
}

// same as above but dropping the associated type bound:
fn example4<A, Witness: Foo<A>>(a: &<Witness as Foo<A>>::X) -> <Witness as Foo<A>>::X {
    a.clone()
}

struct NotClone;

// is the concrete type we specify for the associated type checked at all?
fn example5<W: Foo<NotClone, X = NotClone>>() { }
// it seems not! (in 1.49 and up; in 1.48 and below this does error)

fn main() {
    println!("Hello, world!");
    
    // All of these fail to compile as you'd expect, showing that `A`
    // effectively does have a `: Clone` bound.
    // example1::<NotClone, ()>;
    // example2::<NotClone, ()>;
    // example3::<NotClone, ()>;
    example4::<NotClone, ()>;

// let _ = example4::<String, ()>;
}