`Receiver` and `DispatchFromDyn` probably shouldn't be dyn-compatible?

[theemathas]

Currently, Receiver and DispatchFromDyn are dyn-compatible. This is a way to produce a type that implements those two traits without going through the "normal procedures" of making an impl. This is rather strange. Should we make them dyn-incompatible?

As far as I can tell, I can't cause ICEs or unsoundness with this. dyn Receiver seems to function "correctly", such as in the below code, which compiles and runs without errors:

#![feature(arbitrary_self_types)]

use std::ops::Receiver;

trait Trait {
    fn foo(self: &dyn Receiver<Target=Self>);
}

struct Thing;
impl Trait for Thing {
    fn foo(self: &dyn Receiver<Target=Self>) {
        println!("huh???");
    }
}

fn main() {
    let x = Box::new(Thing);
    let y: &dyn Receiver<Target=Thing> = &x;
    y.foo();
}

Meanwhile, my attempt to abuse dyn DispatchFromDyn merely caused a cycle error due to the type ouroboros required.

cc @dingxiangfei2009

Meta

Tested on the playground with version 1.93.0-nightly (2025-11-18 3d461af2a23456a2676a)

[Darksonn]

For Receiver it seems harmless. But DispatchFromDyn should probably have where Self: Sized.

[theemathas]

I don't think having Self: Sized is possible, since it needs to support trait upcasting.

Maybe it could use the attribute from #148637 instead.

[Darksonn]

I don't think DispatchFromDyn is involved in trait upcasting. Can you elaborate?

[theemathas]

@Darksonn When I implement DispatchFromDyn only for Sized types, I get a compiler error, so I assumed it was for trait upcasting. https://play.rust-lang.org/?version=nightly&mode=debug&edition=2024&gist=2f610ce76e21379f778b30269f1d373a

[Darksonn]

You shared this code:

// T: ?Sized makes this compile
impl<T, U: ?Sized> DispatchFromDyn<Ptr<U>> for Ptr<T>
where
    T: Unsize<U>,
{}

I agree that we need T: ?Sized for this code to make sense. But by Self: Sized I am referring to Ptr<T>, not T. The pointer type needs to be sized, even if the pointee does not.

[theemathas]

Ah right, I missed that. DispatchFromDyn probably should have Sized as a supertrait, then.

[theemathas]

CoerceUnsized is also currently dyn-compatible. And currently, the following code (with unsized_fn_params) causes an ICE:

#![feature(coerce_unsized, unsized_fn_params)]
#![expect(internal_features)]

use std::ops::CoerceUnsized;

pub trait Trait {}

pub fn foo(x: dyn CoerceUnsized<*const dyn Trait>) -> *const dyn Trait {
    x
}