object type unsoundness

pub trait Service<Req>: Send + Sync {
    type Response;
    type Error;
    // ...
}

trait AnyService<Req>: Send + Sync {
    type Response;
    type Error;
    // ...
}

impl<S, Req> AnyService<Req> for S
where
    S: Service<Req> + ?Sized,
{
    type Response = S::Response;
    type Error = S::Error;
    // ...
}

pub trait Builder: Debug + 'static {
	type Artifact : Debug + 'static;
	type DynState : Debug + 'static;
	type Err : Debug + 'static;
    // ... 
}

pub trait SimpleBuilder: Debug + 'static {
	type Artifact : Debug + 'static;
    // ... 
}

impl<B: ?Sized + SimpleBuilder> Builder for B {
	type Artifact = B::Artifact;
	type DynState = ();
	type Err = Never;
}

pub trait AccumObj {
    type Item;
}
impl<A: ?Sized + Accum> AccumObj for A {
    type Item = A::Item;
}
pub trait Accum {
    type Item;
    // ...
}

pub trait ElementQueryFn<T>: Send + Sync {
    type Fut: Future<Output = WebDriverResult<T>> + Send;
}

impl<T, Fut, Fun> ElementQueryFn<T> for Fun
where
    Fun: Fn(WebElement) -> Fut + Send + Sync + ?Sized,
    Fut: Future<Output = WebDriverResult<T>> + Send,
{
    type Fut = Fut;
}

pub trait Transmutter<U> {
    type Target;
}

impl<T: ?Sized, U> Transmutter<U> for T {
    type Target = U;
}

fn transmutter<T: ?Sized, U>(source: <T as Transmutter<U>>::Target) -> U {
    source
}

pub fn transmutte<T, U>(value: T) -> U {
    transmutter::<dyn Transmutter<U, Target = T>, U>(value)
}

trait Trait<T> {
    fn method(&self);
}
trait Erased<T> {
    type Assoc;
    fn erased(&self);
}
impl<T> Trait<T> for dyn Erased<T, Assoc = ()> {
    fn method(&self) {
        self.erased();
    }
}
impl<T, H: Trait<T> + ?Sized> Erased<T> for H {
    type Assoc = ();
    fn erased(&self) {
        self.method();
    }
}

fn break_me(hr: Box<dyn for<'a> Erased<&'a (), Assoc = ()>>) {
    // `hr` implements `for<'a> Erased<&'a ()>` via the builtin impl
    //
    // using the indirection via `dyn Erased<T>: Trait<T>` forces
    // `'a` to not be higher-ranked.
    hr.erased();
}