Compiler Explorer

Source code

// Always applicable impls. Using two separate traits
// for clarity/simplicity.
trait IdA {
    type This;
}
impl<T> IdA for T {
    type This = T;
}
trait IdB {
    type This;
}
impl<T> IdB for T {
    type This = T;
}
trait Trivial {
    type Usize;
}
impl<T> Trivial for T {
    type Usize = usize;
}

// A diverging associated type whose item-bound must not apply
// and differs from an always applicable impl.
trait Diverges<T> {
    type Diverge<Recur: Diverges<T>>: Trivial<Usize = T>;
}
impl<T> Diverges<T> for () {
    type Diverge<Recur: Diverges<T>> = Recur::Diverge<()>;
}

// An impl with a where-clause which is normalized using the blanket impl when
// checking that its item-bounds hold. We then prove that where-clause via the
// incorrect item-bound from above.
//
// This allows us to transfer the item-bound to a concrete type while only
// using the diverging associated type in a generic context.
//
// Concretely, this is impl is well-formed as `<T as IdA>::This` normalizes to
// `<Recur as Trivial>::Usize` which is then normalized to `usize` by using
// the blanket impl. This means `<T as IdA>::This: IdB<This: Copy>` trivially
// holds.
//
// This means it should only be possible to instantiate it with `usize` itself.
// Instantiating `Recur` with `<D as Diverges<T>>::Diverge<()>` causes it to apply
// for all `T` instead.
trait Apply<D> {
    type Assoc: IdB<This: Copy>;
}
impl<T: IdA<This = <Recur as Trivial>::Usize>, Recur> Apply<Recur> for T {
    type Assoc = <T as IdA>::This;
}

fn copy_me<T, D: Diverges<T>>(x: T) {
    // Need to prove the where-bounds of `provide_where_bound` in a generic context
    // as normalizing `D::Diverge<()>` would otherwise overflow.
    //
    // Using the impl of `Apply` requires `T: IdA<This = <D::Diverge<()> as Trivial>::Usize>`.
    // We normalize `<D::Diverge<()> as Trivial>::Usize` to `T` using the item-bound of
    // `D::Diverge<()>` at which point the impl trivially applies.
    provide_where_bound::<D, T>(x)
}

fn provide_where_bound<D: Diverges<T>, T>(x: T)
where
    T: IdA<This = <T as Apply<D::Diverge<()>>>::Assoc>,
    T: Apply<D::Diverge<()>>,
{
    // Inside of this function `<T as Apply<D::Diverge<()>>>::Assoc` is rigid,
    // allowing us to use its incorrect item-bound.
    //
    // <<T as IdA>::This as IdB>::This: Copy
    // ------------------------------------- normalize `<T as IdA>::This` via where-bound
    // <<T as Apply<D::Diverge<()>>>::Assoc as IdB>::This: Copy
    // -------------------------------------------------------- prove via item-bound
    apply_where_bound::<T>(x)
}

fn apply_where_bound<T>(x: T)
where
    <<T as IdA>::This as IdB>::This: Copy,
{
    // We simply normalize `<<T as IdA>::This as IdB>::This` to `T` inside of this
    // function.
    dup(x, x)
}

fn dup<T>(_x: T, _y: T) {}

pub fn main() {
    copy_me::<String, ()>(String::from("hello there"));
}