UI tests: Rename "object safe" to "dyn compatible"

rust-lang-ci · Oct 9, 2024 · 20cebae · 20cebae
1 parent 2e7a52b
commit 20cebae
Show file tree

Hide file tree

Showing 157 changed files with 366 additions and 364 deletions.
diff --git 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
@@ -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
diff --git a/...ype-bounds/entails-sized-object-safety.rs → ...bounds/entails-sized-dyn-compatibility.rs b/...ype-bounds/entails-sized-object-safety.rs → ...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/.../ui/async-await/in-trait/object-safety.rs → ...async-await/in-trait/dyn-compatibility.rs b/.../ui/async-await/in-trait/object-safety.rs → ...async-await/in-trait/dyn-compatibility.rs
diff --git a/...async-await/in-trait/object-safety.stderr → ...c-await/in-trait/dyn-compatibility.stderr b/...async-await/in-trait/object-safety.stderr → ...c-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/...rence-impl-trait-for-trait-object-safe.rs → ...ce-impl-trait-for-trait-dyn-compatible.rs b/...rence-impl-trait-for-trait-object-safe.rs → ...ce-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
@@ -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
diff --git a/...st_params/const_param_ty_object_safety.rs → ...arams/const_param_ty_dyn_compatibility.rs b/...st_params/const_param_ty_object_safety.rs → ...arams/const_param_ty_dyn_compatibility.rs
diff --git a/...arams/const_param_ty_object_safety.stderr → ...s/const_param_ty_dyn_compatibility.stderr b/...arams/const_param_ty_object_safety.stderr → ...s/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/...eric_const_exprs/object-safety-err-ret.rs → ..._const_exprs/dyn-compatibility-err-ret.rs b/...eric_const_exprs/object-safety-err-ret.rs → ..._const_exprs/dyn-compatibility-err-ret.rs
diff --git a/..._const_exprs/object-safety-err-ret.stderr → ...st_exprs/dyn-compatibility-err-ret.stderr b/..._const_exprs/object-safety-err-ret.stderr → ...st_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/...t_exprs/object-safety-err-where-bounds.rs → ...prs/dyn-compatibility-err-where-bounds.rs b/...t_exprs/object-safety-err-where-bounds.rs → ...prs/dyn-compatibility-err-where-bounds.rs
diff --git a/...prs/object-safety-err-where-bounds.stderr → ...dyn-compatibility-err-where-bounds.stderr b/...prs/object-safety-err-where-bounds.stderr → ...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/...const_exprs/object-safety-ok-infer-err.rs → ...t_exprs/dyn-compatibility-ok-infer-err.rs b/...const_exprs/object-safety-ok-infer-err.rs → ...t_exprs/dyn-compatibility-ok-infer-err.rs
diff --git a/...t_exprs/object-safety-ok-infer-err.stderr → ...prs/dyn-compatibility-ok-infer-err.stderr b/...t_exprs/object-safety-ok-infer-err.stderr → ...prs/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,15 +15,15 @@ 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
    |     |
    |     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/...s/generic_const_exprs/object-safety-ok.rs → ...neric_const_exprs/dyn-compatibility-ok.rs b/...s/generic_const_exprs/object-safety-ok.rs → ...neric_const_exprs/dyn-compatibility-ok.rs
