Remove feature(dyn_compatible_for_dispatch) from the compiler

[compiler-errors]

This PR proposes the removal of feature(dyn_compatible_for_dispatch) from the compiler.

• As far as I can tell from the tracking issue, there's very little demand for this feature. I think that if this feature becomes useful in the future, then a fresh implementation from a fresh set of eyes, with renewed understanding of how this feature fits into the picture of Rust as it exists today would be great to have; however, in the absence of this demand, I don't see a particularly good reason to keep this implementation around.

• The RFC didn't receive very much discussion outside of the lang team, and while the discussion it received seemed to suggest that this feature was aiming to simplify the language and improve expressibility, I don't think this feature has really demonstrated either of those goals in practice. Furthermore, nobody seems to have owned this feature for quite some time or express desire to push for its stabilization.

• Relatedly, I find some of the RFC discussion like "when we make things impossible it's often presumptuous"¹ and "I tend to want to take a 'we are all adults here' attitude toward unsafe code"² to be particularly uncompelling. Of course this is no criticism to the authors of those comments since they're pretty old comments now, but type soundness is (IMO) the primary goal of the types team. This feature doesn't really do much other than further complicating the story of where we must validate object safety for soundness, along making dyn-incompatible trait object types almost seem useful, but very much remain UB to create and misleading to users who don't know better.

• Dyn compatibility's story has gotten more complicated since the feature was proposed in 2017, and now it needs to interact with things like associated consts, GATs, RPITITs, trait upcasting, dyn*, etc. While some of this is exercised in the codebase today, I'm not confident all of the corners of this feature have been hammered out. Reducing the "surface area" for what can go wrong in the compiler, especially around a side of the language (dyn Trait) that has been known to be particularly unsound in the past, seems good enough motivation to get rid of this for now.

cc @rust-lang/types @rust-lang/lang

Tracking:

• Tracking issue for tweaks to dyn compatibility (RFC 2027) #43561

r? types

Footnotes

1. https://github.com/rust-lang/rfcs/pull/2027#issuecomment-307592857 ↩

2. https://github.com/rust-lang/rfcs/pull/2027#issuecomment-307645838 ↩

[rustbot]

changes to the core type system

cc @compiler-errors, @lcnr

[compiler-errors]

I'm nominating this for T-types discussion just to see what people think. I've CC'd lang as well, though I think simply removing an implementation from the compiler falls under the responsibility of T-compiler and doesn't need lang team sign off.

[compiler-errors]

For the record, I don't think that this is even true. Even if dyn_compatible_for_dispatch was stabilized, if we used dyn Trait rather than a "placeholder" parameter here, we'd still have a query cycle if the DispatchFromDyn goal we register below needs to prove that dyn Trait: Trait.

[oli-obk]

stray stderr file (there's a few of them)

[nikomatsakis]

I'm happy to remove this logic. My recollection of the motivation for the RFC was that the desire was more to use traits as something module-like for ergonomics -- i.e., being able to say Display::some_helper_fn_related_to_display_where_the_self_type_is_not_important. I think that decision has not aged well given that today it would be be expanding to <dyn Display as HelperTrait>::some_helper... it seems odd. The RFC itself did not contain any kind of compelling example (only Foo/Bar) so I can't really remember the specific case in question (and I didn't see anything in the thread as I skimmed through).

I do want us to revisit our dyn-safety rules, I tend to disagree with "past me" and no longer believe that we should guarantee that Trait: Trait always, etc etc but that's a much broader discussion and goes beyond the scope of the RFC.

(I do agree with the sentiment expressed on the RFC thread that we should enable unsafe code, I think Rust's top goal is reliability, but the goal of "no limits" is also a core design axiom-- but I don't really think that's terribly relevant here.)

That said, I do feel a bit confused how RFC #2027 is related to this attribute exactly.

[traviscross]

As a minor procedural matter, we should probably leave the tracking issue itself open until and unless we de-RFC the underlying RFC 2027 or at least we lang FCP close the tracking issue. I've edited the PR description here so it won't auto-close upon merging this.

[oli-obk]

r=me with stray stderr files removed

[jackh726]

FWIW procedurally, if the RFC was opened today, there would be no way that I could see the types team not needing approve it before it would be accepted. So, for all intents and purposes, I think a types team FCP (here or on the tracking issue) should be enough to effectively unaccept the original RFC.

That being said, this PR could land without an FCP, since it's an unstable feature. If that were to be the case, I agree the tracking issue should stay open until one or both of lang and types does an FCP to unaccept the RFC.

[oli-obk]

Yea, we ripped out impls without FCPs before.

[lcnr]

seems like there's general consensus

r=me with stray stderr files removed

@rustbot author

[rustbot]

changes to the core type system

cc @compiler-errors, @lcnr

[compiler-errors]

@bors r=oli-obk rollup

[bors]

📌 Commit f3d31f7 has been approved by oli-obk

It is now in the queue for this repository.