Replace "dyn-compatible" with "dyn compatible"

See rust-lang#126554 (comment)

Author: cramertj

compiler/rustc_const_eval/src/interpret/call.rs

@@ -614,7 +614,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             // codegen'd / interpreted as virtual calls through the vtable.
             ty::InstanceKind::Virtual(def_id, idx) => {
                 let mut args = args.to_vec();
-                // We have to implement all "dyn-compatible receivers". So we have to go search for a
+                // We have to implement all "dyn compatible receivers". So we have to go search for a
                 // pointer or `dyn Trait` type, but it could be wrapped in newtypes. So recursively
                 // unwrap those newtypes until we are there.
                 // An `InPlace` does nothing here, we keep the original receiver intact. We can't

compiler/rustc_error_codes/src/error_codes/E0038.md

@@ -5,9 +5,9 @@ trait, written in type positions) but this was a bit too confusing, so we now
 write `dyn Trait`.
 
 Some traits are not allowed to be used as trait object types. The traits that
-are allowed to be used as trait object types are called "dyn-compatible"[^1]
+are allowed to be used as trait object types are called "dyn compatible"[^1]
 traits. Attempting to use a trait object type for a trait that is not
-dyn-compatible will trigger error E0038.
+dyn compatible will trigger error E0038.
 
 Two general aspects of trait object types give rise to the restrictions:
 
@@ -34,7 +34,7 @@ aspects.
 ### The trait requires `Self: Sized`
 
 Traits that are declared as `Trait: Sized` or which otherwise inherit a
-constraint of `Self:Sized` are not dyn-compatible.
+constraint of `Self:Sized` are not dyn compatible.
 
 The reasoning behind this is somewhat subtle. It derives from the fact that Rust
 requires (and defines) that every trait object type `dyn Trait` automatically
@@ -61,7 +61,7 @@ implement a sized trait like `Trait:Sized`. So, rather than allow an exception
 to the rule that `dyn Trait` always implements `Trait`, Rust chooses to prohibit
 such a `dyn Trait` from existing at all.
 
-Only unsized traits are considered dyn-compatible.
+Only unsized traits are considered dyn compatible.
 
 Generally, `Self: Sized` is used to indicate that the trait should not be used
 as a trait object. If the trait comes from your own crate, consider removing
@@ -106,7 +106,7 @@ fn call_foo(x: Box<dyn Trait>) {
 }
 ```
 
-If only some methods aren't dyn-compatible, you can add a `where Self: Sized`
+If only some methods aren't dyn compatible, you can add a `where Self: Sized`
 bound on them to mark them as explicitly unavailable to trait objects. The
 functionality will still be available to all other implementers, including
 `Box<dyn Trait>` which is itself sized (assuming you `impl Trait for Box<dyn
