Compiler Explorer

Source code

// An always applicable impl.
trait ProjectTo {
    type Usize;
    type This;
    type Myself;
}
impl<T> ProjectTo for T {
    type Usize = usize;
    type This = T;
    type Myself = T;
}

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

// We need to transfer the item bound to an existing type while only
// using the diverging associated type in a generic context.
//
// The idea is to use an indirection which uses the diverging associated type
// in a where-clause. This then uses its item-bound in the caller and normalizes
// via the applicable impl internally.
//
// `<T as Apply<D::Diverge<()>>::Assoc` for `D: Diverge` has
// an invalid item-bound and can be normalized to a concrete type while
// `D` is still generic.
trait Apply<D> {
    type Assoc: ProjectTo<Myself = usize>;
}
impl<T: ProjectTo<Myself = <D as ProjectTo>::Usize>, D> Apply<D> for T {
    type Assoc = T;
}

// It's still diffuclt to actually using this item bound as we must
// avoid `D::Diverge<()>` being mentioned in the MIR. We otherwise
// try to normalize it during codegen and error with overflow instead.
fn transmute<D: Diverges>(x: &usize) -> &&'static str {
    // We need to prove the where-bounds here while `D` is still generic
    // as they mention `D::Diverge<()>`.
    //
    // We normalize `<&'static str as Apply<D::Diverge<()>>>::Assoc` to `&'static str`
    // here. We therefore need to prove `&'static str: ProjectTo<This = &'static str>`
    // and `&'static str: Apply<D::Diverge<()>>`. Proving the second where-clause relies
    // on the item bound of `D::Diverge<()>`.
    provide_where_bound::<D, _>(x)
}

// `<T as ProjectTo>::This` normalizes to the rigid associated type
// `<T as Apply<D::Diverge<()>>>::Assoc` inside of this function.
fn provide_where_bound<D: Diverges, T>(x: &usize) -> &T
where
    T: ProjectTo<This = <T as Apply<D::Diverge<()>>>::Assoc>,
    T: Apply<D::Diverge<()>>,
{
    // We therefore prove `<T as Apply<D::Diverge<()>>>::Assoc: ProjectTo<Myself = usize>`
    // here. This holds thanks to the item-bound.
    apply_where_bound::<T>(x)
}

// `<T as ProjectTo>::This` normalizes to `T` inside of this function.
// THis means we've now get the incorret where-bound `T: ProjectTo<Myself = usize>`
// inside of this function. Exploiting this is trivial.
fn apply_where_bound<T>(x: &usize) -> &T
where
    <T as ProjectTo>::This: ProjectTo<Myself = usize>,
{
    via_impl::<T>(x)
}

fn via_impl<T>(x: &<T as ProjectTo>::Myself) -> &T {
    x
}

pub fn main() {
    println!("{}", transmute::<()>(&0));
}