From 20cebae31203a9781f99081b075abe0dc2504a98 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 9 Oct 2024 23:31:01 +0200
Subject: [PATCH] UI tests: Rename "object safe" to "dyn compatible"

---
 src/tools/tidy/src/issues.txt                 |  4 --
 tests/ui/allocator/dyn-compatible.rs          | 13 ++++
 tests/ui/allocator/object-safe.rs             | 13 ----
 ....rs => entails-sized-dyn-compatibility.rs} | 12 ++--
 ...{object-safety.rs => dyn-compatibility.rs} |  0
 ...safety.stderr => dyn-compatibility.stderr} |  4 +-
 ...ce-impl-trait-for-trait-dyn-compatible.rs} |  6 +-
 ...impl-trait-for-trait-dyn-compatible.stderr | 27 +++++++
 ...ce-impl-trait-for-trait-object-safe.stderr | 27 -------
 ...rs => const_param_ty_dyn_compatibility.rs} |  0
 ...> const_param_ty_dyn_compatibility.stderr} |  4 +-
 ...rr-ret.rs => dyn-compatibility-err-ret.rs} |  0
 ...tderr => dyn-compatibility-err-ret.stderr} |  8 +--
 ... => dyn-compatibility-err-where-bounds.rs} |  0
 ...dyn-compatibility-err-where-bounds.stderr} |  8 +--
 ...r.rs => dyn-compatibility-ok-infer-err.rs} |  0
 ... => dyn-compatibility-ok-infer-err.stderr} |  8 +--
 ...t-safety-ok.rs => dyn-compatibility-ok.rs} |  0
 .../almost-supertrait-associated-type.rs      |  2 +-
 .../almost-supertrait-associated-type.stderr  |  0
 .../assoc_const_bounds.rs                     |  0
 .../assoc_const_bounds_sized.rs               |  0
 .../assoc_type_bounds.rs                      |  0
 .../assoc_type_bounds.stderr                  |  0
 .../assoc_type_bounds2.rs                     |  0
 .../assoc_type_bounds2.stderr                 |  0
 .../assoc_type_bounds_implicit_sized.fixed    |  0
 .../assoc_type_bounds_implicit_sized.rs       |  0
 .../assoc_type_bounds_implicit_sized.stderr   |  0
 .../assoc_type_bounds_sized.rs                |  0
 .../assoc_type_bounds_sized_others.rs         |  0
 .../assoc_type_bounds_sized_others.stderr     |  0
 .../assoc_type_bounds_sized_unnecessary.rs    |  0
 ...assoc_type_bounds_sized_unnecessary.stderr |  0
 .../assoc_type_bounds_sized_used.rs           |  0
 .../assoc_type_bounds_sized_used.stderr       |  0
 .../associated-consts.curr.stderr}            |  8 +--
 ...consts.dyn_compatible_for_dispatch.stderr} |  4 +-
 .../associated-consts.rs}                     |  0
 .../avoid-ice-on-warning-2.new.stderr         |  0
 .../avoid-ice-on-warning-2.old.stderr         |  0
 .../avoid-ice-on-warning-2.rs                 |  0
 .../avoid-ice-on-warning-3.new.stderr         |  0
 .../avoid-ice-on-warning-3.old.stderr         |  0
 .../avoid-ice-on-warning-3.rs                 |  0
 .../avoid-ice-on-warning.new.stderr           |  0
 .../avoid-ice-on-warning.old.stderr           |  0
 .../avoid-ice-on-warning.rs                   |  0
 .../bare-trait-dont-suggest-dyn.new.fixed     |  0
 .../bare-trait-dont-suggest-dyn.new.stderr    |  0
 .../bare-trait-dont-suggest-dyn.old.stderr    |  0
 .../bare-trait-dont-suggest-dyn.rs            |  0
 .../bounds.rs}                                |  2 +-
 .../bounds.stderr}                            |  4 +-
 .../by-value-self-use.rs}                     |  2 +-
 .../by-value-self-use.stderr}                 |  2 +-
 .../by-value-self.rs}                         |  2 +-
 .../call-when-assoc-ty-is-sized.rs            |  0
 .../elaborated-predicates-ordering.rs}        |  1 +
 .../erroneous_signature.rs                    |  0
 .../erroneous_signature.stderr                |  0
 .../generics.curr.stderr}                     | 20 +++---
 ...nerics.dyn_compatible_for_dispatch.stderr} |  8 +--
 .../generics.rs}                              |  0
 ...s-multiple_supertrait_upcastable-check.rs} |  1 +
 .../item-bounds-can-reference-self.rs         |  0
 ...mention-correct-dyn-incompatible-trait.rs} |  2 +
 ...ion-correct-dyn-incompatible-trait.stderr} |  8 +--
 .../mentions-Self-in-super-predicates.rs}     |  0
 .../mentions-Self-in-super-predicates.stderr} | 12 ++--
 .../mentions-Self.curr.stderr}                | 16 ++---
 ...s-Self.dyn_compatible_for_dispatch.stderr} |  8 +--
 .../mentions-Self.rs}                         |  0
 .../missing-assoc-type.rs}                    |  0
 .../missing-assoc-type.stderr}                | 16 ++---
 .../no-static.curr.stderr}                    | 12 ++--
 ...static.dyn_compatible_for_dispatch.stderr} |  4 +-
 .../no-static.rs}                             |  0
 .../phantom-fn.rs}                            |  2 +-
 ...t-in-fn-inputs-and-outputs-issue-125139.rs |  0
 ...-fn-inputs-and-outputs-issue-125139.stderr |  0
 .../sized-2.curr.stderr}                      |  8 +--
 ...ized-2.dyn_compatible_for_dispatch.stderr} |  4 +-
 .../sized-2.rs}                               |  0
 .../sized.curr.stderr}                        |  8 +--
 .../sized.dyn_compatible_for_dispatch.stderr} |  4 +-
 .../sized.rs}                                 |  0
 .../supertrait-mentions-GAT.rs}               |  0
 .../supertrait-mentions-GAT.stderr}           |  8 +--
 .../supertrait-mentions-Self.rs}              |  0
 .../supertrait-mentions-Self.stderr}          |  8 +--
 ...chable-receiver-and-wc-references-Self.rs} |  5 +-
 ...le-receiver-and-wc-references-Self.stderr} | 12 ++--
 ...ure-gate-dispatch-from-dyn-missing-impl.rs |  2 +-
 ...eature-gate-dyn_compatible_for_dispatch.rs |  8 +--
 ...re-gate-dyn_compatible_for_dispatch.stderr | 24 +++----
 .../generic-associated-types/trait-objects.rs |  2 +-
 ...ble-trait-in-return-position-dyn-trait.rs} | 11 +--
 ...trait-in-return-position-dyn-trait.stderr} | 72 +++++++++----------
 ...le-trait-in-return-position-impl-trait.rs} | 16 ++---
 ...rait-in-return-position-impl-trait.stderr} | 12 ++--
 ...ilities-during-dyn-compatibility-check.rs} |  0
 ...ies-during-dyn-compatibility-check.stderr} | 16 ++---
 ...ty-sized.rs => dyn-compatibility-sized.rs} |  0
 ...{object-safety.rs => dyn-compatibility.rs} |  0
 ...safety.stderr => dyn-compatibility.stderr} | 16 ++---
 tests/ui/issues/issue-58734.rs                |  8 +--
 .../downcast-unsafe-trait-objects.rs          |  2 +-
 .../manual-self-impl-for-unsafe-obj.rs        |  2 +-
 tests/ui/sanitizer/cfi/async-closures.rs      |  2 +-
 ...y-self-types-dyn-incompatible.curr.stderr} |  8 +--
 ...atible.dyn_compatible_for_dispatch.stderr} |  4 +-
 ... arbitrary-self-types-dyn-incompatible.rs} |  0
 ...itrary_self_types_pointers_and_wrappers.rs |  6 +-
 ...compatibility-sized-self-by-value-self.rs} |  2 +-
 ...ompatibility-sized-self-generic-method.rs} |  2 +-
 ...n-compatibility-sized-self-return-Self.rs} |  2 +-
 tests/ui/specialization/issue-44861.rs        |  8 +--
 ...not-object-safe.rs => dyn-incompatible.rs} |  0
 ...dyn-incompatible-trait-references-self.rs} |  0
 ...incompatible-trait-references-self.stderr} | 14 ++--
 ...trait-should-use-self-2021-without-dyn.rs} |  0
 ...t-should-use-self-2021-without-dyn.stderr} | 30 ++++----
 ...ncompatible-trait-should-use-self-2021.rs} |  0
 ...patible-trait-should-use-self-2021.stderr} | 12 ++--
 ...dyn-incompatible-trait-should-use-self.rs} |  0
 ...incompatible-trait-should-use-self.stderr} | 12 ++--
 ...atible-trait-should-use-where-sized.fixed} |  0
 ...ompatible-trait-should-use-where-sized.rs} |  0
 ...tible-trait-should-use-where-sized.stderr} |  6 +-
 tests/ui/suggestions/issue-98500.rs           |  6 +-
 tests/ui/suggestions/issue-98500.stderr       |  2 +-
 tests/ui/traits/alias/no-duplicates.rs        |  4 +-
 tests/ui/traits/alias/no-extra-traits.rs      |  2 +-
 tests/ui/traits/alias/object-wf.rs            |  4 +-
 ...ect-unsafety.rs => dyn-incompatibility.rs} |  0
 ...fety.stderr => dyn-incompatibility.stderr} | 10 +--
 ...ety.rs => supertrait-dyn-compatibility.rs} |  0
 ...rr => supertrait-dyn-compatibility.stderr} | 14 ++--
 tests/ui/traits/object/print_vtable_sizes.rs  |  2 +-
 tests/ui/traits/object/safety.rs              |  2 +-
 ...ect-safe.rs => vtable-dyn-incompatible.rs} |  2 +-
 ....stderr => vtable-dyn-incompatible.stderr} |  2 +-
 tests/ui/traits/wf-object/no-duplicates.rs    |  4 +-
 tests/ui/traits/wf-object/reverse-order.rs    |  2 +-
 ...by-value-trait-dyn-compatibility-rpass.rs} |  0
 ...e-trait-dyn-compatibility-with-default.rs} |  0
 ...rs => by-value-trait-dyn-compatibility.rs} |  0
 ...> by-value-trait-dyn-compatibility.stderr} |  4 +-
 ... wf-convert-dyn-incompat-trait-obj-box.rs} |  2 +-
 ...convert-dyn-incompat-trait-obj-box.stderr} | 12 ++--
 ...s => wf-convert-dyn-incompat-trait-obj.rs} |  2 +-
 ... wf-convert-dyn-incompat-trait-obj.stderr} | 12 ++--
 ....rs => wf-dyn-incompat-trait-obj-match.rs} |  0
 ...=> wf-dyn-incompat-trait-obj-match.stderr} | 10 +--
 ...-object-safe.rs => wf-dyn-incompatible.rs} |  2 +-
 ...safe.stderr => wf-dyn-incompatible.stderr} |  4 +-
 157 files changed, 366 insertions(+), 364 deletions(-)
 create mode 100644 tests/ui/allocator/dyn-compatible.rs
 delete mode 100644 tests/ui/allocator/object-safe.rs
 rename tests/ui/associated-type-bounds/{entails-sized-object-safety.rs => entails-sized-dyn-compatibility.rs} (67%)
 rename tests/ui/async-await/in-trait/{object-safety.rs => dyn-compatibility.rs} (100%)
 rename tests/ui/async-await/in-trait/{object-safety.stderr => dyn-compatibility.stderr} (90%)
 rename tests/ui/coherence/{coherence-impl-trait-for-trait-object-safe.rs => coherence-impl-trait-for-trait-dyn-compatible.rs} (54%)
 create mode 100644 tests/ui/coherence/coherence-impl-trait-for-trait-dyn-compatible.stderr
 delete mode 100644 tests/ui/coherence/coherence-impl-trait-for-trait-object-safe.stderr
 rename tests/ui/const-generics/adt_const_params/{const_param_ty_object_safety.rs => const_param_ty_dyn_compatibility.rs} (100%)
 rename tests/ui/const-generics/adt_const_params/{const_param_ty_object_safety.stderr => const_param_ty_dyn_compatibility.stderr} (93%)
 rename tests/ui/const-generics/generic_const_exprs/{object-safety-err-ret.rs => dyn-compatibility-err-ret.rs} (100%)
 rename tests/ui/const-generics/generic_const_exprs/{object-safety-err-ret.stderr => dyn-compatibility-err-ret.stderr} (91%)
 rename tests/ui/const-generics/generic_const_exprs/{object-safety-err-where-bounds.rs => dyn-compatibility-err-where-bounds.rs} (100%)
 rename tests/ui/const-generics/generic_const_exprs/{object-safety-err-where-bounds.stderr => dyn-compatibility-err-where-bounds.stderr} (88%)
 rename tests/ui/const-generics/generic_const_exprs/{object-safety-ok-infer-err.rs => dyn-compatibility-ok-infer-err.rs} (100%)
 rename tests/ui/const-generics/generic_const_exprs/{object-safety-ok-infer-err.stderr => dyn-compatibility-ok-infer-err.stderr} (85%)
 rename tests/ui/const-generics/generic_const_exprs/{object-safety-ok.rs => dyn-compatibility-ok.rs} (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/almost-supertrait-associated-type.rs (95%)
 rename tests/ui/{object-safety => dyn-compatibility}/almost-supertrait-associated-type.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_const_bounds.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_const_bounds_sized.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds2.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds2.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_implicit_sized.fixed (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_implicit_sized.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_implicit_sized.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_sized.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_sized_others.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_sized_others.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_sized_unnecessary.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_sized_unnecessary.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_sized_used.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/assoc_type_bounds_sized_used.stderr (100%)
 rename tests/ui/{object-safety/object-safety-associated-consts.curr.stderr => dyn-compatibility/associated-consts.curr.stderr} (86%)
 rename tests/ui/{object-safety/object-safety-associated-consts.dyn_compatible_for_dispatch.stderr => dyn-compatibility/associated-consts.dyn_compatible_for_dispatch.stderr} (87%)
 rename tests/ui/{object-safety/object-safety-associated-consts.rs => dyn-compatibility/associated-consts.rs} (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning-2.new.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning-2.old.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning-2.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning-3.new.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning-3.old.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning-3.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning.new.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning.old.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/avoid-ice-on-warning.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/bare-trait-dont-suggest-dyn.new.fixed (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/bare-trait-dont-suggest-dyn.new.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/bare-trait-dont-suggest-dyn.old.stderr (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/bare-trait-dont-suggest-dyn.rs (100%)
 rename tests/ui/{object-safety/object-safety-bounds.rs => dyn-compatibility/bounds.rs} (72%)
 rename tests/ui/{object-safety/object-safety-bounds.stderr => dyn-compatibility/bounds.stderr} (89%)
 rename tests/ui/{object-safety/object-safety-by-value-self-use.rs => dyn-compatibility/by-value-self-use.rs} (79%)
 rename tests/ui/{object-safety/object-safety-by-value-self-use.stderr => dyn-compatibility/by-value-self-use.stderr} (83%)
 rename tests/ui/{object-safety/object-safety-by-value-self.rs => dyn-compatibility/by-value-self.rs} (90%)
 rename tests/ui/{object-safety => dyn-compatibility}/call-when-assoc-ty-is-sized.rs (100%)
 rename tests/ui/{object-safety/issue-102933.rs => dyn-compatibility/elaborated-predicates-ordering.rs} (93%)
 rename tests/ui/{object-safety => dyn-compatibility}/erroneous_signature.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/erroneous_signature.stderr (100%)
 rename tests/ui/{object-safety/object-safety-generics.curr.stderr => dyn-compatibility/generics.curr.stderr} (88%)
 rename tests/ui/{object-safety/object-safety-generics.dyn_compatible_for_dispatch.stderr => dyn-compatibility/generics.dyn_compatible_for_dispatch.stderr} (89%)
 rename tests/ui/{object-safety/object-safety-generics.rs => dyn-compatibility/generics.rs} (100%)
 rename tests/ui/{object-safety/issue-106247.rs => dyn-compatibility/impossible-predicates-multiple_supertrait_upcastable-check.rs} (73%)
 rename tests/ui/{object-safety => dyn-compatibility}/item-bounds-can-reference-self.rs (100%)
 rename tests/ui/{object-safety/issue-19538.rs => dyn-compatibility/mention-correct-dyn-incompatible-trait.rs} (90%)
 rename tests/ui/{object-safety/issue-19538.stderr => dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr} (87%)
 rename tests/ui/{object-safety/object-safety-issue-22040.rs => dyn-compatibility/mentions-Self-in-super-predicates.rs} (100%)
 rename tests/ui/{object-safety/object-safety-issue-22040.stderr => dyn-compatibility/mentions-Self-in-super-predicates.stderr} (87%)
 rename tests/ui/{object-safety/object-safety-mentions-Self.curr.stderr => dyn-compatibility/mentions-Self.curr.stderr} (88%)
 rename tests/ui/{object-safety/object-safety-mentions-Self.dyn_compatible_for_dispatch.stderr => dyn-compatibility/mentions-Self.dyn_compatible_for_dispatch.stderr} (88%)
 rename tests/ui/{object-safety/object-safety-mentions-Self.rs => dyn-compatibility/mentions-Self.rs} (100%)
 rename tests/ui/{traits/object/object-unsafe-missing-assoc-type.rs => dyn-compatibility/missing-assoc-type.rs} (100%)
 rename tests/ui/{traits/object/object-unsafe-missing-assoc-type.stderr => dyn-compatibility/missing-assoc-type.stderr} (86%)
 rename tests/ui/{object-safety/object-safety-no-static.curr.stderr => dyn-compatibility/no-static.curr.stderr} (92%)
 rename tests/ui/{object-safety/object-safety-no-static.dyn_compatible_for_dispatch.stderr => dyn-compatibility/no-static.dyn_compatible_for_dispatch.stderr} (93%)
 rename tests/ui/{object-safety/object-safety-no-static.rs => dyn-compatibility/no-static.rs} (100%)
 rename tests/ui/{object-safety/object-safety-phantom-fn.rs => dyn-compatibility/phantom-fn.rs} (92%)
 rename tests/ui/{object-safety => dyn-compatibility}/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs (100%)
 rename tests/ui/{object-safety => dyn-compatibility}/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.stderr (100%)
 rename tests/ui/{object-safety/object-safety-sized-2.curr.stderr => dyn-compatibility/sized-2.curr.stderr} (88%)
 rename tests/ui/{object-safety/object-safety-sized-2.dyn_compatible_for_dispatch.stderr => dyn-compatibility/sized-2.dyn_compatible_for_dispatch.stderr} (89%)
 rename tests/ui/{object-safety/object-safety-sized-2.rs => dyn-compatibility/sized-2.rs} (100%)
 rename tests/ui/{object-safety/object-safety-sized.curr.stderr => dyn-compatibility/sized.curr.stderr} (88%)
 rename tests/ui/{object-safety/object-safety-sized.dyn_compatible_for_dispatch.stderr => dyn-compatibility/sized.dyn_compatible_for_dispatch.stderr} (89%)
 rename tests/ui/{object-safety/object-safety-sized.rs => dyn-compatibility/sized.rs} (100%)
 rename tests/ui/{object-safety/object-safety-supertrait-mentions-GAT.rs => dyn-compatibility/supertrait-mentions-GAT.rs} (100%)
 rename tests/ui/{object-safety/object-safety-supertrait-mentions-GAT.stderr => dyn-compatibility/supertrait-mentions-GAT.stderr} (86%)
 rename tests/ui/{object-safety/object-safety-supertrait-mentions-Self.rs => dyn-compatibility/supertrait-mentions-Self.rs} (100%)
 rename tests/ui/{object-safety/object-safety-supertrait-mentions-Self.stderr => dyn-compatibility/supertrait-mentions-Self.stderr} (86%)
 rename tests/ui/{object-safety/issue-102762.rs => dyn-compatibility/undispatchable-receiver-and-wc-references-Self.rs} (79%)
 rename tests/ui/{object-safety/issue-102762.stderr => dyn-compatibility/undispatchable-receiver-and-wc-references-Self.stderr} (87%)
 rename tests/ui/impl-trait/{object-unsafe-trait-in-return-position-dyn-trait.rs => dyn-incompatible-trait-in-return-position-dyn-trait.rs} (59%)
 rename tests/ui/impl-trait/{object-unsafe-trait-in-return-position-dyn-trait.stderr => dyn-incompatible-trait-in-return-position-dyn-trait.stderr} (62%)
 rename tests/ui/impl-trait/{object-unsafe-trait-in-return-position-impl-trait.rs => dyn-incompatible-trait-in-return-position-impl-trait.rs} (61%)
 rename tests/ui/impl-trait/{object-unsafe-trait-in-return-position-impl-trait.stderr => dyn-incompatible-trait-in-return-position-impl-trait.stderr} (54%)
 rename tests/ui/impl-trait/in-trait/{cycle-effective-visibilities-during-object-safety.rs => cycle-effective-visibilities-during-dyn-compatibility-check.rs} (100%)
 rename tests/ui/impl-trait/in-trait/{cycle-effective-visibilities-during-object-safety.stderr => cycle-effective-visibilities-during-dyn-compatibility-check.stderr} (82%)
 rename tests/ui/impl-trait/in-trait/{object-safety-sized.rs => dyn-compatibility-sized.rs} (100%)
 rename tests/ui/impl-trait/in-trait/{object-safety.rs => dyn-compatibility.rs} (100%)
 rename tests/ui/impl-trait/in-trait/{object-safety.stderr => dyn-compatibility.stderr} (91%)
 rename tests/ui/self/{arbitrary-self-types-not-object-safe.curr.stderr => arbitrary-self-types-dyn-incompatible.curr.stderr} (89%)
 rename tests/ui/self/{arbitrary-self-types-not-object-safe.dyn_compatible_for_dispatch.stderr => arbitrary-self-types-dyn-incompatible.dyn_compatible_for_dispatch.stderr} (90%)
 rename tests/ui/self/{arbitrary-self-types-not-object-safe.rs => arbitrary-self-types-dyn-incompatible.rs} (100%)
 rename tests/ui/self/{object-safety-sized-self-by-value-self.rs => dyn-compatibility-sized-self-by-value-self.rs} (90%)
 rename tests/ui/self/{object-safety-sized-self-generic-method.rs => dyn-compatibility-sized-self-generic-method.rs} (90%)
 rename tests/ui/self/{object-safety-sized-self-return-Self.rs => dyn-compatibility-sized-self-return-Self.rs} (90%)
 rename tests/ui/suggestions/auxiliary/{not-object-safe.rs => dyn-incompatible.rs} (100%)
 rename tests/ui/suggestions/{object-unsafe-trait-references-self.rs => dyn-incompatible-trait-references-self.rs} (100%)
 rename tests/ui/suggestions/{object-unsafe-trait-references-self.stderr => dyn-incompatible-trait-references-self.stderr} (87%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-self-2021-without-dyn.rs => dyn-incompatible-trait-should-use-self-2021-without-dyn.rs} (100%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-self-2021-without-dyn.stderr => dyn-incompatible-trait-should-use-self-2021-without-dyn.stderr} (83%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-self-2021.rs => dyn-incompatible-trait-should-use-self-2021.rs} (100%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-self-2021.stderr => dyn-incompatible-trait-should-use-self-2021.stderr} (85%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-self.rs => dyn-incompatible-trait-should-use-self.rs} (100%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-self.stderr => dyn-incompatible-trait-should-use-self.stderr} (86%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-where-sized.fixed => dyn-incompatible-trait-should-use-where-sized.fixed} (100%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-where-sized.rs => dyn-incompatible-trait-should-use-where-sized.rs} (100%)
 rename tests/ui/suggestions/{object-unsafe-trait-should-use-where-sized.stderr => dyn-incompatible-trait-should-use-where-sized.stderr} (89%)
 rename tests/ui/traits/next-solver/{object-unsafety.rs => dyn-incompatibility.rs} (100%)
 rename tests/ui/traits/next-solver/{object-unsafety.stderr => dyn-incompatibility.stderr} (90%)
 rename tests/ui/traits/non_lifetime_binders/{supertrait-object-safety.rs => supertrait-dyn-compatibility.rs} (100%)
 rename tests/ui/traits/non_lifetime_binders/{supertrait-object-safety.stderr => supertrait-dyn-compatibility.stderr} (88%)
 rename tests/ui/traits/vtable/{vtable-non-object-safe.rs => vtable-dyn-incompatible.rs} (78%)
 rename tests/ui/traits/vtable/{vtable-non-object-safe.stderr => vtable-dyn-incompatible.stderr} (92%)
 rename tests/ui/unsized-locals/{by-value-trait-object-safety-rpass.rs => by-value-trait-dyn-compatibility-rpass.rs} (100%)
 rename tests/ui/unsized-locals/{by-value-trait-object-safety-withdefault.rs => by-value-trait-dyn-compatibility-with-default.rs} (100%)
 rename tests/ui/unsized-locals/{by-value-trait-object-safety.rs => by-value-trait-dyn-compatibility.rs} (100%)
 rename tests/ui/unsized-locals/{by-value-trait-object-safety.stderr => by-value-trait-dyn-compatibility.stderr} (84%)
 rename tests/ui/wf/{wf-convert-unsafe-trait-obj-box.rs => wf-convert-dyn-incompat-trait-obj-box.rs} (87%)
 rename tests/ui/wf/{wf-convert-unsafe-trait-obj-box.stderr => wf-convert-dyn-incompat-trait-obj-box.stderr} (86%)
 rename tests/ui/wf/{wf-convert-unsafe-trait-obj.rs => wf-convert-dyn-incompat-trait-obj.rs} (87%)
 rename tests/ui/wf/{wf-convert-unsafe-trait-obj.stderr => wf-convert-dyn-incompat-trait-obj.stderr} (87%)
 rename tests/ui/wf/{wf-unsafe-trait-obj-match.rs => wf-dyn-incompat-trait-obj-match.rs} (100%)
 rename tests/ui/wf/{wf-unsafe-trait-obj-match.stderr => wf-dyn-incompat-trait-obj-match.stderr} (89%)
 rename tests/ui/wf/{wf-object-safe.rs => wf-dyn-incompatible.rs} (57%)
 rename tests/ui/wf/{wf-object-safe.stderr => wf-dyn-incompatible.stderr} (90%)

diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 86cae849b9782..92aafc5a98e8a 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -3173,10 +3173,6 @@ ui/nll/user-annotations/issue-55241.rs
 ui/nll/user-annotations/issue-55748-pat-types-constrain-bindings.rs
 ui/nll/user-annotations/issue-57731-ascibed-coupled-types.rs
 ui/numbers-arithmetic/issue-8460.rs
-ui/object-safety/issue-102762.rs
-ui/object-safety/issue-102933.rs
-ui/object-safety/issue-106247.rs
-ui/object-safety/issue-19538.rs
 ui/on-unimplemented/issue-104140.rs
 ui/or-patterns/issue-64879-trailing-before-guard.rs
 ui/or-patterns/issue-67514-irrefutable-param.rs
diff --git a/tests/ui/allocator/dyn-compatible.rs b/tests/ui/allocator/dyn-compatible.rs
new file mode 100644
index 0000000000000..9d8235e58d929
--- /dev/null
+++ b/tests/ui/allocator/dyn-compatible.rs
@@ -0,0 +1,13 @@
+//@ run-pass
+
+// Check that `Allocator` is dyn-compatible, this allows for polymorphic allocators
+
+#![feature(allocator_api)]
+
+use std::alloc::{Allocator, System};
+
+fn ensure_dyn_compatible(_: &dyn Allocator) {}
+
+fn main() {
+    ensure_dyn_compatible(&System);
+}
diff --git a/tests/ui/allocator/object-safe.rs b/tests/ui/allocator/object-safe.rs
deleted file mode 100644
index 1c1f4fe0bf6ce..0000000000000
--- a/tests/ui/allocator/object-safe.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-
-// Check that `Allocator` is object safe, this allows for polymorphic allocators
-
-#![feature(allocator_api)]
-
-use std::alloc::{Allocator, System};
-
-fn ensure_object_safe(_: &dyn Allocator) {}
-
-fn main() {
-    ensure_object_safe(&System);
-}
diff --git a/tests/ui/associated-type-bounds/entails-sized-object-safety.rs b/tests/ui/associated-type-bounds/entails-sized-dyn-compatibility.rs
similarity index 67%
rename from tests/ui/associated-type-bounds/entails-sized-object-safety.rs
rename to tests/ui/associated-type-bounds/entails-sized-dyn-compatibility.rs
index ad2cbe4820981..943df68493fb1 100644
--- a/tests/ui/associated-type-bounds/entails-sized-object-safety.rs
+++ b/tests/ui/associated-type-bounds/entails-sized-dyn-compatibility.rs
@@ -4,21 +4,21 @@ trait Tr1: Sized { type As1; }
 trait Tr2<'a>: Sized { type As2; }
 
 trait ObjTr1 { fn foo() -> Self where Self: Tr1<As1: Copy>; }
-fn _assert_obj_safe_1(_: Box<dyn ObjTr1>) {}
+fn _assert_dyn_compat_1(_: Box<dyn ObjTr1>) {}
 
 trait ObjTr2 { fn foo() -> Self where Self: Tr1<As1: 'static>; }
-fn _assert_obj_safe_2(_: Box<dyn ObjTr2>) {}
+fn _assert_dyn_compat_2(_: Box<dyn ObjTr2>) {}
 
 trait ObjTr3 { fn foo() -> Self where Self: Tr1<As1: Into<u8> + 'static + Copy>; }
-fn _assert_obj_safe_3(_: Box<dyn ObjTr3>) {}
+fn _assert_dyn_compat_3(_: Box<dyn ObjTr3>) {}
 
 trait ObjTr4 { fn foo() -> Self where Self: Tr1<As1: for<'a> Tr2<'a>>; }
-fn _assert_obj_safe_4(_: Box<dyn ObjTr4>) {}
+fn _assert_dyn_compat_4(_: Box<dyn ObjTr4>) {}
 
 trait ObjTr5 { fn foo() -> Self where for<'a> Self: Tr1<As1: Tr2<'a>>; }
-fn _assert_obj_safe_5(_: Box<dyn ObjTr5>) {}
+fn _assert_dyn_compat_5(_: Box<dyn ObjTr5>) {}
 
 trait ObjTr6 { fn foo() -> Self where Self: for<'a> Tr1<As1: Tr2<'a, As2: for<'b> Tr2<'b>>>; }
-fn _assert_obj_safe_6(_: Box<dyn ObjTr6>) {}
+fn _assert_dyn_compat_6(_: Box<dyn ObjTr6>) {}
 
 fn main() {}
diff --git a/tests/ui/async-await/in-trait/object-safety.rs b/tests/ui/async-await/in-trait/dyn-compatibility.rs
similarity index 100%
rename from tests/ui/async-await/in-trait/object-safety.rs
rename to tests/ui/async-await/in-trait/dyn-compatibility.rs
diff --git a/tests/ui/async-await/in-trait/object-safety.stderr b/tests/ui/async-await/in-trait/dyn-compatibility.stderr
similarity index 90%
rename from tests/ui/async-await/in-trait/object-safety.stderr
rename to tests/ui/async-await/in-trait/dyn-compatibility.stderr
index 8e73abab9335f..5cc3b6800ddbc 100644
--- a/tests/ui/async-await/in-trait/object-safety.stderr
+++ b/tests/ui/async-await/in-trait/dyn-compatibility.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety.rs:9:12
+  --> $DIR/dyn-compatibility.rs:9:12
    |
 LL |     let x: &dyn Foo = todo!();
    |            ^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety.rs:5:14
+  --> $DIR/dyn-compatibility.rs:5:14
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/coherence/coherence-impl-trait-for-trait-object-safe.rs b/tests/ui/coherence/coherence-impl-trait-for-trait-dyn-compatible.rs
similarity index 54%
rename from tests/ui/coherence/coherence-impl-trait-for-trait-object-safe.rs
rename to tests/ui/coherence/coherence-impl-trait-for-trait-dyn-compatible.rs
index bce3b0fd729fe..f41d3a783abca 100644
--- a/tests/ui/coherence/coherence-impl-trait-for-trait-object-safe.rs
+++ b/tests/ui/coherence/coherence-impl-trait-for-trait-dyn-compatible.rs
@@ -1,10 +1,10 @@
 // Test that we give suitable error messages when the user attempts to
 // impl a trait `Trait` for its own object type.
 
-// If the trait is not object-safe, we give a more tailored message
+// If the trait is dyn-incompatible, we give a more tailored message
 // because we're such schnuckels:
-trait NotObjectSafe { fn eq(&self, other: Self); }
-impl NotObjectSafe for dyn NotObjectSafe { }
+trait DynIncompatible { fn eq(&self, other: Self); }
+impl DynIncompatible for dyn DynIncompatible { }
 //~^ ERROR E0038
 //~| ERROR E0046
 
diff --git a/tests/ui/coherence/coherence-impl-trait-for-trait-dyn-compatible.stderr b/tests/ui/coherence/coherence-impl-trait-for-trait-dyn-compatible.stderr
new file mode 100644
index 0000000000000..542be2dbc305c
--- /dev/null
+++ b/tests/ui/coherence/coherence-impl-trait-for-trait-dyn-compatible.stderr
@@ -0,0 +1,27 @@
+error[E0038]: the trait `DynIncompatible` cannot be made into an object
+  --> $DIR/coherence-impl-trait-for-trait-dyn-compatible.rs:7:26
+   |
+LL | impl DynIncompatible for dyn DynIncompatible { }
+   |                          ^^^^^^^^^^^^^^^^^^^ `DynIncompatible` cannot be made into an object
+   |
+note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+  --> $DIR/coherence-impl-trait-for-trait-dyn-compatible.rs:6:45
+   |
+LL | trait DynIncompatible { fn eq(&self, other: Self); }
+   |       ---------------                       ^^^^ ...because method `eq` references the `Self` type in this parameter
+   |       |
+   |       this trait cannot be made into an object...
+   = help: consider moving `eq` to another trait
+
+error[E0046]: not all trait items implemented, missing: `eq`
+  --> $DIR/coherence-impl-trait-for-trait-dyn-compatible.rs:7:1
+   |
+LL | trait DynIncompatible { fn eq(&self, other: Self); }
+   |                         -------------------------- `eq` from trait
+LL | impl DynIncompatible for dyn DynIncompatible { }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `eq` in implementation
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0038, E0046.
+For more information about an error, try `rustc --explain E0038`.
diff --git a/tests/ui/coherence/coherence-impl-trait-for-trait-object-safe.stderr b/tests/ui/coherence/coherence-impl-trait-for-trait-object-safe.stderr
deleted file mode 100644
index ce65e079ab45a..0000000000000
--- a/tests/ui/coherence/coherence-impl-trait-for-trait-object-safe.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0038]: the trait `NotObjectSafe` cannot be made into an object
-  --> $DIR/coherence-impl-trait-for-trait-object-safe.rs:7:24
-   |
-LL | impl NotObjectSafe for dyn NotObjectSafe { }
-   |                        ^^^^^^^^^^^^^^^^^ `NotObjectSafe` cannot be made into an object
-   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/coherence-impl-trait-for-trait-object-safe.rs:6:43
-   |
-LL | trait NotObjectSafe { fn eq(&self, other: Self); }
-   |       -------------                       ^^^^ ...because method `eq` references the `Self` type in this parameter
-   |       |
-   |       this trait cannot be made into an object...
-   = help: consider moving `eq` to another trait
-
-error[E0046]: not all trait items implemented, missing: `eq`
-  --> $DIR/coherence-impl-trait-for-trait-object-safe.rs:7:1
-   |
-LL | trait NotObjectSafe { fn eq(&self, other: Self); }
-   |                       -------------------------- `eq` from trait
-LL | impl NotObjectSafe for dyn NotObjectSafe { }
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `eq` in implementation
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0038, E0046.
-For more information about an error, try `rustc --explain E0038`.
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_object_safety.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
similarity index 100%
rename from tests/ui/const-generics/adt_const_params/const_param_ty_object_safety.rs
rename to tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_object_safety.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr
similarity index 93%
rename from tests/ui/const-generics/adt_const_params/const_param_ty_object_safety.stderr
rename to tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr
index 831b40887ac42..84281eb53c946 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_object_safety.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr
@@ -1,5 +1,5 @@
 error[E0038]: the trait `ConstParamTy_` cannot be made into an object
-  --> $DIR/const_param_ty_object_safety.rs:6:12
+  --> $DIR/const_param_ty_dyn_compatibility.rs:6:12
    |
 LL | fn foo(a: &dyn ConstParamTy_) {}
    |            ^^^^^^^^^^^^^^^^^ `ConstParamTy_` cannot be made into an object
@@ -14,7 +14,7 @@ LL | fn foo(a: &impl ConstParamTy_) {}
    |            ~~~~
 
 error[E0038]: the trait `UnsizedConstParamTy` cannot be made into an object
-  --> $DIR/const_param_ty_object_safety.rs:9:12
+  --> $DIR/const_param_ty_dyn_compatibility.rs:9:12
    |
 LL | fn bar(a: &dyn UnsizedConstParamTy) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^ `UnsizedConstParamTy` cannot be made into an object
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.rs b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-ret.rs
similarity index 100%
rename from tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.rs
rename to tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-ret.rs
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.stderr b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-ret.stderr
similarity index 91%
rename from tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.stderr
rename to tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-ret.stderr
index fb57da42bb297..d2017615e67db 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-ret.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-err-ret.rs:17:16
+  --> $DIR/dyn-compatibility-err-ret.rs:17:16
    |
 LL | fn use_dyn(v: &dyn Foo) {
    |                ^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-err-ret.rs:8:8
+  --> $DIR/dyn-compatibility-err-ret.rs:8:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -17,13 +17,13 @@ LL |     fn test(&self) -> [u8; bar::<Self>()];
    = help: only type `()` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-err-ret.rs:18:5
+  --> $DIR/dyn-compatibility-err-ret.rs:18:5
    |
 LL |     v.test();
    |     ^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-err-ret.rs:8:8
+  --> $DIR/dyn-compatibility-err-ret.rs:8:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.rs b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-where-bounds.rs
similarity index 100%
rename from tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.rs
rename to tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-where-bounds.rs
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.stderr b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-where-bounds.stderr
similarity index 88%
rename from tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.stderr
rename to tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-where-bounds.stderr
index 831bda7129542..26ca2d4df5ffc 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-err-where-bounds.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-err-where-bounds.rs:15:16
+  --> $DIR/dyn-compatibility-err-where-bounds.rs:15:16
    |
 LL | fn use_dyn(v: &dyn Foo) {
    |                ^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-err-where-bounds.rs:8:8
+  --> $DIR/dyn-compatibility-err-where-bounds.rs:8:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -15,13 +15,13 @@ LL |     fn test(&self) where [u8; bar::<Self>()]: Sized;
    = help: only type `()` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-err-where-bounds.rs:17:5
+  --> $DIR/dyn-compatibility-err-where-bounds.rs:17:5
    |
 LL |     v.test();
    |     ^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-err-where-bounds.rs:8:8
+  --> $DIR/dyn-compatibility-err-where-bounds.rs:8:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.rs b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok-infer-err.rs
similarity index 100%
rename from tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.rs
rename to tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok-infer-err.rs
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok-infer-err.stderr
similarity index 85%
rename from tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
rename to tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok-infer-err.stderr
index d1e1c976da664..a124fbc60920d 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok-infer-err.stderr
@@ -1,11 +1,11 @@
 error[E0284]: type annotations needed
-  --> $DIR/object-safety-ok-infer-err.rs:19:5
+  --> $DIR/dyn-compatibility-ok-infer-err.rs:19:5
    |
 LL |     use_dyn(&());
    |     ^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `use_dyn`
    |
 note: required by a const generic parameter in `use_dyn`
-  --> $DIR/object-safety-ok-infer-err.rs:14:12
+  --> $DIR/dyn-compatibility-ok-infer-err.rs:14:12
    |
 LL | fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
    |            ^^^^^^^^^^^^^^ required by this const generic parameter in `use_dyn`
@@ -15,7 +15,7 @@ LL |     use_dyn::<N>(&());
    |            +++++
 
 error[E0284]: type annotations needed
-  --> $DIR/object-safety-ok-infer-err.rs:19:5
+  --> $DIR/dyn-compatibility-ok-infer-err.rs:19:5
    |
 LL |     use_dyn(&());
    |     ^^^^^^^ --- type must be known at this point
@@ -23,7 +23,7 @@ LL |     use_dyn(&());
    |     cannot infer the value of the const parameter `N` declared on the function `use_dyn`
    |
 note: required for `()` to implement `Foo<_>`
-  --> $DIR/object-safety-ok-infer-err.rs:8:22
+  --> $DIR/dyn-compatibility-ok-infer-err.rs:8:22
    |
 LL | impl<const N: usize> Foo<N> for () {
    |      --------------  ^^^^^^     ^^
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-ok.rs b/tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok.rs
similarity index 100%
rename from tests/ui/const-generics/generic_const_exprs/object-safety-ok.rs
rename to tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok.rs
diff --git a/tests/ui/object-safety/almost-supertrait-associated-type.rs b/tests/ui/dyn-compatibility/almost-supertrait-associated-type.rs
similarity index 95%
rename from tests/ui/object-safety/almost-supertrait-associated-type.rs
rename to tests/ui/dyn-compatibility/almost-supertrait-associated-type.rs
index 963cdff526ee6..83076f7d5fc3b 100644
--- a/tests/ui/object-safety/almost-supertrait-associated-type.rs
+++ b/tests/ui/dyn-compatibility/almost-supertrait-associated-type.rs
@@ -1,5 +1,5 @@
 // Test for fixed unsoundness in #126079.
-// Enforces that the associated types that are object safe
+// Enforces that the associated types that are dyn-compatible.
 
 use std::marker::PhantomData;
 
diff --git a/tests/ui/object-safety/almost-supertrait-associated-type.stderr b/tests/ui/dyn-compatibility/almost-supertrait-associated-type.stderr
similarity index 100%
rename from tests/ui/object-safety/almost-supertrait-associated-type.stderr
rename to tests/ui/dyn-compatibility/almost-supertrait-associated-type.stderr
diff --git a/tests/ui/object-safety/assoc_const_bounds.rs b/tests/ui/dyn-compatibility/assoc_const_bounds.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_const_bounds.rs
rename to tests/ui/dyn-compatibility/assoc_const_bounds.rs
diff --git a/tests/ui/object-safety/assoc_const_bounds_sized.rs b/tests/ui/dyn-compatibility/assoc_const_bounds_sized.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_const_bounds_sized.rs
rename to tests/ui/dyn-compatibility/assoc_const_bounds_sized.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds.rs b/tests/ui/dyn-compatibility/assoc_type_bounds.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds.rs
rename to tests/ui/dyn-compatibility/assoc_type_bounds.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds.stderr b/tests/ui/dyn-compatibility/assoc_type_bounds.stderr
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds.stderr
rename to tests/ui/dyn-compatibility/assoc_type_bounds.stderr
diff --git a/tests/ui/object-safety/assoc_type_bounds2.rs b/tests/ui/dyn-compatibility/assoc_type_bounds2.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds2.rs
rename to tests/ui/dyn-compatibility/assoc_type_bounds2.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds2.stderr b/tests/ui/dyn-compatibility/assoc_type_bounds2.stderr
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds2.stderr
rename to tests/ui/dyn-compatibility/assoc_type_bounds2.stderr
diff --git a/tests/ui/object-safety/assoc_type_bounds_implicit_sized.fixed b/tests/ui/dyn-compatibility/assoc_type_bounds_implicit_sized.fixed
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_implicit_sized.fixed
rename to tests/ui/dyn-compatibility/assoc_type_bounds_implicit_sized.fixed
diff --git a/tests/ui/object-safety/assoc_type_bounds_implicit_sized.rs b/tests/ui/dyn-compatibility/assoc_type_bounds_implicit_sized.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_implicit_sized.rs
rename to tests/ui/dyn-compatibility/assoc_type_bounds_implicit_sized.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds_implicit_sized.stderr b/tests/ui/dyn-compatibility/assoc_type_bounds_implicit_sized.stderr
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_implicit_sized.stderr
rename to tests/ui/dyn-compatibility/assoc_type_bounds_implicit_sized.stderr
diff --git a/tests/ui/object-safety/assoc_type_bounds_sized.rs b/tests/ui/dyn-compatibility/assoc_type_bounds_sized.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_sized.rs
rename to tests/ui/dyn-compatibility/assoc_type_bounds_sized.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds_sized_others.rs b/tests/ui/dyn-compatibility/assoc_type_bounds_sized_others.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_sized_others.rs
rename to tests/ui/dyn-compatibility/assoc_type_bounds_sized_others.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds_sized_others.stderr b/tests/ui/dyn-compatibility/assoc_type_bounds_sized_others.stderr
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_sized_others.stderr
rename to tests/ui/dyn-compatibility/assoc_type_bounds_sized_others.stderr
diff --git a/tests/ui/object-safety/assoc_type_bounds_sized_unnecessary.rs b/tests/ui/dyn-compatibility/assoc_type_bounds_sized_unnecessary.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_sized_unnecessary.rs
rename to tests/ui/dyn-compatibility/assoc_type_bounds_sized_unnecessary.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds_sized_unnecessary.stderr b/tests/ui/dyn-compatibility/assoc_type_bounds_sized_unnecessary.stderr
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_sized_unnecessary.stderr
rename to tests/ui/dyn-compatibility/assoc_type_bounds_sized_unnecessary.stderr
diff --git a/tests/ui/object-safety/assoc_type_bounds_sized_used.rs b/tests/ui/dyn-compatibility/assoc_type_bounds_sized_used.rs
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_sized_used.rs
rename to tests/ui/dyn-compatibility/assoc_type_bounds_sized_used.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds_sized_used.stderr b/tests/ui/dyn-compatibility/assoc_type_bounds_sized_used.stderr
similarity index 100%
rename from tests/ui/object-safety/assoc_type_bounds_sized_used.stderr
rename to tests/ui/dyn-compatibility/assoc_type_bounds_sized_used.stderr
diff --git a/tests/ui/object-safety/object-safety-associated-consts.curr.stderr b/tests/ui/dyn-compatibility/associated-consts.curr.stderr
similarity index 86%
rename from tests/ui/object-safety/object-safety-associated-consts.curr.stderr
rename to tests/ui/dyn-compatibility/associated-consts.curr.stderr
index 3c070f17c82ad..17d184942c701 100644
--- a/tests/ui/object-safety/object-safety-associated-consts.curr.stderr
+++ b/tests/ui/dyn-compatibility/associated-consts.curr.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-associated-consts.rs:12:31
+  --> $DIR/associated-consts.rs:12:31
    |
 LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
    |                               ^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-associated-consts.rs:9:11
+  --> $DIR/associated-consts.rs:9:11
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -14,13 +14,13 @@ LL |     const X: usize;
    = help: consider moving `X` to another trait
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-associated-consts.rs:14:5
+  --> $DIR/associated-consts.rs:14:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-associated-consts.rs:9:11
+  --> $DIR/associated-consts.rs:9:11
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-associated-consts.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/associated-consts.dyn_compatible_for_dispatch.stderr
similarity index 87%
rename from tests/ui/object-safety/object-safety-associated-consts.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/associated-consts.dyn_compatible_for_dispatch.stderr
index 5b98cc35505c6..cc5120232c244 100644
--- a/tests/ui/object-safety/object-safety-associated-consts.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/associated-consts.dyn_compatible_for_dispatch.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-associated-consts.rs:14:5
+  --> $DIR/associated-consts.rs:14:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-associated-consts.rs:9:11
+  --> $DIR/associated-consts.rs:9:11
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-associated-consts.rs b/tests/ui/dyn-compatibility/associated-consts.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-associated-consts.rs
rename to tests/ui/dyn-compatibility/associated-consts.rs
diff --git a/tests/ui/object-safety/avoid-ice-on-warning-2.new.stderr b/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.new.stderr
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning-2.new.stderr
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning-2.new.stderr
diff --git a/tests/ui/object-safety/avoid-ice-on-warning-2.old.stderr b/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.old.stderr
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning-2.old.stderr
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning-2.old.stderr
diff --git a/tests/ui/object-safety/avoid-ice-on-warning-2.rs b/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.rs
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning-2.rs
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning-2.rs
diff --git a/tests/ui/object-safety/avoid-ice-on-warning-3.new.stderr b/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.new.stderr
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning-3.new.stderr
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning-3.new.stderr
diff --git a/tests/ui/object-safety/avoid-ice-on-warning-3.old.stderr b/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.old.stderr
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning-3.old.stderr
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning-3.old.stderr
diff --git a/tests/ui/object-safety/avoid-ice-on-warning-3.rs b/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.rs
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning-3.rs
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning-3.rs
diff --git a/tests/ui/object-safety/avoid-ice-on-warning.new.stderr b/tests/ui/dyn-compatibility/avoid-ice-on-warning.new.stderr
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning.new.stderr
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning.new.stderr
diff --git a/tests/ui/object-safety/avoid-ice-on-warning.old.stderr b/tests/ui/dyn-compatibility/avoid-ice-on-warning.old.stderr
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning.old.stderr
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning.old.stderr
diff --git a/tests/ui/object-safety/avoid-ice-on-warning.rs b/tests/ui/dyn-compatibility/avoid-ice-on-warning.rs
similarity index 100%
rename from tests/ui/object-safety/avoid-ice-on-warning.rs
rename to tests/ui/dyn-compatibility/avoid-ice-on-warning.rs
diff --git a/tests/ui/object-safety/bare-trait-dont-suggest-dyn.new.fixed b/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.fixed
similarity index 100%
rename from tests/ui/object-safety/bare-trait-dont-suggest-dyn.new.fixed
rename to tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.fixed
diff --git a/tests/ui/object-safety/bare-trait-dont-suggest-dyn.new.stderr b/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.stderr
similarity index 100%
rename from tests/ui/object-safety/bare-trait-dont-suggest-dyn.new.stderr
rename to tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.stderr
diff --git a/tests/ui/object-safety/bare-trait-dont-suggest-dyn.old.stderr b/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.old.stderr
similarity index 100%
rename from tests/ui/object-safety/bare-trait-dont-suggest-dyn.old.stderr
rename to tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.old.stderr
diff --git a/tests/ui/object-safety/bare-trait-dont-suggest-dyn.rs b/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.rs
similarity index 100%
rename from tests/ui/object-safety/bare-trait-dont-suggest-dyn.rs
rename to tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.rs
diff --git a/tests/ui/object-safety/object-safety-bounds.rs b/tests/ui/dyn-compatibility/bounds.rs
similarity index 72%
rename from tests/ui/object-safety/object-safety-bounds.rs
rename to tests/ui/dyn-compatibility/bounds.rs
index 44bd369324a4b..1e04d11c516cb 100644
--- a/tests/ui/object-safety/object-safety-bounds.rs
+++ b/tests/ui/dyn-compatibility/bounds.rs
@@ -1,4 +1,4 @@
-// Traits with bounds mentioning `Self` are not object safe
+// Traits with bounds mentioning `Self` are dyn-incompatible.
 
 trait X {
     type U: PartialEq<Self>;
diff --git a/tests/ui/object-safety/object-safety-bounds.stderr b/tests/ui/dyn-compatibility/bounds.stderr
similarity index 89%
rename from tests/ui/object-safety/object-safety-bounds.stderr
rename to tests/ui/dyn-compatibility/bounds.stderr
index 96a81a69639bd..9231d524fd173 100644
--- a/tests/ui/object-safety/object-safety-bounds.stderr
+++ b/tests/ui/dyn-compatibility/bounds.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `X` cannot be made into an object
-  --> $DIR/object-safety-bounds.rs:7:15
+  --> $DIR/bounds.rs:7:15
    |
 LL | fn f() -> Box<dyn X<U = u32>> {
    |               ^^^^^^^^^^^^^^ `X` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-bounds.rs:4:13
+  --> $DIR/bounds.rs:4:13
    |
 LL | trait X {
    |       - this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-by-value-self-use.rs b/tests/ui/dyn-compatibility/by-value-self-use.rs
similarity index 79%
rename from tests/ui/object-safety/object-safety-by-value-self-use.rs
rename to tests/ui/dyn-compatibility/by-value-self-use.rs
index 8e93c538217bb..3c04ec0cd888c 100644
--- a/tests/ui/object-safety/object-safety-by-value-self-use.rs
+++ b/tests/ui/dyn-compatibility/by-value-self-use.rs
@@ -1,4 +1,4 @@
-// Check that while a trait with by-value self is object-safe, we
+// Check that while a trait with by-value self is dyn-compatible, we
 // can't actually invoke it from an object (yet...?).
 
 #![feature(rustc_attrs)]
diff --git a/tests/ui/object-safety/object-safety-by-value-self-use.stderr b/tests/ui/dyn-compatibility/by-value-self-use.stderr
similarity index 83%
rename from tests/ui/object-safety/object-safety-by-value-self-use.stderr
rename to tests/ui/dyn-compatibility/by-value-self-use.stderr
index 1701f6059a8ee..14785b982a39e 100644
--- a/tests/ui/object-safety/object-safety-by-value-self-use.stderr
+++ b/tests/ui/dyn-compatibility/by-value-self-use.stderr
@@ -1,5 +1,5 @@
 error[E0161]: cannot move a value of type `dyn Bar`
-  --> $DIR/object-safety-by-value-self-use.rs:15:5
+  --> $DIR/by-value-self-use.rs:15:5
    |
 LL |     t.bar()
    |     ^ the size of `dyn Bar` cannot be statically determined
diff --git a/tests/ui/object-safety/object-safety-by-value-self.rs b/tests/ui/dyn-compatibility/by-value-self.rs
similarity index 90%
rename from tests/ui/object-safety/object-safety-by-value-self.rs
rename to tests/ui/dyn-compatibility/by-value-self.rs
index 0d20032327cae..a057a7ff0b57a 100644
--- a/tests/ui/object-safety/object-safety-by-value-self.rs
+++ b/tests/ui/dyn-compatibility/by-value-self.rs
@@ -1,4 +1,4 @@
-// Check that a trait with by-value self is considered object-safe.
+// Check that a trait with by-value self is considered dyn-compatible.
 
 //@ build-pass (FIXME(62277): could be check-pass?)
 #![allow(dead_code)]
diff --git a/tests/ui/object-safety/call-when-assoc-ty-is-sized.rs b/tests/ui/dyn-compatibility/call-when-assoc-ty-is-sized.rs
similarity index 100%
rename from tests/ui/object-safety/call-when-assoc-ty-is-sized.rs
rename to tests/ui/dyn-compatibility/call-when-assoc-ty-is-sized.rs
diff --git a/tests/ui/object-safety/issue-102933.rs b/tests/ui/dyn-compatibility/elaborated-predicates-ordering.rs
similarity index 93%
rename from tests/ui/object-safety/issue-102933.rs
rename to tests/ui/dyn-compatibility/elaborated-predicates-ordering.rs
index aa678fea17620..d3c3963a673d5 100644
--- a/tests/ui/object-safety/issue-102933.rs
+++ b/tests/ui/dyn-compatibility/elaborated-predicates-ordering.rs
@@ -1,4 +1,5 @@
 //@ check-pass
+// issue: rust-lang/rust#102933
 
 use std::future::Future;
 
diff --git a/tests/ui/object-safety/erroneous_signature.rs b/tests/ui/dyn-compatibility/erroneous_signature.rs
similarity index 100%
rename from tests/ui/object-safety/erroneous_signature.rs
rename to tests/ui/dyn-compatibility/erroneous_signature.rs
diff --git a/tests/ui/object-safety/erroneous_signature.stderr b/tests/ui/dyn-compatibility/erroneous_signature.stderr
similarity index 100%
rename from tests/ui/object-safety/erroneous_signature.stderr
rename to tests/ui/dyn-compatibility/erroneous_signature.stderr
diff --git a/tests/ui/object-safety/object-safety-generics.curr.stderr b/tests/ui/dyn-compatibility/generics.curr.stderr
similarity index 88%
rename from tests/ui/object-safety/object-safety-generics.curr.stderr
rename to tests/ui/dyn-compatibility/generics.curr.stderr
index 7528785d90b47..c63db38a080b4 100644
--- a/tests/ui/object-safety/object-safety-generics.curr.stderr
+++ b/tests/ui/dyn-compatibility/generics.curr.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-generics.rs:18:31
+  --> $DIR/generics.rs:18:31
    |
 LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
    |                               ^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-generics.rs:10:8
+  --> $DIR/generics.rs:10:8
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -14,13 +14,13 @@ LL |     fn bar<T>(&self, t: T);
    = help: consider moving `bar` to another trait
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-generics.rs:25:40
+  --> $DIR/generics.rs:25:40
    |
 LL | fn make_bar_explicit<T:Bar>(t: &T) -> &dyn Bar {
    |                                        ^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-generics.rs:10:8
+  --> $DIR/generics.rs:10:8
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -29,13 +29,13 @@ LL |     fn bar<T>(&self, t: T);
    = help: consider moving `bar` to another trait
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-generics.rs:20:5
+  --> $DIR/generics.rs:20:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-generics.rs:10:8
+  --> $DIR/generics.rs:10:8
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -45,13 +45,13 @@ LL |     fn bar<T>(&self, t: T);
    = note: required for the cast from `&T` to `&dyn Bar`
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-generics.rs:27:10
+  --> $DIR/generics.rs:27:10
    |
 LL |     t as &dyn Bar
    |          ^^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-generics.rs:10:8
+  --> $DIR/generics.rs:10:8
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -60,13 +60,13 @@ LL |     fn bar<T>(&self, t: T);
    = help: consider moving `bar` to another trait
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-generics.rs:27:5
+  --> $DIR/generics.rs:27:5
    |
 LL |     t as &dyn Bar
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-generics.rs:10:8
+  --> $DIR/generics.rs:10:8
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-generics.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/generics.dyn_compatible_for_dispatch.stderr
similarity index 89%
rename from tests/ui/object-safety/object-safety-generics.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/generics.dyn_compatible_for_dispatch.stderr
index 4686b994b33ed..ba2546ef2dc5c 100644
--- a/tests/ui/object-safety/object-safety-generics.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/generics.dyn_compatible_for_dispatch.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-generics.rs:20:5
+  --> $DIR/generics.rs:20:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-generics.rs:10:8
+  --> $DIR/generics.rs:10:8
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -15,13 +15,13 @@ LL |     fn bar<T>(&self, t: T);
    = note: required for the cast from `&T` to `&dyn Bar`
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-generics.rs:27:5
+  --> $DIR/generics.rs:27:5
    |
 LL |     t as &dyn Bar
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-generics.rs:10:8
+  --> $DIR/generics.rs:10:8
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-generics.rs b/tests/ui/dyn-compatibility/generics.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-generics.rs
rename to tests/ui/dyn-compatibility/generics.rs
diff --git a/tests/ui/object-safety/issue-106247.rs b/tests/ui/dyn-compatibility/impossible-predicates-multiple_supertrait_upcastable-check.rs
similarity index 73%
rename from tests/ui/object-safety/issue-106247.rs
rename to tests/ui/dyn-compatibility/impossible-predicates-multiple_supertrait_upcastable-check.rs
index 20a451a59a164..c2b8ecc141d7d 100644
--- a/tests/ui/object-safety/issue-106247.rs
+++ b/tests/ui/dyn-compatibility/impossible-predicates-multiple_supertrait_upcastable-check.rs
@@ -1,4 +1,5 @@
 //@ check-pass
+// issue: rust-lang/rust#106247
 
 pub trait Trait {
     fn method(&self) where Self: Sync;
diff --git a/tests/ui/object-safety/item-bounds-can-reference-self.rs b/tests/ui/dyn-compatibility/item-bounds-can-reference-self.rs
similarity index 100%
rename from tests/ui/object-safety/item-bounds-can-reference-self.rs
rename to tests/ui/dyn-compatibility/item-bounds-can-reference-self.rs
diff --git a/tests/ui/object-safety/issue-19538.rs b/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.rs
similarity index 90%
rename from tests/ui/object-safety/issue-19538.rs
rename to tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.rs
index 7054ef41b1c82..1289d2d7874aa 100644
--- a/tests/ui/object-safety/issue-19538.rs
+++ b/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.rs
@@ -1,3 +1,5 @@
+// issue: rust-lang/rust#19538
+
 trait Foo {
     fn foo<T>(&self, val: T);
 }
diff --git a/tests/ui/object-safety/issue-19538.stderr b/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr
similarity index 87%
rename from tests/ui/object-safety/issue-19538.stderr
rename to tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr
index 3dbe389686a44..7378ec023c926 100644
--- a/tests/ui/object-safety/issue-19538.stderr
+++ b/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/issue-19538.rs:17:15
+  --> $DIR/mention-correct-dyn-incompatible-trait.rs:19:15
    |
 LL |     let test: &mut dyn Bar = &mut thing;
    |               ^^^^^^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/issue-19538.rs:2:8
+  --> $DIR/mention-correct-dyn-incompatible-trait.rs:4:8
    |
 LL |     fn foo<T>(&self, val: T);
    |        ^^^ ...because method `foo` has generic type parameters
@@ -16,13 +16,13 @@ LL | trait Bar: Foo { }
    = help: only type `Thing` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/issue-19538.rs:17:30
+  --> $DIR/mention-correct-dyn-incompatible-trait.rs:19:30
    |
 LL |     let test: &mut dyn Bar = &mut thing;
    |                              ^^^^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/issue-19538.rs:2:8
+  --> $DIR/mention-correct-dyn-incompatible-trait.rs:4:8
    |
 LL |     fn foo<T>(&self, val: T);
    |        ^^^ ...because method `foo` has generic type parameters
diff --git a/tests/ui/object-safety/object-safety-issue-22040.rs b/tests/ui/dyn-compatibility/mentions-Self-in-super-predicates.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-issue-22040.rs
rename to tests/ui/dyn-compatibility/mentions-Self-in-super-predicates.rs
diff --git a/tests/ui/object-safety/object-safety-issue-22040.stderr b/tests/ui/dyn-compatibility/mentions-Self-in-super-predicates.stderr
similarity index 87%
rename from tests/ui/object-safety/object-safety-issue-22040.stderr
rename to tests/ui/dyn-compatibility/mentions-Self-in-super-predicates.stderr
index e5723f12258fe..7578edce7d19e 100644
--- a/tests/ui/object-safety/object-safety-issue-22040.stderr
+++ b/tests/ui/dyn-compatibility/mentions-Self-in-super-predicates.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Expr` cannot be made into an object
-  --> $DIR/object-safety-issue-22040.rs:12:23
+  --> $DIR/mentions-Self-in-super-predicates.rs:12:23
    |
 LL |     elements: Vec<Box<dyn Expr + 'x>>,
    |                       ^^^^^^^^^^^^^ `Expr` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-issue-22040.rs:5:21
+  --> $DIR/mentions-Self-in-super-predicates.rs:5:21
    |
 LL | trait Expr: Debug + PartialEq {
    |       ----          ^^^^^^^^^ ...because it uses `Self` as a type parameter
@@ -14,13 +14,13 @@ LL | trait Expr: Debug + PartialEq {
    = help: only type `SExpr<'x>` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Expr` cannot be made into an object
-  --> $DIR/object-safety-issue-22040.rs:38:16
+  --> $DIR/mentions-Self-in-super-predicates.rs:38:16
    |
 LL |     let a: Box<dyn Expr> = Box::new(SExpr::new());
    |                ^^^^^^^^ `Expr` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-issue-22040.rs:5:21
+  --> $DIR/mentions-Self-in-super-predicates.rs:5:21
    |
 LL | trait Expr: Debug + PartialEq {
    |       ----          ^^^^^^^^^ ...because it uses `Self` as a type parameter
@@ -29,13 +29,13 @@ LL | trait Expr: Debug + PartialEq {
    = help: only type `SExpr<'x>` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Expr` cannot be made into an object
-  --> $DIR/object-safety-issue-22040.rs:40:16
+  --> $DIR/mentions-Self-in-super-predicates.rs:40:16
    |
 LL |     let b: Box<dyn Expr> = Box::new(SExpr::new());
    |                ^^^^^^^^ `Expr` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-issue-22040.rs:5:21
+  --> $DIR/mentions-Self-in-super-predicates.rs:5:21
    |
 LL | trait Expr: Debug + PartialEq {
    |       ----          ^^^^^^^^^ ...because it uses `Self` as a type parameter
diff --git a/tests/ui/object-safety/object-safety-mentions-Self.curr.stderr b/tests/ui/dyn-compatibility/mentions-Self.curr.stderr
similarity index 88%
rename from tests/ui/object-safety/object-safety-mentions-Self.curr.stderr
rename to tests/ui/dyn-compatibility/mentions-Self.curr.stderr
index 7efb6ec3542d0..434e41cf2182d 100644
--- a/tests/ui/object-safety/object-safety-mentions-Self.curr.stderr
+++ b/tests/ui/dyn-compatibility/mentions-Self.curr.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-mentions-Self.rs:22:31
+  --> $DIR/mentions-Self.rs:22:31
    |
 LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
    |                               ^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-mentions-Self.rs:11:22
+  --> $DIR/mentions-Self.rs:11:22
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -14,13 +14,13 @@ LL |     fn bar(&self, x: &Self);
    = help: consider moving `bar` to another trait
 
 error[E0038]: the trait `Baz` cannot be made into an object
-  --> $DIR/object-safety-mentions-Self.rs:28:31
+  --> $DIR/mentions-Self.rs:28:31
    |
 LL | fn make_baz<T:Baz>(t: &T) -> &dyn Baz {
    |                               ^^^^^^^ `Baz` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-mentions-Self.rs:15:22
+  --> $DIR/mentions-Self.rs:15:22
    |
 LL | trait Baz {
    |       --- this trait cannot be made into an object...
@@ -29,13 +29,13 @@ LL |     fn baz(&self) -> Self;
    = help: consider moving `baz` to another trait
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-mentions-Self.rs:24:5
+  --> $DIR/mentions-Self.rs:24:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-mentions-Self.rs:11:22
+  --> $DIR/mentions-Self.rs:11:22
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -45,13 +45,13 @@ LL |     fn bar(&self, x: &Self);
    = note: required for the cast from `&T` to `&dyn Bar`
 
 error[E0038]: the trait `Baz` cannot be made into an object
-  --> $DIR/object-safety-mentions-Self.rs:30:5
+  --> $DIR/mentions-Self.rs:30:5
    |
 LL |     t
    |     ^ `Baz` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-mentions-Self.rs:15:22
+  --> $DIR/mentions-Self.rs:15:22
    |
 LL | trait Baz {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-mentions-Self.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/mentions-Self.dyn_compatible_for_dispatch.stderr
similarity index 88%
rename from tests/ui/object-safety/object-safety-mentions-Self.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/mentions-Self.dyn_compatible_for_dispatch.stderr
index d0efb9c587e4e..dc2d1f87eb737 100644
--- a/tests/ui/object-safety/object-safety-mentions-Self.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/mentions-Self.dyn_compatible_for_dispatch.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-mentions-Self.rs:24:5
+  --> $DIR/mentions-Self.rs:24:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-mentions-Self.rs:11:22
+  --> $DIR/mentions-Self.rs:11:22
    |
 LL | trait Bar {
    |       --- this trait cannot be made into an object...
@@ -15,13 +15,13 @@ LL |     fn bar(&self, x: &Self);
    = note: required for the cast from `&T` to `&dyn Bar`
 
 error[E0038]: the trait `Baz` cannot be made into an object
-  --> $DIR/object-safety-mentions-Self.rs:30:5
+  --> $DIR/mentions-Self.rs:30:5
    |
 LL |     t
    |     ^ `Baz` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-mentions-Self.rs:15:22
+  --> $DIR/mentions-Self.rs:15:22
    |
 LL | trait Baz {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-mentions-Self.rs b/tests/ui/dyn-compatibility/mentions-Self.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-mentions-Self.rs
rename to tests/ui/dyn-compatibility/mentions-Self.rs
diff --git a/tests/ui/traits/object/object-unsafe-missing-assoc-type.rs b/tests/ui/dyn-compatibility/missing-assoc-type.rs
similarity index 100%
rename from tests/ui/traits/object/object-unsafe-missing-assoc-type.rs
rename to tests/ui/dyn-compatibility/missing-assoc-type.rs
diff --git a/tests/ui/traits/object/object-unsafe-missing-assoc-type.stderr b/tests/ui/dyn-compatibility/missing-assoc-type.stderr
similarity index 86%
rename from tests/ui/traits/object/object-unsafe-missing-assoc-type.stderr
rename to tests/ui/dyn-compatibility/missing-assoc-type.stderr
index 9258b38f26c3a..f8450ba212d03 100644
--- a/tests/ui/traits/object/object-unsafe-missing-assoc-type.stderr
+++ b/tests/ui/dyn-compatibility/missing-assoc-type.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-unsafe-missing-assoc-type.rs:5:16
+  --> $DIR/missing-assoc-type.rs:5:16
    |
 LL | fn bar(x: &dyn Foo) {}
    |                ^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-missing-assoc-type.rs:2:10
+  --> $DIR/missing-assoc-type.rs:2:10
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -14,13 +14,13 @@ LL |     type Bar<T>;
    = help: consider moving `Bar` to another trait
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-unsafe-missing-assoc-type.rs:5:16
+  --> $DIR/missing-assoc-type.rs:5:16
    |
 LL | fn bar(x: &dyn Foo) {}
    |                ^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-missing-assoc-type.rs:2:10
+  --> $DIR/missing-assoc-type.rs:2:10
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -30,13 +30,13 @@ LL |     type Bar<T>;
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-unsafe-missing-assoc-type.rs:5:16
+  --> $DIR/missing-assoc-type.rs:5:16
    |
 LL | fn bar(x: &dyn Foo) {}
    |                ^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-missing-assoc-type.rs:2:10
+  --> $DIR/missing-assoc-type.rs:2:10
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -46,13 +46,13 @@ LL |     type Bar<T>;
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-unsafe-missing-assoc-type.rs:5:12
+  --> $DIR/missing-assoc-type.rs:5:12
    |
 LL | fn bar(x: &dyn Foo) {}
    |            ^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-missing-assoc-type.rs:2:10
+  --> $DIR/missing-assoc-type.rs:2:10
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-no-static.curr.stderr b/tests/ui/dyn-compatibility/no-static.curr.stderr
similarity index 92%
rename from tests/ui/object-safety/object-safety-no-static.curr.stderr
rename to tests/ui/dyn-compatibility/no-static.curr.stderr
index 91c3d89602e86..584db77985566 100644
--- a/tests/ui/object-safety/object-safety-no-static.curr.stderr
+++ b/tests/ui/dyn-compatibility/no-static.curr.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-no-static.rs:12:22
+  --> $DIR/no-static.rs:12:22
    |
 LL | fn diverges() -> Box<dyn Foo> {
    |                      ^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-no-static.rs:9:8
+  --> $DIR/no-static.rs:9:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -22,13 +22,13 @@ LL |     fn foo() where Self: Sized {}
    |              +++++++++++++++++
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-no-static.rs:22:12
+  --> $DIR/no-static.rs:22:12
    |
 LL |     let b: Box<dyn Foo> = Box::new(Bar);
    |            ^^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-no-static.rs:9:8
+  --> $DIR/no-static.rs:9:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -45,13 +45,13 @@ LL |     fn foo() where Self: Sized {}
    |              +++++++++++++++++
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-no-static.rs:22:27
+  --> $DIR/no-static.rs:22:27
    |
 LL |     let b: Box<dyn Foo> = Box::new(Bar);
    |                           ^^^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-no-static.rs:9:8
+  --> $DIR/no-static.rs:9:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-no-static.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/no-static.dyn_compatible_for_dispatch.stderr
similarity index 93%
rename from tests/ui/object-safety/object-safety-no-static.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/no-static.dyn_compatible_for_dispatch.stderr
index 52f6865b6f3cb..f2deb3b8d84b9 100644
--- a/tests/ui/object-safety/object-safety-no-static.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/no-static.dyn_compatible_for_dispatch.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety-no-static.rs:22:27
+  --> $DIR/no-static.rs:22:27
    |
 LL |     let b: Box<dyn Foo> = Box::new(Bar);
    |                           ^^^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-no-static.rs:9:8
+  --> $DIR/no-static.rs:9:8
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-no-static.rs b/tests/ui/dyn-compatibility/no-static.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-no-static.rs
rename to tests/ui/dyn-compatibility/no-static.rs
diff --git a/tests/ui/object-safety/object-safety-phantom-fn.rs b/tests/ui/dyn-compatibility/phantom-fn.rs
similarity index 92%
rename from tests/ui/object-safety/object-safety-phantom-fn.rs
rename to tests/ui/dyn-compatibility/phantom-fn.rs
index 1019c24859fba..9e410da82eed5 100644
--- a/tests/ui/object-safety/object-safety-phantom-fn.rs
+++ b/tests/ui/dyn-compatibility/phantom-fn.rs
@@ -1,4 +1,4 @@
-// Check that `Self` appearing in a phantom fn does not make a trait not object safe.
+// Check that `Self` appearing in a phantom fn does not make a trait dyn-incompatible.
 
 //@ build-pass (FIXME(62277): could be check-pass?)
 #![allow(dead_code)]
diff --git a/tests/ui/object-safety/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs b/tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs
similarity index 100%
rename from tests/ui/object-safety/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs
rename to tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs
diff --git a/tests/ui/object-safety/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.stderr b/tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.stderr
similarity index 100%
rename from tests/ui/object-safety/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.stderr
rename to tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.stderr
diff --git a/tests/ui/object-safety/object-safety-sized-2.curr.stderr b/tests/ui/dyn-compatibility/sized-2.curr.stderr
similarity index 88%
rename from tests/ui/object-safety/object-safety-sized-2.curr.stderr
rename to tests/ui/dyn-compatibility/sized-2.curr.stderr
index 4ce7ac5704e42..1017fde53d313 100644
--- a/tests/ui/object-safety/object-safety-sized-2.curr.stderr
+++ b/tests/ui/dyn-compatibility/sized-2.curr.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-sized-2.rs:14:31
+  --> $DIR/sized-2.rs:14:31
    |
 LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
    |                               ^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-sized-2.rs:9:18
+  --> $DIR/sized-2.rs:9:18
    |
 LL | trait Bar
    |       --- this trait cannot be made into an object...
@@ -13,13 +13,13 @@ LL |     where Self : Sized
    |                  ^^^^^ ...because it requires `Self: Sized`
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-sized-2.rs:16:5
+  --> $DIR/sized-2.rs:16:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-sized-2.rs:9:18
+  --> $DIR/sized-2.rs:9:18
    |
 LL | trait Bar
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-sized-2.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/sized-2.dyn_compatible_for_dispatch.stderr
similarity index 89%
rename from tests/ui/object-safety/object-safety-sized-2.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/sized-2.dyn_compatible_for_dispatch.stderr
index 99066c104b7cb..534cf0f1b033f 100644
--- a/tests/ui/object-safety/object-safety-sized-2.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/sized-2.dyn_compatible_for_dispatch.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-sized-2.rs:16:5
+  --> $DIR/sized-2.rs:16:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-sized-2.rs:9:18
+  --> $DIR/sized-2.rs:9:18
    |
 LL | trait Bar
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/object-safety/object-safety-sized-2.rs b/tests/ui/dyn-compatibility/sized-2.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-sized-2.rs
rename to tests/ui/dyn-compatibility/sized-2.rs
diff --git a/tests/ui/object-safety/object-safety-sized.curr.stderr b/tests/ui/dyn-compatibility/sized.curr.stderr
similarity index 88%
rename from tests/ui/object-safety/object-safety-sized.curr.stderr
rename to tests/ui/dyn-compatibility/sized.curr.stderr
index b61f968d90210..613833aad12ee 100644
--- a/tests/ui/object-safety/object-safety-sized.curr.stderr
+++ b/tests/ui/dyn-compatibility/sized.curr.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-sized.rs:12:32
+  --> $DIR/sized.rs:12:32
    |
 LL | fn make_bar<T: Bar>(t: &T) -> &dyn Bar {
    |                                ^^^^^^^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-sized.rs:8:12
+  --> $DIR/sized.rs:8:12
    |
 LL | trait Bar: Sized {
    |       ---  ^^^^^ ...because it requires `Self: Sized`
@@ -13,13 +13,13 @@ LL | trait Bar: Sized {
    |       this trait cannot be made into an object...
 
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-sized.rs:14:5
+  --> $DIR/sized.rs:14:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-sized.rs:8:12
+  --> $DIR/sized.rs:8:12
    |
 LL | trait Bar: Sized {
    |       ---  ^^^^^ ...because it requires `Self: Sized`
diff --git a/tests/ui/object-safety/object-safety-sized.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/sized.dyn_compatible_for_dispatch.stderr
similarity index 89%
rename from tests/ui/object-safety/object-safety-sized.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/sized.dyn_compatible_for_dispatch.stderr
index 5ce713375a49a..cf847bc157785 100644
--- a/tests/ui/object-safety/object-safety-sized.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/sized.dyn_compatible_for_dispatch.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Bar` cannot be made into an object
-  --> $DIR/object-safety-sized.rs:14:5
+  --> $DIR/sized.rs:14:5
    |
 LL |     t
    |     ^ `Bar` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-sized.rs:8:12
+  --> $DIR/sized.rs:8:12
    |
 LL | trait Bar: Sized {
    |       ---  ^^^^^ ...because it requires `Self: Sized`
diff --git a/tests/ui/object-safety/object-safety-sized.rs b/tests/ui/dyn-compatibility/sized.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-sized.rs
rename to tests/ui/dyn-compatibility/sized.rs
diff --git a/tests/ui/object-safety/object-safety-supertrait-mentions-GAT.rs b/tests/ui/dyn-compatibility/supertrait-mentions-GAT.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-supertrait-mentions-GAT.rs
rename to tests/ui/dyn-compatibility/supertrait-mentions-GAT.rs
diff --git a/tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr b/tests/ui/dyn-compatibility/supertrait-mentions-GAT.stderr
similarity index 86%
rename from tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr
rename to tests/ui/dyn-compatibility/supertrait-mentions-GAT.stderr
index 4d44627e77926..ac5a5b28d94d4 100644
--- a/tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr
+++ b/tests/ui/dyn-compatibility/supertrait-mentions-GAT.stderr
@@ -1,14 +1,14 @@
 error[E0311]: the parameter type `Self` may not live long enough
    |
 note: ...that is required by this bound
-  --> $DIR/object-safety-supertrait-mentions-GAT.rs:6:15
+  --> $DIR/supertrait-mentions-GAT.rs:6:15
    |
 LL |         Self: 'a;
    |               ^^
    = help: consider adding an explicit lifetime bound `Self: 'a`...
 
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-safety-supertrait-mentions-GAT.rs:10:20
+  --> $DIR/supertrait-mentions-GAT.rs:10:20
    |
 LL | trait SuperTrait<T>: for<'a> GatTrait<Gat<'a> = T> {
    |       ---------- in this trait
@@ -21,13 +21,13 @@ LL |     fn c(&self) -> Self;
    |                    ~~~~
 
 error[E0038]: the trait `SuperTrait` cannot be made into an object
-  --> $DIR/object-safety-supertrait-mentions-GAT.rs:10:20
+  --> $DIR/supertrait-mentions-GAT.rs:10:20
    |
 LL |     fn c(&self) -> dyn SuperTrait<T>;
    |                    ^^^^^^^^^^^^^^^^^ `SuperTrait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-supertrait-mentions-GAT.rs:4:10
+  --> $DIR/supertrait-mentions-GAT.rs:4:10
    |
 LL |     type Gat<'a>
    |          ^^^ ...because it contains the generic associated type `Gat`
diff --git a/tests/ui/object-safety/object-safety-supertrait-mentions-Self.rs b/tests/ui/dyn-compatibility/supertrait-mentions-Self.rs
similarity index 100%
rename from tests/ui/object-safety/object-safety-supertrait-mentions-Self.rs
rename to tests/ui/dyn-compatibility/supertrait-mentions-Self.rs
diff --git a/tests/ui/object-safety/object-safety-supertrait-mentions-Self.stderr b/tests/ui/dyn-compatibility/supertrait-mentions-Self.stderr
similarity index 86%
rename from tests/ui/object-safety/object-safety-supertrait-mentions-Self.stderr
rename to tests/ui/dyn-compatibility/supertrait-mentions-Self.stderr
index b1a70fb859d7f..6474b115c4628 100644
--- a/tests/ui/object-safety/object-safety-supertrait-mentions-Self.stderr
+++ b/tests/ui/dyn-compatibility/supertrait-mentions-Self.stderr
@@ -1,11 +1,11 @@
 error[E0277]: the size for values of type `Self` cannot be known at compilation time
-  --> $DIR/object-safety-supertrait-mentions-Self.rs:8:13
+  --> $DIR/supertrait-mentions-Self.rs:8:13
    |
 LL | trait Baz : Bar<Self> {
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
 note: required by an implicit `Sized` bound in `Bar`
-  --> $DIR/object-safety-supertrait-mentions-Self.rs:4:11
+  --> $DIR/supertrait-mentions-Self.rs:4:11
    |
 LL | trait Bar<T> {
    |           ^ required by the implicit `Sized` requirement on this type parameter in `Bar`
@@ -19,13 +19,13 @@ LL | trait Bar<T: ?Sized> {
    |            ++++++++
 
 error[E0038]: the trait `Baz` cannot be made into an object
-  --> $DIR/object-safety-supertrait-mentions-Self.rs:16:31
+  --> $DIR/supertrait-mentions-Self.rs:16:31
    |
 LL | fn make_baz<T:Baz>(t: &T) -> &dyn Baz {
    |                               ^^^^^^^ `Baz` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety-supertrait-mentions-Self.rs:8:13
+  --> $DIR/supertrait-mentions-Self.rs:8:13
    |
 LL | trait Baz : Bar<Self> {
    |       ---   ^^^^^^^^^ ...because it uses `Self` as a type parameter
diff --git a/tests/ui/object-safety/issue-102762.rs b/tests/ui/dyn-compatibility/undispatchable-receiver-and-wc-references-Self.rs
similarity index 79%
rename from tests/ui/object-safety/issue-102762.rs
rename to tests/ui/dyn-compatibility/undispatchable-receiver-and-wc-references-Self.rs
index 576f73e08bcf9..5c71bd7769ce1 100644
--- a/tests/ui/object-safety/issue-102762.rs
+++ b/tests/ui/dyn-compatibility/undispatchable-receiver-and-wc-references-Self.rs
@@ -1,7 +1,8 @@
 //@ compile-flags: --crate-type=lib
 // This test checks that the `where_clauses_object_safety` lint does not cause
-// other object safety *hard errors* to be suppressed, because we currently
-// only emit one object safety error per trait...
+// other dyn-compatibility *hard errors* to be suppressed, because we currently
+// only emit one dyn-compatibility error per trait...
+// issue: rust-lang/rust#102762
 
 use std::future::Future;
 use std::pin::Pin;
diff --git a/tests/ui/object-safety/issue-102762.stderr b/tests/ui/dyn-compatibility/undispatchable-receiver-and-wc-references-Self.stderr
similarity index 87%
rename from tests/ui/object-safety/issue-102762.stderr
rename to tests/ui/dyn-compatibility/undispatchable-receiver-and-wc-references-Self.stderr
index 05451eb8399cf..8d62ac9d923f9 100644
--- a/tests/ui/object-safety/issue-102762.stderr
+++ b/tests/ui/dyn-compatibility/undispatchable-receiver-and-wc-references-Self.stderr
@@ -1,5 +1,5 @@
 error[E0038]: the trait `Fetcher` cannot be made into an object
-  --> $DIR/issue-102762.rs:18:21
+  --> $DIR/undispatchable-receiver-and-wc-references-Self.rs:19:21
    |
 LL |     fn get<'a>(self: &'a Box<Self>) -> Pin<Box<dyn Future<Output = Vec<u8>> + 'a>>
    |                      ------------- help: consider changing method `get`'s `self` parameter to be `&self`: `&Self`
@@ -8,7 +8,7 @@ LL | fn fetcher() -> Box<dyn Fetcher> {
    |                     ^^^^^^^^^^^ `Fetcher` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/issue-102762.rs:10:22
+  --> $DIR/undispatchable-receiver-and-wc-references-Self.rs:11:22
    |
 LL | pub trait Fetcher: Send + Sync {
    |           ------- this trait cannot be made into an object...
@@ -16,7 +16,7 @@ LL |     fn get<'a>(self: &'a Box<Self>) -> Pin<Box<dyn Future<Output = Vec<u8>>
    |                      ^^^^^^^^^^^^^ ...because method `get`'s `self` parameter cannot be dispatched on
 
 error[E0038]: the trait `Fetcher` cannot be made into an object
-  --> $DIR/issue-102762.rs:24:19
+  --> $DIR/undispatchable-receiver-and-wc-references-Self.rs:25:19
    |
 LL |     fn get<'a>(self: &'a Box<Self>) -> Pin<Box<dyn Future<Output = Vec<u8>> + 'a>>
    |                      ------------- help: consider changing method `get`'s `self` parameter to be `&self`: `&Self`
@@ -25,7 +25,7 @@ LL |     let fetcher = fetcher();
    |                   ^^^^^^^^^ `Fetcher` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/issue-102762.rs:10:22
+  --> $DIR/undispatchable-receiver-and-wc-references-Self.rs:11:22
    |
 LL | pub trait Fetcher: Send + Sync {
    |           ------- this trait cannot be made into an object...
@@ -33,7 +33,7 @@ LL |     fn get<'a>(self: &'a Box<Self>) -> Pin<Box<dyn Future<Output = Vec<u8>>
    |                      ^^^^^^^^^^^^^ ...because method `get`'s `self` parameter cannot be dispatched on
 
 error[E0038]: the trait `Fetcher` cannot be made into an object
-  --> $DIR/issue-102762.rs:26:13
+  --> $DIR/undispatchable-receiver-and-wc-references-Self.rs:27:13
    |
 LL |     fn get<'a>(self: &'a Box<Self>) -> Pin<Box<dyn Future<Output = Vec<u8>> + 'a>>
    |                      ------------- help: consider changing method `get`'s `self` parameter to be `&self`: `&Self`
@@ -42,7 +42,7 @@ LL |     let _ = fetcher.get();
    |             ^^^^^^^^^^^^^ `Fetcher` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/issue-102762.rs:10:22
+  --> $DIR/undispatchable-receiver-and-wc-references-Self.rs:11:22
    |
 LL | pub trait Fetcher: Send + Sync {
    |           ------- this trait cannot be made into an object...
diff --git a/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-missing-impl.rs b/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-missing-impl.rs
index 23857cbaca85e..3c9e903d4ba00 100644
--- a/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-missing-impl.rs
+++ b/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-missing-impl.rs
@@ -1,4 +1,4 @@
-// Check that a self parameter type requires a DispatchFromDyn impl to be object safe
+// Check that a self parameter type requires a DispatchFromDyn impl to be dyn-compatible.
 
 #![feature(arbitrary_self_types, unsize, coerce_unsized)]
 
diff --git a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.rs b/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.rs
index 2dbba370a51e5..e38ab66dbe549 100644
--- a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.rs
+++ b/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.rs
@@ -15,20 +15,20 @@ trait DynIncompatible4 {
     fn foo(&self, s: &Self);
 }
 
-fn takes_non_object_safe_ref<T>(obj: &dyn DynIncompatible1) {
+fn takes_dyn_incompatible_ref<T>(obj: &dyn DynIncompatible1) {
     //~^ ERROR E0038
 }
 
-fn return_non_object_safe_ref() -> &'static dyn DynIncompatible2 {
+fn return_dyn_incompatible_ref() -> &'static dyn DynIncompatible2 {
     //~^ ERROR E0038
     loop {}
 }
 
-fn takes_non_object_safe_box(obj: Box<dyn DynIncompatible3>) {
+fn takes_dyn_incompatible_box(obj: Box<dyn DynIncompatible3>) {
     //~^ ERROR E0038
 }
 
-fn return_non_object_safe_rc() -> std::rc::Rc<dyn DynIncompatible4> {
+fn return_dyn_incompatible_rc() -> std::rc::Rc<dyn DynIncompatible4> {
     //~^ ERROR E0038
     loop {}
 }
diff --git a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.stderr b/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.stderr
index 3cb73dfd52c68..ed021c154a5b8 100644
--- a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.stderr
@@ -1,8 +1,8 @@
 error[E0038]: the trait `DynIncompatible1` cannot be made into an object
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:18:39
+  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:18:40
    |
-LL | fn takes_non_object_safe_ref<T>(obj: &dyn DynIncompatible1) {
-   |                                       ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible1` cannot be made into an object
+LL | fn takes_dyn_incompatible_ref<T>(obj: &dyn DynIncompatible1) {
+   |                                        ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible1` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:4:25
@@ -13,10 +13,10 @@ LL | trait DynIncompatible1: Sized {}
    |       this trait cannot be made into an object...
 
 error[E0038]: the trait `DynIncompatible2` cannot be made into an object
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:22:45
+  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:22:46
    |
-LL | fn return_non_object_safe_ref() -> &'static dyn DynIncompatible2 {
-   |                                             ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible2` cannot be made into an object
+LL | fn return_dyn_incompatible_ref() -> &'static dyn DynIncompatible2 {
+   |                                              ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible2` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:7:8
@@ -35,10 +35,10 @@ LL |     fn static_fn() where Self: Sized {}
    |                    +++++++++++++++++
 
 error[E0038]: the trait `DynIncompatible3` cannot be made into an object
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:27:39
+  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:27:40
    |
-LL | fn takes_non_object_safe_box(obj: Box<dyn DynIncompatible3>) {
-   |                                       ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible3` cannot be made into an object
+LL | fn takes_dyn_incompatible_box(obj: Box<dyn DynIncompatible3>) {
+   |                                        ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible3` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:11:8
@@ -50,10 +50,10 @@ LL |     fn foo<T>(&self);
    = help: consider moving `foo` to another trait
 
 error[E0038]: the trait `DynIncompatible4` cannot be made into an object
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:31:47
+  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:31:48
    |
-LL | fn return_non_object_safe_rc() -> std::rc::Rc<dyn DynIncompatible4> {
-   |                                               ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible4` cannot be made into an object
+LL | fn return_dyn_incompatible_rc() -> std::rc::Rc<dyn DynIncompatible4> {
+   |                                                ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible4` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:15:22
diff --git a/tests/ui/generic-associated-types/trait-objects.rs b/tests/ui/generic-associated-types/trait-objects.rs
index 277ffcc1f0dd3..743a3df0acc81 100644
--- a/tests/ui/generic-associated-types/trait-objects.rs
+++ b/tests/ui/generic-associated-types/trait-objects.rs
@@ -6,7 +6,7 @@
 trait StreamingIterator {
     type Item<'a> where Self: 'a;
     fn size_hint(&self) -> (usize, Option<usize>);
-    // Uncommenting makes `StreamingIterator` not object safe
+    // Uncommenting makes `StreamingIterator` dyn-incompatible.
 //    fn next(&mut self) -> Self::Item<'_>;
 }
 
diff --git a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.rs b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.rs
similarity index 59%
rename from tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.rs
rename to tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.rs
index 068f7d3eea6da..76dbb05f53d66 100644
--- a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.rs
+++ b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.rs
@@ -1,24 +1,25 @@
 #![allow(bare_trait_objects)]
-trait NotObjectSafe {
+
+trait DynIncompatible {
     fn foo() -> Self;
 }
 
 struct A;
 struct B;
 
-impl NotObjectSafe for A {
+impl DynIncompatible for A {
     fn foo() -> Self {
         A
     }
 }
 
-impl NotObjectSafe for B {
+impl DynIncompatible for B {
     fn foo() -> Self {
         B
     }
 }
 
-fn car() -> dyn NotObjectSafe { //~ ERROR the trait `NotObjectSafe` cannot be made into an object
+fn car() -> dyn DynIncompatible { //~ ERROR the trait `DynIncompatible` cannot be made into an object
 //~^ ERROR return type cannot have an unboxed trait object
     if true {
         return A;
@@ -26,7 +27,7 @@ fn car() -> dyn NotObjectSafe { //~ ERROR the trait `NotObjectSafe` cannot be ma
     B
 }
 
-fn cat() -> Box<dyn NotObjectSafe> { //~ ERROR the trait `NotObjectSafe` cannot be made into an
+fn cat() -> Box<dyn DynIncompatible> { //~ ERROR the trait `DynIncompatible` cannot be made into an
     if true {
         return Box::new(A); //~ ERROR cannot be made into an object
     }
diff --git a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.stderr b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.stderr
similarity index 62%
rename from tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.stderr
rename to tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.stderr
index 2a36824e29254..576bd909cbc7d 100644
--- a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.stderr
+++ b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.stderr
@@ -1,17 +1,17 @@
-error[E0038]: the trait `NotObjectSafe` cannot be made into an object
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:21:13
+error[E0038]: the trait `DynIncompatible` cannot be made into an object
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:13
    |
-LL | fn car() -> dyn NotObjectSafe {
-   |             ^^^^^^^^^^^^^^^^^ `NotObjectSafe` cannot be made into an object
+LL | fn car() -> dyn DynIncompatible {
+   |             ^^^^^^^^^^^^^^^^^^^ `DynIncompatible` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:3:8
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
    |
-LL | trait NotObjectSafe {
-   |       ------------- this trait cannot be made into an object...
+LL | trait DynIncompatible {
+   |       --------------- this trait cannot be made into an object...
 LL |     fn foo() -> Self;
    |        ^^^ ...because associated function `foo` has no `self` parameter
-   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `NotObjectSafe` for this new enum and using it instead:
+   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `DynIncompatible` for this new enum and using it instead:
              A
              B
 help: consider turning `foo` into a method by giving it a `&self` argument
@@ -23,20 +23,20 @@ help: alternatively, consider constraining `foo` so it does not apply to trait o
 LL |     fn foo() -> Self where Self: Sized;
    |                      +++++++++++++++++
 
-error[E0038]: the trait `NotObjectSafe` cannot be made into an object
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:29:17
+error[E0038]: the trait `DynIncompatible` cannot be made into an object
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:30:17
    |
-LL | fn cat() -> Box<dyn NotObjectSafe> {
-   |                 ^^^^^^^^^^^^^^^^^ `NotObjectSafe` cannot be made into an object
+LL | fn cat() -> Box<dyn DynIncompatible> {
+   |                 ^^^^^^^^^^^^^^^^^^^ `DynIncompatible` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:3:8
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
    |
-LL | trait NotObjectSafe {
-   |       ------------- this trait cannot be made into an object...
+LL | trait DynIncompatible {
+   |       --------------- this trait cannot be made into an object...
 LL |     fn foo() -> Self;
    |        ^^^ ...because associated function `foo` has no `self` parameter
-   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `NotObjectSafe` for this new enum and using it instead:
+   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `DynIncompatible` for this new enum and using it instead:
              A
              B
 help: consider turning `foo` into a method by giving it a `&self` argument
@@ -49,15 +49,15 @@ LL |     fn foo() -> Self where Self: Sized;
    |                      +++++++++++++++++
 
 error[E0746]: return type cannot have an unboxed trait object
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:21:13
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:13
    |
-LL | fn car() -> dyn NotObjectSafe {
-   |             ^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+LL | fn car() -> dyn DynIncompatible {
+   |             ^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
-LL ~ fn car() -> Box<dyn NotObjectSafe> {
+LL ~ fn car() -> Box<dyn DynIncompatible> {
 LL |
 LL |     if true {
 LL ~         return Box::new(A);
@@ -65,23 +65,23 @@ LL |     }
 LL ~     Box::new(B)
    |
 
-error[E0038]: the trait `NotObjectSafe` cannot be made into an object
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:31:16
+error[E0038]: the trait `DynIncompatible` cannot be made into an object
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:32:16
    |
 LL |         return Box::new(A);
-   |                ^^^^^^^^^^^ `NotObjectSafe` cannot be made into an object
+   |                ^^^^^^^^^^^ `DynIncompatible` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:3:8
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
    |
-LL | trait NotObjectSafe {
-   |       ------------- this trait cannot be made into an object...
+LL | trait DynIncompatible {
+   |       --------------- this trait cannot be made into an object...
 LL |     fn foo() -> Self;
    |        ^^^ ...because associated function `foo` has no `self` parameter
-   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `NotObjectSafe` for this new enum and using it instead:
+   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `DynIncompatible` for this new enum and using it instead:
              A
              B
-   = note: required for the cast from `Box<A>` to `Box<(dyn NotObjectSafe + 'static)>`
+   = note: required for the cast from `Box<A>` to `Box<(dyn DynIncompatible + 'static)>`
 help: consider turning `foo` into a method by giving it a `&self` argument
    |
 LL |     fn foo(&self) -> Self;
@@ -91,23 +91,23 @@ help: alternatively, consider constraining `foo` so it does not apply to trait o
 LL |     fn foo() -> Self where Self: Sized;
    |                      +++++++++++++++++
 
-error[E0038]: the trait `NotObjectSafe` cannot be made into an object
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:33:5
+error[E0038]: the trait `DynIncompatible` cannot be made into an object
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:34:5
    |
 LL |     Box::new(B)
-   |     ^^^^^^^^^^^ `NotObjectSafe` cannot be made into an object
+   |     ^^^^^^^^^^^ `DynIncompatible` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-in-return-position-dyn-trait.rs:3:8
+  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
    |
-LL | trait NotObjectSafe {
-   |       ------------- this trait cannot be made into an object...
+LL | trait DynIncompatible {
+   |       --------------- this trait cannot be made into an object...
 LL |     fn foo() -> Self;
    |        ^^^ ...because associated function `foo` has no `self` parameter
-   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `NotObjectSafe` for this new enum and using it instead:
+   = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `DynIncompatible` for this new enum and using it instead:
              A
              B
-   = note: required for the cast from `Box<B>` to `Box<(dyn NotObjectSafe + 'static)>`
+   = note: required for the cast from `Box<B>` to `Box<(dyn DynIncompatible + 'static)>`
 help: consider turning `foo` into a method by giving it a `&self` argument
    |
 LL |     fn foo(&self) -> Self;
diff --git a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-impl-trait.rs b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-impl-trait.rs
similarity index 61%
rename from tests/ui/impl-trait/object-unsafe-trait-in-return-position-impl-trait.rs
rename to tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-impl-trait.rs
index 503515013b9ab..25a901e4ff350 100644
--- a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-impl-trait.rs
+++ b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-impl-trait.rs
@@ -1,42 +1,42 @@
-trait NotObjectSafe {
+trait DynIncompatible {
     fn foo() -> Self;
 }
 
-trait ObjectSafe {
+trait DynCompatible {
     fn bar(&self);
 }
 
 struct A;
 struct B;
 
-impl NotObjectSafe for A {
+impl DynIncompatible for A {
     fn foo() -> Self {
         A
     }
 }
 
-impl NotObjectSafe for B {
+impl DynIncompatible for B {
     fn foo() -> Self {
         B
     }
 }
 
-impl ObjectSafe for A {
+impl DynCompatible for A {
     fn bar(&self) {}
 }
 
-impl ObjectSafe for B {
+impl DynCompatible for B {
     fn bar(&self) {}
 }
 
-fn can() -> impl NotObjectSafe {
+fn can() -> impl DynIncompatible {
     if true {
         return A;
     }
     B //~ ERROR mismatched types
 }
 
-fn cat() -> impl ObjectSafe {
+fn cat() -> impl DynCompatible {
     if true {
         return A;
     }
diff --git a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-impl-trait.stderr b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-impl-trait.stderr
similarity index 54%
rename from tests/ui/impl-trait/object-unsafe-trait-in-return-position-impl-trait.stderr
rename to tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-impl-trait.stderr
index e5147bcea1662..6a485881bfccb 100644
--- a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-impl-trait.stderr
+++ b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-impl-trait.stderr
@@ -1,17 +1,17 @@
 error[E0308]: mismatched types
-  --> $DIR/object-unsafe-trait-in-return-position-impl-trait.rs:36:5
+  --> $DIR/dyn-incompatible-trait-in-return-position-impl-trait.rs:36:5
    |
-LL | fn can() -> impl NotObjectSafe {
-   |             ------------------ expected `A` because of return type
+LL | fn can() -> impl DynIncompatible {
+   |             -------------------- expected `A` because of return type
 ...
 LL |     B
    |     ^ expected `A`, found `B`
 
 error[E0308]: mismatched types
-  --> $DIR/object-unsafe-trait-in-return-position-impl-trait.rs:43:5
+  --> $DIR/dyn-incompatible-trait-in-return-position-impl-trait.rs:43:5
    |
-LL | fn cat() -> impl ObjectSafe {
-   |             --------------- expected `A` because of return type
+LL | fn cat() -> impl DynCompatible {
+   |             ------------------ expected `A` because of return type
 ...
 LL |     B
    |     ^ expected `A`, found `B`
diff --git a/tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-object-safety.rs b/tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-dyn-compatibility-check.rs
similarity index 100%
rename from tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-object-safety.rs
rename to tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-dyn-compatibility-check.rs
diff --git a/tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-object-safety.stderr b/tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-dyn-compatibility-check.stderr
similarity index 82%
rename from tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-object-safety.stderr
rename to tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-dyn-compatibility-check.stderr
index af624e2a75871..a975b6204aa5a 100644
--- a/tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-object-safety.stderr
+++ b/tests/ui/impl-trait/in-trait/cycle-effective-visibilities-during-dyn-compatibility-check.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `&dyn MyTrait: MyTrait` is not satisfied
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:20:22
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:20:22
    |
 LL |         MyTrait::foo(&self)
    |         ------------ ^^^^^ the trait `MyTrait` is not implemented for `&dyn MyTrait`
@@ -9,13 +9,13 @@ LL |         MyTrait::foo(&self)
    = help: the trait `MyTrait` is implemented for `Outer`
 
 error[E0038]: the trait `MyTrait` cannot be made into an object
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:20:9
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:20:9
    |
 LL |         MyTrait::foo(&self)
    |         ^^^^^^^^^^^^ `MyTrait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:5:22
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:5:22
    |
 LL | trait MyTrait {
    |       ------- this trait cannot be made into an object...
@@ -25,7 +25,7 @@ LL |     fn foo(&self) -> impl Marker;
    = help: only type `Outer` implements the trait, consider using it directly instead
 
 error[E0277]: the trait bound `&dyn MyTrait: MyTrait` is not satisfied
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:20:9
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:20:9
    |
 LL |         MyTrait::foo(&self)
    |         ^^^^^^^^^^^^^^^^^^^ the trait `MyTrait` is not implemented for `&dyn MyTrait`
@@ -33,13 +33,13 @@ LL |         MyTrait::foo(&self)
    = help: the trait `MyTrait` is implemented for `Outer`
 
 error[E0038]: the trait `MyTrait` cannot be made into an object
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:16:6
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:16:6
    |
 LL | impl dyn MyTrait {
    |      ^^^^^^^^^^^ `MyTrait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:5:22
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:5:22
    |
 LL | trait MyTrait {
    |       ------- this trait cannot be made into an object...
@@ -49,13 +49,13 @@ LL |     fn foo(&self) -> impl Marker;
    = help: only type `Outer` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `MyTrait` cannot be made into an object
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:18:15
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:18:15
    |
 LL |     fn other(&self) -> impl Marker {
    |               ^^^^ `MyTrait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/cycle-effective-visibilities-during-object-safety.rs:5:22
+  --> $DIR/cycle-effective-visibilities-during-dyn-compatibility-check.rs:5:22
    |
 LL | trait MyTrait {
    |       ------- this trait cannot be made into an object...
diff --git a/tests/ui/impl-trait/in-trait/object-safety-sized.rs b/tests/ui/impl-trait/in-trait/dyn-compatibility-sized.rs
similarity index 100%
rename from tests/ui/impl-trait/in-trait/object-safety-sized.rs
rename to tests/ui/impl-trait/in-trait/dyn-compatibility-sized.rs
diff --git a/tests/ui/impl-trait/in-trait/object-safety.rs b/tests/ui/impl-trait/in-trait/dyn-compatibility.rs
similarity index 100%
rename from tests/ui/impl-trait/in-trait/object-safety.rs
rename to tests/ui/impl-trait/in-trait/dyn-compatibility.rs
diff --git a/tests/ui/impl-trait/in-trait/object-safety.stderr b/tests/ui/impl-trait/in-trait/dyn-compatibility.stderr
similarity index 91%
rename from tests/ui/impl-trait/in-trait/object-safety.stderr
rename to tests/ui/impl-trait/in-trait/dyn-compatibility.stderr
index e2f23bca621c6..115cb014b8c34 100644
--- a/tests/ui/impl-trait/in-trait/object-safety.stderr
+++ b/tests/ui/impl-trait/in-trait/dyn-compatibility.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety.rs:14:33
+  --> $DIR/dyn-compatibility.rs:14:33
    |
 LL |     let i = Box::new(42_u32) as Box<dyn Foo>;
    |                                 ^^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety.rs:4:22
+  --> $DIR/dyn-compatibility.rs:4:22
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -15,13 +15,13 @@ LL |     fn baz(&self) -> impl Debug;
    = help: only type `u32` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety.rs:17:15
+  --> $DIR/dyn-compatibility.rs:17:15
    |
 LL |     let s = i.baz();
    |               ^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety.rs:4:22
+  --> $DIR/dyn-compatibility.rs:4:22
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -31,13 +31,13 @@ LL |     fn baz(&self) -> impl Debug;
    = help: only type `u32` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety.rs:17:13
+  --> $DIR/dyn-compatibility.rs:17:13
    |
 LL |     let s = i.baz();
    |             ^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety.rs:4:22
+  --> $DIR/dyn-compatibility.rs:4:22
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -47,13 +47,13 @@ LL |     fn baz(&self) -> impl Debug;
    = help: only type `u32` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety.rs:14:13
+  --> $DIR/dyn-compatibility.rs:14:13
    |
 LL |     let i = Box::new(42_u32) as Box<dyn Foo>;
    |             ^^^^^^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-safety.rs:4:22
+  --> $DIR/dyn-compatibility.rs:4:22
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/issues/issue-58734.rs b/tests/ui/issues/issue-58734.rs
index c838fde5d73b6..9b630666baf85 100644
--- a/tests/ui/issues/issue-58734.rs
+++ b/tests/ui/issues/issue-58734.rs
@@ -1,22 +1,22 @@
 trait Trait {
     fn exists(self) -> ();
 
-    fn not_object_safe() -> Self;
+    fn dyn_incompatible() -> Self;
 }
 
 impl Trait for () {
     fn exists(self) -> () {
     }
 
-    fn not_object_safe() -> Self {
+    fn dyn_incompatible() -> Self {
         ()
     }
 }
 
 fn main() {
-    // object-safe or not, this call is OK
+    // dyn-compatible or not, this call is OK
     Trait::exists(());
-    // no object safety error
+    // no dyn-compatibility error
     Trait::nonexistent(());
     //~^ ERROR no function or associated item named `nonexistent` found
     //~| WARN trait objects without an explicit `dyn` are deprecated
diff --git a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/downcast-unsafe-trait-objects.rs b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/downcast-unsafe-trait-objects.rs
index e9206789756e7..b1b2dcf3eb9fd 100644
--- a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/downcast-unsafe-trait-objects.rs
+++ b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/downcast-unsafe-trait-objects.rs
@@ -1,4 +1,4 @@
-// Check that we if we get ahold of an object unsafe trait
+// Check that we if we get ahold of a dyn-incompatible trait
 // object with auto traits and lifetimes, we can downcast it
 //
 //@ check-pass
diff --git a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.rs b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.rs
index 37e6f948ad118..425dc130d4587 100644
--- a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.rs
+++ b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.rs
@@ -1,4 +1,4 @@
-// Check that we can manually implement an object-unsafe trait for its trait object.
+// Check that we can manually implement a dyn-incompatible trait for its trait object.
 
 //@ revisions: current next
 //@ ignore-compare-mode-next-solver (explicit revisions)
diff --git a/tests/ui/sanitizer/cfi/async-closures.rs b/tests/ui/sanitizer/cfi/async-closures.rs
index d94f2992d8428..4eaa44cfa3f47 100644
--- a/tests/ui/sanitizer/cfi/async-closures.rs
+++ b/tests/ui/sanitizer/cfi/async-closures.rs
@@ -21,7 +21,7 @@ use std::ops::AsyncFn;
 #[inline(never)]
 fn identity<T>(x: T) -> T { x }
 
-// We can't actually create a `dyn AsyncFn()`, because it's not object-safe, but we should check
+// We can't actually create a `dyn AsyncFn()`, because it's dyn-incompatible, but we should check
 // that we don't bug out when we encounter one.
 
 fn main() {
diff --git a/tests/ui/self/arbitrary-self-types-not-object-safe.curr.stderr b/tests/ui/self/arbitrary-self-types-dyn-incompatible.curr.stderr
similarity index 89%
rename from tests/ui/self/arbitrary-self-types-not-object-safe.curr.stderr
rename to tests/ui/self/arbitrary-self-types-dyn-incompatible.curr.stderr
index e2d73fc08f6d7..2eb7597d5c105 100644
--- a/tests/ui/self/arbitrary-self-types-not-object-safe.curr.stderr
+++ b/tests/ui/self/arbitrary-self-types-dyn-incompatible.curr.stderr
@@ -1,5 +1,5 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/arbitrary-self-types-not-object-safe.rs:33:32
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:33:32
    |
 LL |     fn foo(self: &Rc<Self>) -> usize;
    |                  --------- help: consider changing method `foo`'s `self` parameter to be `&self`: `&Self`
@@ -8,7 +8,7 @@ LL |     let x = Rc::new(5usize) as Rc<dyn Foo>;
    |                                ^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/arbitrary-self-types-not-object-safe.rs:8:18
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:8:18
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
@@ -17,7 +17,7 @@ LL |     fn foo(self: &Rc<Self>) -> usize;
    = help: only type `usize` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/arbitrary-self-types-not-object-safe.rs:33:13
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:33:13
    |
 LL |     fn foo(self: &Rc<Self>) -> usize;
    |                  --------- help: consider changing method `foo`'s `self` parameter to be `&self`: `&Self`
@@ -26,7 +26,7 @@ LL |     let x = Rc::new(5usize) as Rc<dyn Foo>;
    |             ^^^^^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/arbitrary-self-types-not-object-safe.rs:8:18
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:8:18
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/self/arbitrary-self-types-not-object-safe.dyn_compatible_for_dispatch.stderr b/tests/ui/self/arbitrary-self-types-dyn-incompatible.dyn_compatible_for_dispatch.stderr
similarity index 90%
rename from tests/ui/self/arbitrary-self-types-not-object-safe.dyn_compatible_for_dispatch.stderr
rename to tests/ui/self/arbitrary-self-types-dyn-incompatible.dyn_compatible_for_dispatch.stderr
index fda07765c6620..02af692c4a352 100644
--- a/tests/ui/self/arbitrary-self-types-not-object-safe.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/self/arbitrary-self-types-dyn-incompatible.dyn_compatible_for_dispatch.stderr
@@ -1,5 +1,5 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/arbitrary-self-types-not-object-safe.rs:33:13
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:33:13
    |
 LL |     fn foo(self: &Rc<Self>) -> usize;
    |                  --------- help: consider changing method `foo`'s `self` parameter to be `&self`: `&Self`
@@ -8,7 +8,7 @@ LL |     let x = Rc::new(5usize) as Rc<dyn Foo>;
    |             ^^^^^^^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/arbitrary-self-types-not-object-safe.rs:8:18
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:8:18
    |
 LL | trait Foo {
    |       --- this trait cannot be made into an object...
diff --git a/tests/ui/self/arbitrary-self-types-not-object-safe.rs b/tests/ui/self/arbitrary-self-types-dyn-incompatible.rs
similarity index 100%
rename from tests/ui/self/arbitrary-self-types-not-object-safe.rs
rename to tests/ui/self/arbitrary-self-types-dyn-incompatible.rs
diff --git a/tests/ui/self/arbitrary_self_types_pointers_and_wrappers.rs b/tests/ui/self/arbitrary_self_types_pointers_and_wrappers.rs
index d7149002e7bca..76d7754384ebe 100644
--- a/tests/ui/self/arbitrary_self_types_pointers_and_wrappers.rs
+++ b/tests/ui/self/arbitrary_self_types_pointers_and_wrappers.rs
@@ -50,9 +50,9 @@ impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<Wrapper<U>> for Wrapper<T> {}
 
 
 trait Trait {
-    // This method isn't object-safe yet. Unsized by-value `self` is object-safe (but not callable
-    // without unsized_locals), but wrappers arond `Self` currently are not.
-    // FIXME (mikeyhew) uncomment this when unsized rvalues object-safety is implemented
+    // This method isn't dyn-compatible yet. Unsized by-value `self` is dyn-compatible (but not
+    // callable without unsized_locals), but wrappers arond `Self` currently are not.
+    // FIXME (mikeyhew) uncomment this when unsized rvalues dyn-compatibility is implemented
     // fn wrapper(self: Wrapper<Self>) -> i32;
     fn ptr_wrapper(self: Ptr<Wrapper<Self>>) -> i32;
     fn wrapper_ptr(self: Wrapper<Ptr<Self>>) -> i32;
diff --git a/tests/ui/self/object-safety-sized-self-by-value-self.rs b/tests/ui/self/dyn-compatibility-sized-self-by-value-self.rs
similarity index 90%
rename from tests/ui/self/object-safety-sized-self-by-value-self.rs
rename to tests/ui/self/dyn-compatibility-sized-self-by-value-self.rs
index d902812eb9a67..658371c95e2f5 100644
--- a/tests/ui/self/object-safety-sized-self-by-value-self.rs
+++ b/tests/ui/self/dyn-compatibility-sized-self-by-value-self.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 #![allow(unused_mut)]
-// Check that a trait is still object-safe (and usable) if it has
+// Check that a trait is still dyn-compatible (and usable) if it has
 // methods with by-value self so long as they require `Self : Sized`.
 
 
diff --git a/tests/ui/self/object-safety-sized-self-generic-method.rs b/tests/ui/self/dyn-compatibility-sized-self-generic-method.rs
similarity index 90%
rename from tests/ui/self/object-safety-sized-self-generic-method.rs
rename to tests/ui/self/dyn-compatibility-sized-self-generic-method.rs
index 7a2ebd2cb7935..a7b5013694ff2 100644
--- a/tests/ui/self/object-safety-sized-self-generic-method.rs
+++ b/tests/ui/self/dyn-compatibility-sized-self-generic-method.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 #![allow(unused_variables)]
-// Check that a trait is still object-safe (and usable) if it has
+// Check that a trait is still dyn-compatible (and usable) if it has
 // generic methods so long as they require `Self : Sized`.
 
 
diff --git a/tests/ui/self/object-safety-sized-self-return-Self.rs b/tests/ui/self/dyn-compatibility-sized-self-return-Self.rs
similarity index 90%
rename from tests/ui/self/object-safety-sized-self-return-Self.rs
rename to tests/ui/self/dyn-compatibility-sized-self-return-Self.rs
index 9fc3f85677223..a15f4fd781360 100644
--- a/tests/ui/self/object-safety-sized-self-return-Self.rs
+++ b/tests/ui/self/dyn-compatibility-sized-self-return-Self.rs
@@ -1,5 +1,5 @@
 //@ run-pass
-// Check that a trait is still object-safe (and usable) if it has
+// Check that a trait is still dyn-compatible (and usable) if it has
 // methods that return `Self` so long as they require `Self : Sized`.
 
 
diff --git a/tests/ui/specialization/issue-44861.rs b/tests/ui/specialization/issue-44861.rs
index 79d9b9490d09d..9d6517e613a22 100644
--- a/tests/ui/specialization/issue-44861.rs
+++ b/tests/ui/specialization/issue-44861.rs
@@ -12,9 +12,9 @@ pub trait Smartass {
     type Data2: CoerceUnsized<*const [u8]>;
 }
 
-pub trait MaybeObjectSafe {}
+pub trait MaybeDynCompatible {}
 
-impl MaybeObjectSafe for () {}
+impl MaybeDynCompatible for () {}
 
 impl<T> Smartass for T {
     type Data = <Self as Smartass>::Data2;
@@ -26,7 +26,7 @@ impl Smartass for () {
     type Data2 = *const [u8; 1];
 }
 
-impl Smartass for dyn MaybeObjectSafe {
+impl Smartass for dyn MaybeDynCompatible {
     type Data = *const [u8];
     type Data2 = *const [u8; 0];
 }
@@ -35,6 +35,6 @@ impl<U: Smartass+?Sized, T: Smartass+?Sized> CoerceUnsized<SmartassPtr<T>> for S
     where <U as Smartass>::Data: std::ops::CoerceUnsized<<T as Smartass>::Data>
 {}
 
-pub fn conv(s: SmartassPtr<()>) -> SmartassPtr<dyn MaybeObjectSafe> {
+pub fn conv(s: SmartassPtr<()>) -> SmartassPtr<dyn MaybeDynCompatible> {
     s
 }
diff --git a/tests/ui/suggestions/auxiliary/not-object-safe.rs b/tests/ui/suggestions/auxiliary/dyn-incompatible.rs
similarity index 100%
rename from tests/ui/suggestions/auxiliary/not-object-safe.rs
rename to tests/ui/suggestions/auxiliary/dyn-incompatible.rs
diff --git a/tests/ui/suggestions/object-unsafe-trait-references-self.rs b/tests/ui/suggestions/dyn-incompatible-trait-references-self.rs
similarity index 100%
rename from tests/ui/suggestions/object-unsafe-trait-references-self.rs
rename to tests/ui/suggestions/dyn-incompatible-trait-references-self.rs
diff --git a/tests/ui/suggestions/object-unsafe-trait-references-self.stderr b/tests/ui/suggestions/dyn-incompatible-trait-references-self.stderr
similarity index 87%
rename from tests/ui/suggestions/object-unsafe-trait-references-self.stderr
rename to tests/ui/suggestions/dyn-incompatible-trait-references-self.stderr
index c00bb3efbf640..242c44abd9d66 100644
--- a/tests/ui/suggestions/object-unsafe-trait-references-self.stderr
+++ b/tests/ui/suggestions/dyn-incompatible-trait-references-self.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/object-unsafe-trait-references-self.rs:9:12
+  --> $DIR/dyn-incompatible-trait-references-self.rs:9:12
    |
 LL | fn bar(x: &dyn Trait) {}
    |            ^^^^^^^^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-references-self.rs:2:22
+  --> $DIR/dyn-incompatible-trait-references-self.rs:2:22
    |
 LL | trait Trait {
    |       ----- this trait cannot be made into an object...
@@ -18,13 +18,13 @@ LL |     fn bat(&self) -> Self {}
    = help: consider moving `bat` to another trait
 
 error[E0038]: the trait `Other` cannot be made into an object
-  --> $DIR/object-unsafe-trait-references-self.rs:13:12
+  --> $DIR/dyn-incompatible-trait-references-self.rs:13:12
    |
 LL | fn foo(x: &dyn Other) {}
    |            ^^^^^^^^^ `Other` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-references-self.rs:11:14
+  --> $DIR/dyn-incompatible-trait-references-self.rs:11:14
    |
 LL | trait Other: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
@@ -32,7 +32,7 @@ LL | trait Other: Sized {}
    |       this trait cannot be made into an object...
 
 error[E0277]: the size for values of type `Self` cannot be known at compilation time
-  --> $DIR/object-unsafe-trait-references-self.rs:2:22
+  --> $DIR/dyn-incompatible-trait-references-self.rs:2:22
    |
 LL |     fn baz(&self, _: Self) {}
    |                      ^^^^ doesn't have a size known at compile-time
@@ -48,7 +48,7 @@ LL |     fn baz(&self, _: &Self) {}
    |                      +
 
 error[E0308]: mismatched types
-  --> $DIR/object-unsafe-trait-references-self.rs:4:27
+  --> $DIR/dyn-incompatible-trait-references-self.rs:4:27
    |
 LL | trait Trait {
    | ----------- expected this type parameter
@@ -60,7 +60,7 @@ LL |     fn bat(&self) -> Self {}
                    found unit type `()`
 
 error[E0277]: the size for values of type `Self` cannot be known at compilation time
-  --> $DIR/object-unsafe-trait-references-self.rs:4:22
+  --> $DIR/dyn-incompatible-trait-references-self.rs:4:22
    |
 LL |     fn bat(&self) -> Self {}
    |                      ^^^^ doesn't have a size known at compile-time
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.rs b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs
similarity index 100%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.rs
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.stderr b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.stderr
similarity index 83%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.stderr
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.stderr
index a17f821ebec48..5330438258488 100644
--- a/tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.stderr
+++ b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.stderr
@@ -1,5 +1,5 @@
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:4:13
    |
 LL | trait A: Sized {
    |       - in this trait
@@ -12,13 +12,13 @@ LL |     fn f(a: Self) -> Self;
    |             ~~~~     ~~~~
 
 error[E0038]: the trait `A` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:4:13
    |
 LL |     fn f(a: A) -> A;
    |             ^ `A` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:3:10
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:3:10
    |
 LL | trait A: Sized {
    |       -  ^^^^^ ...because it requires `Self: Sized`
@@ -26,7 +26,7 @@ LL | trait A: Sized {
    |       this trait cannot be made into an object...
 
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:13
    |
 LL | trait B {
    |       - in this trait
@@ -39,13 +39,13 @@ LL |     fn f(b: Self) -> Self;
    |             ~~~~     ~~~~
 
 error[E0038]: the trait `B` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:13
    |
 LL |     fn f(b: B) -> B;
    |             ^ `B` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:8
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:8
    |
 LL | trait B {
    |       - this trait cannot be made into an object...
@@ -61,7 +61,7 @@ LL |     fn f(b: B) -> B where Self: Sized;
    |                     +++++++++++++++++
 
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:20
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:20
    |
 LL | trait C {
    |       - in this trait
@@ -74,7 +74,7 @@ LL |     fn f(&self, c: Self) -> Self;
    |                    ~~~~     ~~~~
 
 error[E0038]: the trait `C` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:20
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:20
    |
 LL |     fn f(&self, c: C) -> C;
    |          -----     ^ `C` cannot be made into an object
@@ -82,7 +82,7 @@ LL |     fn f(&self, c: C) -> C;
    |          help: consider changing method `f`'s `self` parameter to be `&self` (notice the capitalization): `&Self`
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:10
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:10
    |
 LL | trait C {
    |       - this trait cannot be made into an object...
@@ -90,7 +90,7 @@ LL |     fn f(&self, c: C) -> C;
    |          ^^^^^ ...because method `f`'s `self` parameter cannot be dispatched on
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:4:13
    |
 LL |     fn f(a: A) -> A;
    |             ^
@@ -106,7 +106,7 @@ LL |     fn f(a: impl A) -> A;
    |             ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:19
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:4:19
    |
 LL |     fn f(a: A) -> A;
    |                   ^
@@ -117,7 +117,7 @@ LL |     fn f(a: A) -> impl A;
    |                   ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:13
    |
 LL |     fn f(b: B) -> B;
    |             ^
@@ -133,7 +133,7 @@ LL |     fn f(b: impl B) -> B;
    |             ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:19
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:19
    |
 LL |     fn f(b: B) -> B;
    |                   ^
@@ -144,7 +144,7 @@ LL |     fn f(b: B) -> impl B;
    |                   ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:20
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:20
    |
 LL |     fn f(&self, c: C) -> C;
    |                    ^
@@ -160,7 +160,7 @@ LL |     fn f(&self, c: impl C) -> C;
    |                    ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:26
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:26
    |
 LL |     fn f(&self, c: C) -> C;
    |                          ^
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-self-2021.rs b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021.rs
similarity index 100%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-self-2021.rs
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021.rs
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-self-2021.stderr b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021.stderr
similarity index 85%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-self-2021.stderr
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021.stderr
index a7d36d9ebee5d..5e0d1a1445230 100644
--- a/tests/ui/suggestions/object-unsafe-trait-should-use-self-2021.stderr
+++ b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021.stderr
@@ -1,5 +1,5 @@
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self-2021.rs:4:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021.rs:4:13
    |
 LL | trait A: Sized {
    |       - in this trait
@@ -12,13 +12,13 @@ LL |     fn f(a: Self) -> Self;
    |             ~~~~     ~~~~
 
 error[E0038]: the trait `A` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021.rs:4:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021.rs:4:13
    |
 LL |     fn f(a: dyn A) -> dyn A;
    |             ^^^^^ `A` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021.rs:3:10
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021.rs:3:10
    |
 LL | trait A: Sized {
    |       -  ^^^^^ ...because it requires `Self: Sized`
@@ -26,7 +26,7 @@ LL | trait A: Sized {
    |       this trait cannot be made into an object...
 
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self-2021.rs:9:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021.rs:9:13
    |
 LL | trait B {
    |       - in this trait
@@ -39,13 +39,13 @@ LL |     fn f(a: Self) -> Self;
    |             ~~~~     ~~~~
 
 error[E0038]: the trait `B` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021.rs:9:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021.rs:9:13
    |
 LL |     fn f(a: dyn B) -> dyn B;
    |             ^^^^^ `B` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021.rs:9:8
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021.rs:9:8
    |
 LL | trait B {
    |       - this trait cannot be made into an object...
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-self.rs b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self.rs
similarity index 100%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-self.rs
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-self.rs
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-self.stderr b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self.stderr
similarity index 86%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-self.stderr
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-self.stderr
index 28952933c644f..93f6ea2b12e67 100644
--- a/tests/ui/suggestions/object-unsafe-trait-should-use-self.stderr
+++ b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self.stderr
@@ -1,5 +1,5 @@
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self.rs:3:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:3:13
    |
 LL | trait A: Sized {
    |       - in this trait
@@ -12,13 +12,13 @@ LL |     fn f(a: Self) -> Self;
    |             ~~~~     ~~~~
 
 error[E0038]: the trait `A` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self.rs:3:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:3:13
    |
 LL |     fn f(a: A) -> A;
    |             ^ `A` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self.rs:2:10
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:2:10
    |
 LL | trait A: Sized {
    |       -  ^^^^^ ...because it requires `Self: Sized`
@@ -26,7 +26,7 @@ LL | trait A: Sized {
    |       this trait cannot be made into an object...
 
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self.rs:8:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:13
    |
 LL | trait B {
    |       - in this trait
@@ -39,13 +39,13 @@ LL |     fn f(a: Self) -> Self;
    |             ~~~~     ~~~~
 
 error[E0038]: the trait `B` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self.rs:8:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:13
    |
 LL |     fn f(a: B) -> B;
    |             ^ `B` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self.rs:8:8
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:8
    |
 LL | trait B {
    |       - this trait cannot be made into an object...
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-where-sized.fixed b/tests/ui/suggestions/dyn-incompatible-trait-should-use-where-sized.fixed
similarity index 100%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-where-sized.fixed
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-where-sized.fixed
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-where-sized.rs b/tests/ui/suggestions/dyn-incompatible-trait-should-use-where-sized.rs
similarity index 100%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-where-sized.rs
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-where-sized.rs
diff --git a/tests/ui/suggestions/object-unsafe-trait-should-use-where-sized.stderr b/tests/ui/suggestions/dyn-incompatible-trait-should-use-where-sized.stderr
similarity index 89%
rename from tests/ui/suggestions/object-unsafe-trait-should-use-where-sized.stderr
rename to tests/ui/suggestions/dyn-incompatible-trait-should-use-where-sized.stderr
index 5e3a0290d42c0..beafd7c2ab00f 100644
--- a/tests/ui/suggestions/object-unsafe-trait-should-use-where-sized.stderr
+++ b/tests/ui/suggestions/dyn-incompatible-trait-should-use-where-sized.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-where-sized.rs:9:12
+  --> $DIR/dyn-incompatible-trait-should-use-where-sized.rs:9:12
    |
 LL | fn bar(x: &dyn Trait) {}
    |            ^^^^^^^^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-where-sized.rs:5:8
+  --> $DIR/dyn-incompatible-trait-should-use-where-sized.rs:5:8
    |
 LL | trait Trait {
    |       ----- this trait cannot be made into an object...
@@ -27,7 +27,7 @@ LL |     fn bar(self: &Self) {}
    |                  ~~~~~
 
 error[E0307]: invalid `self` parameter type: `()`
-  --> $DIR/object-unsafe-trait-should-use-where-sized.rs:6:18
+  --> $DIR/dyn-incompatible-trait-should-use-where-sized.rs:6:18
    |
 LL |     fn bar(self: ()) {}
    |                  ^^
diff --git a/tests/ui/suggestions/issue-98500.rs b/tests/ui/suggestions/issue-98500.rs
index b6fd9e7c23fe3..289b16abf4b37 100644
--- a/tests/ui/suggestions/issue-98500.rs
+++ b/tests/ui/suggestions/issue-98500.rs
@@ -1,9 +1,9 @@
-//@ aux-build:not-object-safe.rs
+//@ aux-build:dyn-incompatible.rs
 
-extern crate not_object_safe;
+extern crate dyn_incompatible;
 
 pub trait B where
-    Self: not_object_safe::A,
+    Self: dyn_incompatible::A,
 {
     fn f2(&self);
 }
diff --git a/tests/ui/suggestions/issue-98500.stderr b/tests/ui/suggestions/issue-98500.stderr
index c4b446763afe5..d7136ec1a649f 100644
--- a/tests/ui/suggestions/issue-98500.stderr
+++ b/tests/ui/suggestions/issue-98500.stderr
@@ -5,7 +5,7 @@ LL | struct S(Box<dyn B>);
    |              ^^^^^ `B` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/auxiliary/not-object-safe.rs:4:8
+  --> $DIR/auxiliary/dyn-incompatible.rs:4:8
    |
 LL |     fn f();
    |        ^ ...because associated function `f` has no `self` parameter
diff --git a/tests/ui/traits/alias/no-duplicates.rs b/tests/ui/traits/alias/no-duplicates.rs
index 88feb89170dd3..d0829ab4cecbf 100644
--- a/tests/ui/traits/alias/no-duplicates.rs
+++ b/tests/ui/traits/alias/no-duplicates.rs
@@ -1,4 +1,4 @@
-// The purpose of this test is to demonstrate that duplicating object safe traits
+// The purpose of this test is to demonstrate that duplicating dyn-compatible traits
 // that are not auto traits is rejected with trait aliases even though one could
 // reasonably accept this.
 
@@ -6,7 +6,7 @@
 
 use std::marker::Unpin;
 
-// Some arbitrary object-safe trait:
+// Some arbitrary dyn-compatible trait:
 trait Obj {}
 
 // Nest a few levels deep:
diff --git a/tests/ui/traits/alias/no-extra-traits.rs b/tests/ui/traits/alias/no-extra-traits.rs
index 4dad8c0f87349..f3d35a8cd034d 100644
--- a/tests/ui/traits/alias/no-extra-traits.rs
+++ b/tests/ui/traits/alias/no-extra-traits.rs
@@ -5,7 +5,7 @@
 
 use std::marker::Unpin;
 
-// Some arbitrary object-safe traits:
+// Some arbitrary dyn-compatible traits:
 trait ObjA {}
 trait ObjB {}
 
diff --git a/tests/ui/traits/alias/object-wf.rs b/tests/ui/traits/alias/object-wf.rs
index 3abffd22d142f..a14cfea3bd7ad 100644
--- a/tests/ui/traits/alias/object-wf.rs
+++ b/tests/ui/traits/alias/object-wf.rs
@@ -20,7 +20,7 @@ fn _f0() {
     let _: Box<dyn Unpin + _1 + Send + Sync>;
 }
 
-// Include object safe traits:
+// Include dyn-compatible traits:
 
 fn _f1() {
     let _: Box<dyn Obj + _0>;
@@ -28,7 +28,7 @@ fn _f1() {
     let _: Box<dyn Obj + _1 + _0>;
 }
 
-// And when the object safe trait is in a trait alias:
+// And when the dyn-compatible trait is in a trait alias:
 
 trait _2 = Obj;
 
diff --git a/tests/ui/traits/next-solver/object-unsafety.rs b/tests/ui/traits/next-solver/dyn-incompatibility.rs
similarity index 100%
rename from tests/ui/traits/next-solver/object-unsafety.rs
rename to tests/ui/traits/next-solver/dyn-incompatibility.rs
diff --git a/tests/ui/traits/next-solver/object-unsafety.stderr b/tests/ui/traits/next-solver/dyn-incompatibility.stderr
similarity index 90%
rename from tests/ui/traits/next-solver/object-unsafety.stderr
rename to tests/ui/traits/next-solver/dyn-incompatibility.stderr
index 75d0ce244132e..7f2c0646ef501 100644
--- a/tests/ui/traits/next-solver/object-unsafety.stderr
+++ b/tests/ui/traits/next-solver/dyn-incompatibility.stderr
@@ -1,12 +1,12 @@
 error[E0277]: the trait bound `T: Copy` is not satisfied in `dyn Setup<From = T>`
-  --> $DIR/object-unsafety.rs:12:12
+  --> $DIR/dyn-incompatibility.rs:12:12
    |
 LL |     copy::<dyn Setup<From=T>>(t)
    |            ^^^^^^^^^^^^^^^^^ within `dyn Setup<From = T>`, the trait `Copy` is not implemented for `T`, which is required by `dyn Setup<From = T>: Setup`
    |
    = note: required because it appears within the type `dyn Setup<From = T>`
 note: required by a bound in `copy`
-  --> $DIR/object-unsafety.rs:7:12
+  --> $DIR/dyn-incompatibility.rs:7:12
    |
 LL | fn copy<U: Setup + ?Sized>(from: &U::From) -> U::From {
    |            ^^^^^ required by this bound in `copy`
@@ -16,7 +16,7 @@ LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
    |                  +++++++++++++++++++
 
 error[E0308]: mismatched types
-  --> $DIR/object-unsafety.rs:12:31
+  --> $DIR/dyn-incompatibility.rs:12:31
    |
 LL |     copy::<dyn Setup<From=T>>(t)
    |     ------------------------- ^ types differ
@@ -26,13 +26,13 @@ LL |     copy::<dyn Setup<From=T>>(t)
    = note: expected reference `&<dyn Setup<From = T> as Setup>::From`
               found reference `&T`
 note: function defined here
-  --> $DIR/object-unsafety.rs:7:4
+  --> $DIR/dyn-incompatibility.rs:7:4
    |
 LL | fn copy<U: Setup + ?Sized>(from: &U::From) -> U::From {
    |    ^^^^                    --------------
 
 error[E0277]: the trait bound `T: Copy` is not satisfied in `dyn Setup<From = T>`
-  --> $DIR/object-unsafety.rs:12:5
+  --> $DIR/dyn-incompatibility.rs:12:5
    |
 LL |     copy::<dyn Setup<From=T>>(t)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `dyn Setup<From = T>`, the trait `Copy` is not implemented for `T`, which is required by `dyn Setup<From = T>: Setup`
diff --git a/tests/ui/traits/non_lifetime_binders/supertrait-object-safety.rs b/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.rs
similarity index 100%
rename from tests/ui/traits/non_lifetime_binders/supertrait-object-safety.rs
rename to tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.rs
diff --git a/tests/ui/traits/non_lifetime_binders/supertrait-object-safety.stderr b/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.stderr
similarity index 88%
rename from tests/ui/traits/non_lifetime_binders/supertrait-object-safety.stderr
rename to tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.stderr
index 0854ea28150fb..dd2dca74f9087 100644
--- a/tests/ui/traits/non_lifetime_binders/supertrait-object-safety.stderr
+++ b/tests/ui/traits/non_lifetime_binders/supertrait-dyn-compatibility.stderr
@@ -1,5 +1,5 @@
 warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/supertrait-object-safety.rs:1:12
+  --> $DIR/supertrait-dyn-compatibility.rs:1:12
    |
 LL | #![feature(non_lifetime_binders)]
    |            ^^^^^^^^^^^^^^^^^^^^
@@ -8,13 +8,13 @@ LL | #![feature(non_lifetime_binders)]
    = note: `#[warn(incomplete_features)]` on by default
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/supertrait-object-safety.rs:19:23
+  --> $DIR/supertrait-dyn-compatibility.rs:19:23
    |
 LL |     let x: &dyn Foo = &();
    |                       ^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/supertrait-object-safety.rs:4:12
+  --> $DIR/supertrait-dyn-compatibility.rs:4:12
    |
 LL | trait Foo: for<T> Bar<T> {}
    |       ---  ^^^^^^^^^^^^^ ...because where clause cannot reference non-lifetime `for<...>` variables
@@ -24,13 +24,13 @@ LL | trait Foo: for<T> Bar<T> {}
    = note: required for the cast from `&()` to `&dyn Foo`
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/supertrait-object-safety.rs:19:12
+  --> $DIR/supertrait-dyn-compatibility.rs:19:12
    |
 LL |     let x: &dyn Foo = &();
    |            ^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/supertrait-object-safety.rs:4:12
+  --> $DIR/supertrait-dyn-compatibility.rs:4:12
    |
 LL | trait Foo: for<T> Bar<T> {}
    |       ---  ^^^^^^^^^^^^^ ...because where clause cannot reference non-lifetime `for<...>` variables
@@ -39,13 +39,13 @@ LL | trait Foo: for<T> Bar<T> {}
    = help: only type `()` implements the trait, consider using it directly instead
 
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/supertrait-object-safety.rs:22:5
+  --> $DIR/supertrait-dyn-compatibility.rs:22:5
    |
 LL |     needs_bar(x);
    |     ^^^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/supertrait-object-safety.rs:4:12
+  --> $DIR/supertrait-dyn-compatibility.rs:4:12
    |
 LL | trait Foo: for<T> Bar<T> {}
    |       ---  ^^^^^^^^^^^^^ ...because where clause cannot reference non-lifetime `for<...>` variables
diff --git a/tests/ui/traits/object/print_vtable_sizes.rs b/tests/ui/traits/object/print_vtable_sizes.rs
index 684458d079e5e..2b1745da5f308 100644
--- a/tests/ui/traits/object/print_vtable_sizes.rs
+++ b/tests/ui/traits/object/print_vtable_sizes.rs
@@ -7,7 +7,7 @@ trait A<T: help::V>: AsRef<[T::V]> + AsMut<[T::V]> {}
 trait B<T>: AsRef<T> + AsRef<T> + AsRef<T> + AsRef<T> {}
 
 trait C {
-    fn x() {} // not object safe, shouldn't be reported
+    fn x() {} // not dyn-compatible, shouldn't be reported
 }
 
 // This does not have any upcasting cost,
diff --git a/tests/ui/traits/object/safety.rs b/tests/ui/traits/object/safety.rs
index f43d332d69637..f4abcf8542e5f 100644
--- a/tests/ui/traits/object/safety.rs
+++ b/tests/ui/traits/object/safety.rs
@@ -1,4 +1,4 @@
-// Check that static methods are not object-safe.
+// Check that static methods render the trait dyn-incompatible.
 
 trait Tr {
     fn foo();
diff --git a/tests/ui/traits/vtable/vtable-non-object-safe.rs b/tests/ui/traits/vtable/vtable-dyn-incompatible.rs
similarity index 78%
rename from tests/ui/traits/vtable/vtable-non-object-safe.rs
rename to tests/ui/traits/vtable/vtable-dyn-incompatible.rs
index f98af0f23b732..64a8138bdcfb3 100644
--- a/tests/ui/traits/vtable/vtable-non-object-safe.rs
+++ b/tests/ui/traits/vtable/vtable-dyn-incompatible.rs
@@ -1,7 +1,7 @@
 //@ build-fail
 #![feature(rustc_attrs)]
 
-// Ensure that non-object-safe methods in Iterator does not generate
+// Ensure that dyn-incompatible methods in Iterator does not generate
 // vtable entries.
 
 #[rustc_dump_vtable]
diff --git a/tests/ui/traits/vtable/vtable-non-object-safe.stderr b/tests/ui/traits/vtable/vtable-dyn-incompatible.stderr
similarity index 92%
rename from tests/ui/traits/vtable/vtable-non-object-safe.stderr
rename to tests/ui/traits/vtable/vtable-dyn-incompatible.stderr
index 53eef5d0b13ca..e442c3eac00ea 100644
--- a/tests/ui/traits/vtable/vtable-non-object-safe.stderr
+++ b/tests/ui/traits/vtable/vtable-dyn-incompatible.stderr
@@ -7,7 +7,7 @@ error: vtable entries for `<std::vec::IntoIter<u8> as A>`: [
            Method(<std::vec::IntoIter<u8> as Iterator>::advance_by),
            Method(<std::vec::IntoIter<u8> as Iterator>::nth),
        ]
-  --> $DIR/vtable-non-object-safe.rs:8:1
+  --> $DIR/vtable-dyn-incompatible.rs:8:1
    |
 LL | trait A: Iterator {}
    | ^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/wf-object/no-duplicates.rs b/tests/ui/traits/wf-object/no-duplicates.rs
index 678ede58296a4..83544064ce210 100644
--- a/tests/ui/traits/wf-object/no-duplicates.rs
+++ b/tests/ui/traits/wf-object/no-duplicates.rs
@@ -1,7 +1,7 @@
-// The purpose of this test is to demonstrate that duplicating object safe traits
+// The purpose of this test is to demonstrate that duplicating dyn-compatible traits
 // that are not auto-traits is rejected even though one could reasonably accept this.
 
-// Some arbitrary object-safe trait:
+// Some arbitrary dyn-compatible trait:
 trait Obj {}
 
 // Demonstrate that recursive expansion of trait aliases doesn't affect stable behavior:
diff --git a/tests/ui/traits/wf-object/reverse-order.rs b/tests/ui/traits/wf-object/reverse-order.rs
index b8f2aae89663b..99c727cc332b2 100644
--- a/tests/ui/traits/wf-object/reverse-order.rs
+++ b/tests/ui/traits/wf-object/reverse-order.rs
@@ -2,7 +2,7 @@
 
 // Ensure that `dyn $($AutoTrait)+ ObjSafe` is well-formed.
 
-// Some arbitrary object-safe trait:
+// Some arbitrary dyn-compatible trait:
 trait Obj {}
 
 type _0 = dyn Unpin;
diff --git a/tests/ui/unsized-locals/by-value-trait-object-safety-rpass.rs b/tests/ui/unsized-locals/by-value-trait-dyn-compatibility-rpass.rs
similarity index 100%
rename from tests/ui/unsized-locals/by-value-trait-object-safety-rpass.rs
rename to tests/ui/unsized-locals/by-value-trait-dyn-compatibility-rpass.rs
diff --git a/tests/ui/unsized-locals/by-value-trait-object-safety-withdefault.rs b/tests/ui/unsized-locals/by-value-trait-dyn-compatibility-with-default.rs
similarity index 100%
rename from tests/ui/unsized-locals/by-value-trait-object-safety-withdefault.rs
rename to tests/ui/unsized-locals/by-value-trait-dyn-compatibility-with-default.rs
diff --git a/tests/ui/unsized-locals/by-value-trait-object-safety.rs b/tests/ui/unsized-locals/by-value-trait-dyn-compatibility.rs
similarity index 100%
rename from tests/ui/unsized-locals/by-value-trait-object-safety.rs
rename to tests/ui/unsized-locals/by-value-trait-dyn-compatibility.rs
diff --git a/tests/ui/unsized-locals/by-value-trait-object-safety.stderr b/tests/ui/unsized-locals/by-value-trait-dyn-compatibility.stderr
similarity index 84%
rename from tests/ui/unsized-locals/by-value-trait-object-safety.stderr
rename to tests/ui/unsized-locals/by-value-trait-dyn-compatibility.stderr
index 6a93464febb10..223624cfca4dd 100644
--- a/tests/ui/unsized-locals/by-value-trait-object-safety.stderr
+++ b/tests/ui/unsized-locals/by-value-trait-dyn-compatibility.stderr
@@ -1,5 +1,5 @@
 warning: the feature `unsized_locals` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/by-value-trait-object-safety.rs:1:12
+  --> $DIR/by-value-trait-dyn-compatibility.rs:1:12
    |
 LL | #![feature(unsized_locals)]
    |            ^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | #![feature(unsized_locals)]
    = note: `#[warn(incomplete_features)]` on by default
 
 error: the `foo` method cannot be invoked on a trait object
-  --> $DIR/by-value-trait-object-safety.rs:20:7
+  --> $DIR/by-value-trait-dyn-compatibility.rs:20:7
    |
 LL |         Self: Sized;
    |               ----- this has a `Sized` requirement
diff --git a/tests/ui/wf/wf-convert-unsafe-trait-obj-box.rs b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.rs
similarity index 87%
rename from tests/ui/wf/wf-convert-unsafe-trait-obj-box.rs
rename to tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.rs
index e32b04c471524..26292a1d218c9 100644
--- a/tests/ui/wf/wf-convert-unsafe-trait-obj-box.rs
+++ b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.rs
@@ -1,5 +1,5 @@
 // Check that we do not allow casts or coercions
-// to object unsafe trait objects inside a Box
+// to dyn-incompatible trait objects inside a Box
 
 #![feature(dyn_compatible_for_dispatch)]
 
diff --git a/tests/ui/wf/wf-convert-unsafe-trait-obj-box.stderr b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.stderr
similarity index 86%
rename from tests/ui/wf/wf-convert-unsafe-trait-obj-box.stderr
rename to tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.stderr
index 2565e25a24297..38426545bc8cb 100644
--- a/tests/ui/wf/wf-convert-unsafe-trait-obj-box.stderr
+++ b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-convert-unsafe-trait-obj-box.rs:16:33
+  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:16:33
    |
 LL |     let t_box: Box<dyn Trait> = Box::new(S);
    |                                 ^^^^^^^^^^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-convert-unsafe-trait-obj-box.rs:6:14
+  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
@@ -15,13 +15,13 @@ LL | trait Trait: Sized {}
    = note: required for the cast from `Box<S>` to `Box<dyn Trait>`
 
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-convert-unsafe-trait-obj-box.rs:17:15
+  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:17:15
    |
 LL |     takes_box(Box::new(S));
    |               ^^^^^^^^^^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-convert-unsafe-trait-obj-box.rs:6:14
+  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
@@ -31,13 +31,13 @@ LL | trait Trait: Sized {}
    = note: required for the cast from `Box<S>` to `Box<(dyn Trait + 'static)>`
 
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-convert-unsafe-trait-obj-box.rs:15:5
+  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:15:5
    |
 LL |     Box::new(S) as Box<dyn Trait>;
    |     ^^^^^^^^^^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-convert-unsafe-trait-obj-box.rs:6:14
+  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
diff --git a/tests/ui/wf/wf-convert-unsafe-trait-obj.rs b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.rs
similarity index 87%
rename from tests/ui/wf/wf-convert-unsafe-trait-obj.rs
rename to tests/ui/wf/wf-convert-dyn-incompat-trait-obj.rs
index 6f38635281983..ec4bb2897f9dc 100644
--- a/tests/ui/wf/wf-convert-unsafe-trait-obj.rs
+++ b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.rs
@@ -1,5 +1,5 @@
 // Check that we do not allow casts or coercions
-// to object unsafe trait objects by ref
+// to dyn-incompatible trait objects by ref
 
 #![feature(dyn_compatible_for_dispatch)]
 
diff --git a/tests/ui/wf/wf-convert-unsafe-trait-obj.stderr b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.stderr
similarity index 87%
rename from tests/ui/wf/wf-convert-unsafe-trait-obj.stderr
rename to tests/ui/wf/wf-convert-dyn-incompat-trait-obj.stderr
index 97f6bcd0428b6..94259aa5b0aa8 100644
--- a/tests/ui/wf/wf-convert-unsafe-trait-obj.stderr
+++ b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-convert-unsafe-trait-obj.rs:16:25
+  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:16:25
    |
 LL |     let t: &dyn Trait = &S;
    |                         ^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-convert-unsafe-trait-obj.rs:6:14
+  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
@@ -15,13 +15,13 @@ LL | trait Trait: Sized {}
    = note: required for the cast from `&S` to `&dyn Trait`
 
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-convert-unsafe-trait-obj.rs:17:17
+  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:17:17
    |
 LL |     takes_trait(&S);
    |                 ^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-convert-unsafe-trait-obj.rs:6:14
+  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
@@ -31,13 +31,13 @@ LL | trait Trait: Sized {}
    = note: required for the cast from `&S` to `&dyn Trait`
 
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-convert-unsafe-trait-obj.rs:15:5
+  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:15:5
    |
 LL |     &S as &dyn Trait;
    |     ^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-convert-unsafe-trait-obj.rs:6:14
+  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
diff --git a/tests/ui/wf/wf-unsafe-trait-obj-match.rs b/tests/ui/wf/wf-dyn-incompat-trait-obj-match.rs
similarity index 100%
rename from tests/ui/wf/wf-unsafe-trait-obj-match.rs
rename to tests/ui/wf/wf-dyn-incompat-trait-obj-match.rs
diff --git a/tests/ui/wf/wf-unsafe-trait-obj-match.stderr b/tests/ui/wf/wf-dyn-incompat-trait-obj-match.stderr
similarity index 89%
rename from tests/ui/wf/wf-unsafe-trait-obj-match.stderr
rename to tests/ui/wf/wf-dyn-incompat-trait-obj-match.stderr
index edbdec6a5efc6..d7366e12256a2 100644
--- a/tests/ui/wf/wf-unsafe-trait-obj-match.stderr
+++ b/tests/ui/wf/wf-dyn-incompat-trait-obj-match.stderr
@@ -1,5 +1,5 @@
 error[E0308]: `match` arms have incompatible types
-  --> $DIR/wf-unsafe-trait-obj-match.rs:23:17
+  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:23:17
    |
 LL | /     match opt() {
 LL | |         Some(()) => &S,
@@ -13,13 +13,13 @@ LL | |     }
               found reference `&R`
 
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-unsafe-trait-obj-match.rs:26:21
+  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:26:21
    |
 LL |         Some(()) => &S,
    |                     ^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-unsafe-trait-obj-match.rs:6:14
+  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
@@ -31,7 +31,7 @@ LL | trait Trait: Sized {}
    = note: required for the cast from `&S` to `&dyn Trait`
 
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/wf-unsafe-trait-obj-match.rs:25:25
+  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:25:25
    |
 LL |       let t: &dyn Trait = match opt() {
    |  _________________________^
@@ -41,7 +41,7 @@ LL | |     };
    | |_____^ `Trait` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-unsafe-trait-obj-match.rs:6:14
+  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:6:14
    |
 LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
diff --git a/tests/ui/wf/wf-object-safe.rs b/tests/ui/wf/wf-dyn-incompatible.rs
similarity index 57%
rename from tests/ui/wf/wf-object-safe.rs
rename to tests/ui/wf/wf-dyn-incompatible.rs
index 42e6917551fd9..16e7ca1cbc618 100644
--- a/tests/ui/wf/wf-object-safe.rs
+++ b/tests/ui/wf/wf-dyn-incompatible.rs
@@ -1,4 +1,4 @@
-// Check that object-safe traits are not WF when used as object types.
+// Check that dyn-incompatible traits are not WF when used as trait object types.
 // Issue #21953.
 
 trait A {
diff --git a/tests/ui/wf/wf-object-safe.stderr b/tests/ui/wf/wf-dyn-incompatible.stderr
similarity index 90%
rename from tests/ui/wf/wf-object-safe.stderr
rename to tests/ui/wf/wf-dyn-incompatible.stderr
index 7c14f3d2f8bf6..cf016b63c7405 100644
--- a/tests/ui/wf/wf-object-safe.stderr
+++ b/tests/ui/wf/wf-dyn-incompatible.stderr
@@ -1,11 +1,11 @@
 error[E0038]: the trait `A` cannot be made into an object
-  --> $DIR/wf-object-safe.rs:9:13
+  --> $DIR/wf-dyn-incompatible.rs:9:13
    |
 LL |     let _x: &dyn A;
    |             ^^^^^^ `A` cannot be made into an object
    |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/wf-object-safe.rs:5:23
+  --> $DIR/wf-dyn-incompatible.rs:5:23
    |
 LL | trait A {
    |       - this trait cannot be made into an object...