@@ -120,7 +120,7 @@ trait Trait {
 ```
 
 Now, `foo()` can no longer be called on a trait object, but you will now be
-allowed to make a trait object, and that will be able to call any dyn-compatible
+allowed to make a trait object, and that will be able to call any dyn compatible
 methods. With such a bound, one can still call `foo()` on types implementing
 that trait that aren't behind trait objects.
 
@@ -309,7 +309,7 @@ Here, the supertrait might have methods as follows:
 
 ```
 trait Super<A: ?Sized> {
-    fn get_a(&self) -> &A; // note that this is dyn-compatible!
+    fn get_a(&self) -> &A; // note that this is dyn compatible!
 }
 ```
 
@@ -318,8 +318,8 @@ If the trait `Trait` was deriving from something like `Super<String>` or
 `get_a()` will definitely return an object of that type.
 
 However, if it derives from `Super<Self>`, even though `Super` is
-dyn-compatible, the method `get_a()` would return an object of unknown type when
-called on the function. `Self` type parameters let us make dyn-compatible traits
+dyn compatible, the method `get_a()` would return an object of unknown type when
+called on the function. `Self` type parameters let us make dyn compatible traits
 no longer compatible, so they are forbidden when specifying supertraits.
 
 There's no easy fix for this. Generally, code will need to be refactored so that

compiler/rustc_error_codes/src/error_codes/E0802.md

@@ -1,4 +1,4 @@
-The `Async{Fn, FnMut, FnOnce}` traits are not yet `dyn`-compatible.
+The `Async{Fn, FnMut, FnOnce}` traits are not yet dyn compatible.
 
 Erroneous code example:
 

compiler/rustc_error_codes/src/lib.rs

@@ -625,7 +625,7 @@ E0802: 0802,
 //  E0314, // closure outlives stack frame
 //  E0315, // cannot invoke closure outside of its lifetime
 //  E0319, // trait impls for defaulted traits allowed just for structs/enums
-//  E0372, // coherence not dyn-compatible
+//  E0372, // coherence not dyn compatible
 //  E0385, // {} in an aliasable location
 //  E0402, // cannot use an outer type parameter in this context
 //  E0406, // merged into 420

compiler/rustc_feature/src/removed.rs

@@ -159,7 +159,7 @@ declare_features! (
     /// then removed. But there was no utility storing it separately, so now
     /// it's in this list.
     (removed, no_stack_check, "1.0.0", None, None),
-    /// Allows making `dyn Trait` well-formed even if `Trait` is not dyn-compatible (object safe).
+    /// Allows making `dyn Trait` well-formed even if `Trait` is not dyn compatible (object safe).
     /// Renamed to `dyn_compatible_for_dispatch`.
     (removed, object_safe_for_dispatch, "1.83.0", Some(43561),
      Some("renamed to `dyn_compatible_for_dispatch`")),

compiler/rustc_feature/src/unstable.rs

@@ -269,7 +269,7 @@ declare_features! (
     (unstable, doc_notable_trait, "1.52.0", Some(45040)),
     /// Allows using the `may_dangle` attribute (RFC 1327).
     (unstable, dropck_eyepatch, "1.10.0", Some(34761)),
-    /// Allows making `dyn Trait` well-formed even if `Trait` is not dyn-compatible[^1].
+    /// Allows making `dyn Trait` well-formed even if `Trait` is not dyn compatible[^1].
     /// In that case, `dyn Trait: Trait` does not hold. Moreover, coercions and
     /// casts in safe Rust to `dyn Trait` for such a `Trait` is also forbidden.
     ///

compiler/rustc_hir_analysis/src/coherence/mod.rs

@@ -184,7 +184,7 @@ fn check_object_overlap<'tcx>(
     // check for overlap with the automatic `impl Trait for dyn Trait`
     if let ty::Dynamic(data, ..) = trait_ref.self_ty().kind() {
         // This is something like `impl Trait1 for Trait2`. Illegal if
-        // Trait1 is a supertrait of Trait2 or Trait2 is not dyn-compatible.
+        // Trait1 is a supertrait of Trait2 or Trait2 is not dyn compatible.
 
         let component_def_ids = data.iter().flat_map(|predicate| {
             match predicate.skip_binder() {

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -116,7 +116,7 @@ pub(crate) fn orphan_check_impl(
         // We can allow f to be called on `dyn DynCompatibleTrait + AutoTrait`.
         //
         // If we didn't deny `impl AutoTrait for dyn Trait`, it would be unsound
-        // for the `DynCompatibleTrait` shown above to be dyn-compatible because someone
+        // for the `DynCompatibleTrait` shown above to be dyn compatible because someone
         // could take some type implementing `DynCompatibleTrait` but not `AutoTrait`,
         // unsize it to `dyn DynCompatibleTrait`, and call `.f()` which has no
         // concrete implementation (issue #50781).

compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs

@@ -80,7 +80,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             if self_ty.span.can_be_used_for_suggestions()
                 && !self.maybe_suggest_impl_trait(self_ty, &mut diag)
             {
-                // FIXME: Only emit this suggestion if the trait is dyn-compatible.
+                // FIXME: Only emit this suggestion if the trait is dyn compatible.
                 diag.multipart_suggestion_verbose(label, sugg, Applicability::MachineApplicable);
             }
             // Check if the impl trait that we are considering is an impl of a local trait.
@@ -102,7 +102,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 lint.primary_message("trait objects without an explicit `dyn` are deprecated");
                 if self_ty.span.can_be_used_for_suggestions() {
                     lint.multipart_suggestion_verbose(
-                        "if this is a dyn-compatible trait, use `dyn`",
+                        "if this is a dyn compatible trait, use `dyn`",
                         sugg,
                         Applicability::MachineApplicable,
                     );

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -771,7 +771,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // give us a `QPath::TypeRelative` with a trait object as
                 // `qself`. In that case, we want to avoid registering a WF obligation
                 // for `dyn MyTrait`, since we don't actually need the trait
-                // to be dyn-compatible.
+                // to be dyn compatible.
                 // We manually call `register_wf_obligation` in the success path
                 // below.
                 let ty = self.lowerer().lower_ty(qself);