diff --git a/...fety/almost-supertrait-associated-type.rs → ...lity/almost-supertrait-associated-type.rs b/...fety/almost-supertrait-associated-type.rs → ...lity/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/.../almost-supertrait-associated-type.stderr → .../almost-supertrait-associated-type.stderr b/.../almost-supertrait-associated-type.stderr → .../almost-supertrait-associated-type.stderr
diff --git a/tests/ui/object-safety/assoc_const_bounds.rs → ...i/dyn-compatibility/assoc_const_bounds.rs b/tests/ui/object-safety/assoc_const_bounds.rs → ...i/dyn-compatibility/assoc_const_bounds.rs
diff --git a/...object-safety/assoc_const_bounds_sized.rs → ...compatibility/assoc_const_bounds_sized.rs b/...object-safety/assoc_const_bounds_sized.rs → ...compatibility/assoc_const_bounds_sized.rs
diff --git a/tests/ui/object-safety/assoc_type_bounds.rs → ...ui/dyn-compatibility/assoc_type_bounds.rs b/tests/ui/object-safety/assoc_type_bounds.rs → ...ui/dyn-compatibility/assoc_type_bounds.rs
diff --git a/...ui/object-safety/assoc_type_bounds.stderr → ...yn-compatibility/assoc_type_bounds.stderr b/...ui/object-safety/assoc_type_bounds.stderr → ...yn-compatibility/assoc_type_bounds.stderr
diff --git a/tests/ui/object-safety/assoc_type_bounds2.rs → ...i/dyn-compatibility/assoc_type_bounds2.rs b/tests/ui/object-safety/assoc_type_bounds2.rs → ...i/dyn-compatibility/assoc_type_bounds2.rs
diff --git a/...i/object-safety/assoc_type_bounds2.stderr → ...n-compatibility/assoc_type_bounds2.stderr b/...i/object-safety/assoc_type_bounds2.stderr → ...n-compatibility/assoc_type_bounds2.stderr
diff --git a/...ty/assoc_type_bounds_implicit_sized.fixed → ...ty/assoc_type_bounds_implicit_sized.fixed b/...ty/assoc_type_bounds_implicit_sized.fixed → ...ty/assoc_type_bounds_implicit_sized.fixed
diff --git a/...afety/assoc_type_bounds_implicit_sized.rs → ...ility/assoc_type_bounds_implicit_sized.rs b/...afety/assoc_type_bounds_implicit_sized.rs → ...ility/assoc_type_bounds_implicit_sized.rs
diff --git a/...y/assoc_type_bounds_implicit_sized.stderr → ...y/assoc_type_bounds_implicit_sized.stderr b/...y/assoc_type_bounds_implicit_sized.stderr → ...y/assoc_type_bounds_implicit_sized.stderr
diff --git a/.../object-safety/assoc_type_bounds_sized.rs → ...-compatibility/assoc_type_bounds_sized.rs b/.../object-safety/assoc_type_bounds_sized.rs → ...-compatibility/assoc_type_bounds_sized.rs
diff --git a/...-safety/assoc_type_bounds_sized_others.rs → ...ibility/assoc_type_bounds_sized_others.rs b/...-safety/assoc_type_bounds_sized_others.rs → ...ibility/assoc_type_bounds_sized_others.rs
diff --git a/...ety/assoc_type_bounds_sized_others.stderr → ...ity/assoc_type_bounds_sized_others.stderr b/...ety/assoc_type_bounds_sized_others.stderr → ...ity/assoc_type_bounds_sized_others.stderr
diff --git a/...ty/assoc_type_bounds_sized_unnecessary.rs → ...ty/assoc_type_bounds_sized_unnecessary.rs b/...ty/assoc_type_bounds_sized_unnecessary.rs → ...ty/assoc_type_bounds_sized_unnecessary.rs
diff --git a/...ssoc_type_bounds_sized_unnecessary.stderr → ...ssoc_type_bounds_sized_unnecessary.stderr b/...ssoc_type_bounds_sized_unnecessary.stderr → ...ssoc_type_bounds_sized_unnecessary.stderr
diff --git a/...ct-safety/assoc_type_bounds_sized_used.rs → ...atibility/assoc_type_bounds_sized_used.rs b/...ct-safety/assoc_type_bounds_sized_used.rs → ...atibility/assoc_type_bounds_sized_used.rs
diff --git a/...afety/assoc_type_bounds_sized_used.stderr → ...ility/assoc_type_bounds_sized_used.stderr b/...afety/assoc_type_bounds_sized_used.stderr → ...ility/assoc_type_bounds_sized_used.stderr
diff --git a/...ject-safety-associated-consts.curr.stderr → ...mpatibility/associated-consts.curr.stderr b/...ject-safety-associated-consts.curr.stderr → ...mpatibility/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/...consts.dyn_compatible_for_dispatch.stderr → ...consts.dyn_compatible_for_dispatch.stderr b/...consts.dyn_compatible_for_dispatch.stderr → ...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/...safety/object-safety-associated-consts.rs → ...ui/dyn-compatibility/associated-consts.rs b/...safety/object-safety-associated-consts.rs → ...ui/dyn-compatibility/associated-consts.rs
diff --git a/...-safety/avoid-ice-on-warning-2.new.stderr → ...ibility/avoid-ice-on-warning-2.new.stderr b/...-safety/avoid-ice-on-warning-2.new.stderr → ...ibility/avoid-ice-on-warning-2.new.stderr
diff --git a/...-safety/avoid-ice-on-warning-2.old.stderr → ...ibility/avoid-ice-on-warning-2.old.stderr b/...-safety/avoid-ice-on-warning-2.old.stderr → ...ibility/avoid-ice-on-warning-2.old.stderr
diff --git a/...i/object-safety/avoid-ice-on-warning-2.rs → ...n-compatibility/avoid-ice-on-warning-2.rs b/...i/object-safety/avoid-ice-on-warning-2.rs → ...n-compatibility/avoid-ice-on-warning-2.rs
diff --git a/...-safety/avoid-ice-on-warning-3.new.stderr → ...ibility/avoid-ice-on-warning-3.new.stderr b/...-safety/avoid-ice-on-warning-3.new.stderr → ...ibility/avoid-ice-on-warning-3.new.stderr
diff --git a/...-safety/avoid-ice-on-warning-3.old.stderr → ...ibility/avoid-ice-on-warning-3.old.stderr b/...-safety/avoid-ice-on-warning-3.old.stderr → ...ibility/avoid-ice-on-warning-3.old.stderr
diff --git a/...i/object-safety/avoid-ice-on-warning-3.rs → ...n-compatibility/avoid-ice-on-warning-3.rs b/...i/object-safety/avoid-ice-on-warning-3.rs → ...n-compatibility/avoid-ice-on-warning-3.rs
diff --git a/...ct-safety/avoid-ice-on-warning.new.stderr → ...atibility/avoid-ice-on-warning.new.stderr b/...ct-safety/avoid-ice-on-warning.new.stderr → ...atibility/avoid-ice-on-warning.new.stderr
diff --git a/...ct-safety/avoid-ice-on-warning.old.stderr → ...atibility/avoid-ice-on-warning.old.stderr b/...ct-safety/avoid-ice-on-warning.old.stderr → ...atibility/avoid-ice-on-warning.old.stderr
diff --git a/.../ui/object-safety/avoid-ice-on-warning.rs → ...dyn-compatibility/avoid-ice-on-warning.rs b/.../ui/object-safety/avoid-ice-on-warning.rs → ...dyn-compatibility/avoid-ice-on-warning.rs
diff --git a/...ety/bare-trait-dont-suggest-dyn.new.fixed → ...ity/bare-trait-dont-suggest-dyn.new.fixed b/...ety/bare-trait-dont-suggest-dyn.new.fixed → ...ity/bare-trait-dont-suggest-dyn.new.fixed
diff --git a/...ty/bare-trait-dont-suggest-dyn.new.stderr → ...ty/bare-trait-dont-suggest-dyn.new.stderr b/...ty/bare-trait-dont-suggest-dyn.new.stderr → ...ty/bare-trait-dont-suggest-dyn.new.stderr
diff --git a/...ty/bare-trait-dont-suggest-dyn.old.stderr → ...ty/bare-trait-dont-suggest-dyn.old.stderr b/...ty/bare-trait-dont-suggest-dyn.old.stderr → ...ty/bare-trait-dont-suggest-dyn.old.stderr
diff --git a/...ect-safety/bare-trait-dont-suggest-dyn.rs → ...patibility/bare-trait-dont-suggest-dyn.rs b/...ect-safety/bare-trait-dont-suggest-dyn.rs → ...patibility/bare-trait-dont-suggest-dyn.rs
diff --git a/.../ui/object-safety/object-safety-bounds.rs → tests/ui/dyn-compatibility/bounds.rs b/.../ui/object-safety/object-safety-bounds.rs → 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/...object-safety/object-safety-bounds.stderr → tests/ui/dyn-compatibility/bounds.stderr b/...object-safety/object-safety-bounds.stderr → 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/...safety/object-safety-by-value-self-use.rs → ...ui/dyn-compatibility/by-value-self-use.rs b/...safety/object-safety-by-value-self-use.rs → ...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/...ty/object-safety-by-value-self-use.stderr → ...yn-compatibility/by-value-self-use.stderr b/...ty/object-safety-by-value-self-use.stderr → ...yn-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/...ect-safety/object-safety-by-value-self.rs → tests/ui/dyn-compatibility/by-value-self.rs b/...ect-safety/object-safety-by-value-self.rs → 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/...ect-safety/call-when-assoc-ty-is-sized.rs → ...patibility/call-when-assoc-ty-is-sized.rs b/...ect-safety/call-when-assoc-ty-is-sized.rs → ...patibility/call-when-assoc-ty-is-sized.rs
diff --git a/tests/ui/object-safety/issue-102933.rs → ...ibility/elaborated-predicates-ordering.rs b/tests/ui/object-safety/issue-102933.rs → ...ibility/elaborated-predicates-ordering.rs
@@ -1,4 +1,5 @@
 //@ check-pass
+// issue: rust-lang/rust#102933
 
 use std::future::Future;
 

diff --git a/...s/ui/object-safety/erroneous_signature.rs → .../dyn-compatibility/erroneous_signature.rs b/...s/ui/object-safety/erroneous_signature.rs → .../dyn-compatibility/erroneous_signature.rs
diff --git a/.../object-safety/erroneous_signature.stderr → ...-compatibility/erroneous_signature.stderr b/.../object-safety/erroneous_signature.stderr → ...-compatibility/erroneous_signature.stderr