Add missing dyn keywords to tests that do not test for them

Veykril · Veykril · commit 2549962c6365 · 2025-06-05T09:41:58.000+02:00
diff --git a/tests/ui/auxiliary/typeid-intrinsic-aux1.rs b/tests/ui/auxiliary/typeid-intrinsic-aux1.rs
@@ -9,9 +9,9 @@ pub struct E(Result<&'static str, isize>);
 pub type F = Option<isize>;
 pub type G = usize;
 pub type H = &'static str;
-pub type I = Box<Fn()>;
-pub type I32Iterator = Iterator<Item=i32>;
-pub type U32Iterator = Iterator<Item=u32>;
+pub type I = Box<dyn Fn()>;
+pub type I32Iterator = dyn Iterator<Item=i32>;
+pub type U32Iterator = dyn Iterator<Item=u32>;
 
 pub fn id_A() -> TypeId { TypeId::of::<A>() }
 pub fn id_B() -> TypeId { TypeId::of::<B>() }
diff --git a/tests/ui/auxiliary/typeid-intrinsic-aux2.rs b/tests/ui/auxiliary/typeid-intrinsic-aux2.rs
@@ -9,9 +9,9 @@ pub struct E(Result<&'static str, isize>);
 pub type F = Option<isize>;
 pub type G = usize;
 pub type H = &'static str;
-pub type I = Box<Fn()>;
-pub type I32Iterator = Iterator<Item=i32>;
-pub type U32Iterator = Iterator<Item=u32>;
+pub type I = Box<dyn Fn()>;
+pub type I32Iterator = dyn Iterator<Item=i32>;
+pub type U32Iterator = dyn Iterator<Item=u32>;
 
 pub fn id_A() -> TypeId { TypeId::of::<A>() }
 pub fn id_B() -> TypeId { TypeId::of::<B>() }
diff --git a/tests/ui/suggestions/dyn-incompatible-trait-should-use-self.rs b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self.rs
@@ -1,16 +1,15 @@
-#![allow(bare_trait_objects)]
 trait A: Sized {
-    fn f(a: A) -> A;
+    fn f(a: dyn A) -> dyn A;
     //~^ ERROR associated item referring to unboxed trait object for its own trait
     //~| ERROR the trait `A` is not dyn compatible
 }
 trait B {
-    fn f(a: B) -> B;
+    fn f(a: dyn B) -> dyn B;
     //~^ ERROR associated item referring to unboxed trait object for its own trait
     //~| ERROR the trait `B` is not dyn compatible
 }
 trait C {
-    fn f(&self, a: C) -> C;
+    fn f(&self, a: dyn C) -> dyn C;
 }
 
 fn main() {}
diff --git a/tests/ui/suggestions/dyn-incompatible-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/dyn-incompatible-trait-should-use-self.rs:3:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:2:13
    |
 LL | trait A: Sized {
    |       - in this trait
@@ -13,22 +13,22 @@ LL +     fn f(a: Self) -> Self;
    |
 
 error[E0038]: the trait `A` is not dyn compatible
-  --> $DIR/dyn-incompatible-trait-should-use-self.rs:3:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:2:13
    |
 LL |     fn f(a: dyn A) -> dyn A;
    |             ^^^^^ `A` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/dyn-incompatible-trait-should-use-self.rs:2:10
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:1:10
    |
 LL | trait A: Sized {
    |       -  ^^^^^ ...because it requires `Self: Sized`
    |       |
    |       this trait is not dyn compatible...
 
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:7:13
    |
 LL | trait B {
    |       - in this trait
@@ -42,14 +42,14 @@ LL +     fn f(a: Self) -> Self;
    |
 
 error[E0038]: the trait `B` is not dyn compatible
-  --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:13
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:7:13
    |
 LL |     fn f(a: dyn B) -> dyn B;
    |             ^^^^^ `B` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:8
+  --> $DIR/dyn-incompatible-trait-should-use-self.rs:7:8
    |
 LL | trait B {
    |       - this trait is not dyn compatible...
diff --git a/tests/ui/suggestions/missing-lifetime-specifier.rs b/tests/ui/suggestions/missing-lifetime-specifier.rs
@@ -7,7 +7,6 @@
 // Different number of duplicated diagnostics on different targets
 //@ compile-flags: -Zdeduplicate-diagnostics=yes
 
-#![allow(bare_trait_objects)]
 use std::cell::RefCell;
 use std::collections::HashMap;
 
@@ -28,15 +27,15 @@ thread_local! {
     //~^ ERROR missing lifetime specifiers
 }
 thread_local! {
-    static b: RefCell<HashMap<i32, Vec<Vec<&Bar>>>> = RefCell::new(HashMap::new());
+    static b: RefCell<HashMap<i32, Vec<Vec<&dyn Bar>>>> = RefCell::new(HashMap::new());
     //~^ ERROR missing lifetime specifiers
 }
 thread_local! {
     static c: RefCell<HashMap<i32, Vec<Vec<Qux<i32>>>>> = RefCell::new(HashMap::new());
     //~^ ERROR missing lifetime specifiers
 }
 thread_local! {
-    static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new());
+    static d: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<i32>>>>> = RefCell::new(HashMap::new());
     //~^ ERROR missing lifetime specifiers
 }
 
@@ -45,8 +44,9 @@ thread_local! {
     //~^ ERROR union takes 2 lifetime arguments but 1 lifetime argument
 }
 thread_local! {
-    static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
-    //~^ ERROR trait takes 2 lifetime arguments but 1 lifetime argument was supplied
+    static f: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<'static, i32>>>>> =
+        RefCell::new(HashMap::new());
+    //~^^ ERROR trait takes 2 lifetime arguments but 1 lifetime argument was supplied
     //~| ERROR missing lifetime specifier
 }
 
diff --git a/tests/ui/suggestions/missing-lifetime-specifier.stderr b/tests/ui/suggestions/missing-lifetime-specifier.stderr
@@ -1,5 +1,5 @@
 error[E0106]: missing lifetime specifiers
-  --> $DIR/missing-lifetime-specifier.rs:27:44
+  --> $DIR/missing-lifetime-specifier.rs:26:44
    |
 LL |     static a: RefCell<HashMap<i32, Vec<Vec<Foo>>>> = RefCell::new(HashMap::new());
    |                                            ^^^ expected 2 lifetime parameters
@@ -11,21 +11,21 @@ LL |     static a: RefCell<HashMap<i32, Vec<Vec<Foo<'static, 'static>>>>> = RefC
    |                                               ++++++++++++++++++
 
 error[E0106]: missing lifetime specifiers
-  --> $DIR/missing-lifetime-specifier.rs:31:44
+  --> $DIR/missing-lifetime-specifier.rs:30:44
    |
-LL |     static b: RefCell<HashMap<i32, Vec<Vec<&Bar>>>> = RefCell::new(HashMap::new());
-   |                                            ^^^^ expected 2 lifetime parameters
+LL |     static b: RefCell<HashMap<i32, Vec<Vec<&dyn Bar>>>> = RefCell::new(HashMap::new());
+   |                                            ^    ^^^ expected 2 lifetime parameters
    |                                            |
    |                                            expected named lifetime parameter
    |
    = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
 help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
    |
-LL |     static b: RefCell<HashMap<i32, Vec<Vec<&'static Bar<'static, 'static>>>>> = RefCell::new(HashMap::new());
-   |                                             +++++++    ++++++++++++++++++
+LL |     static b: RefCell<HashMap<i32, Vec<Vec<&'static dyn Bar<'static, 'static>>>>> = RefCell::new(HashMap::new());
+   |                                             +++++++        ++++++++++++++++++
 
 error[E0106]: missing lifetime specifiers
-  --> $DIR/missing-lifetime-specifier.rs:35:47
+  --> $DIR/missing-lifetime-specifier.rs:34:47
    |
 LL |     static c: RefCell<HashMap<i32, Vec<Vec<Qux<i32>>>>> = RefCell::new(HashMap::new());
    |                                               ^ expected 2 lifetime parameters
@@ -37,41 +37,46 @@ LL |     static c: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'static, i32>>>>> =
    |                                                +++++++++++++++++
 
 error[E0106]: missing lifetime specifiers
-  --> $DIR/missing-lifetime-specifier.rs:39:44
+  --> $DIR/missing-lifetime-specifier.rs:38:44
    |
-LL |     static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new());
-   |                                            ^   ^ expected 2 lifetime parameters
+LL |     static d: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<i32>>>>> = RefCell::new(HashMap::new());
+   |                                            ^       ^ expected 2 lifetime parameters
    |                                            |
    |                                            expected named lifetime parameter
    |
    = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
 help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
    |
-LL |     static d: RefCell<HashMap<i32, Vec<Vec<&'static Tar<'static, 'static, i32>>>>> = RefCell::new(HashMap::new());
-   |                                             +++++++     +++++++++++++++++
+LL |     static d: RefCell<HashMap<i32, Vec<Vec<&'static dyn Tar<'static, 'static, i32>>>>> = RefCell::new(HashMap::new());
+   |                                             +++++++         +++++++++++++++++
 
 error[E0106]: missing lifetime specifier
-  --> $DIR/missing-lifetime-specifier.rs:48:44
+  --> $DIR/missing-lifetime-specifier.rs:47:44
    |
-LL |     static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
+LL |     static f: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<'static, i32>>>>> =
    |                                            ^ expected named lifetime parameter
    |
    = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
 help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
    |
-LL |     static f: RefCell<HashMap<i32, Vec<Vec<&'static Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
+LL |     static f: RefCell<HashMap<i32, Vec<Vec<&'static dyn Tar<'static, i32>>>>> =
    |                                             +++++++
+help: instead, you are more likely to want to return an owned value
+   |
+LL -     static f: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<'static, i32>>>>> =
+LL +     static f: RefCell<HashMap<i32, Vec<Vec<dyn Tar<'static, i32>>>>> =
+   |
 
 error[E0107]: union takes 2 lifetime arguments but 1 lifetime argument was supplied
-  --> $DIR/missing-lifetime-specifier.rs:44:44
+  --> $DIR/missing-lifetime-specifier.rs:43:44
    |
 LL |     static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new());
    |                                            ^^^ ------- supplied 1 lifetime argument
    |                                            |
    |                                            expected 2 lifetime arguments
    |
 note: union defined here, with 2 lifetime parameters: `'t`, `'k`
-  --> $DIR/missing-lifetime-specifier.rs:20:11
+  --> $DIR/missing-lifetime-specifier.rs:19:11
    |
 LL | pub union Qux<'t, 'k, I> {
    |           ^^^ --  --
@@ -81,22 +86,22 @@ LL |     static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'static, i32>>>>> =
    |                                                       +++++++++
 
 error[E0107]: trait takes 2 lifetime arguments but 1 lifetime argument was supplied
-  --> $DIR/missing-lifetime-specifier.rs:48:45
+  --> $DIR/missing-lifetime-specifier.rs:47:49
    |
-LL |     static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
-   |                                             ^^^ ------- supplied 1 lifetime argument
-   |                                             |
-   |                                             expected 2 lifetime arguments
+LL |     static f: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<'static, i32>>>>> =
+   |                                                 ^^^ ------- supplied 1 lifetime argument
+   |                                                 |
+   |                                                 expected 2 lifetime arguments
    |
 note: trait defined here, with 2 lifetime parameters: `'t`, `'k`
-  --> $DIR/missing-lifetime-specifier.rs:24:7
+  --> $DIR/missing-lifetime-specifier.rs:23:7
    |
 LL | trait Tar<'t, 'k, I> {}
    |       ^^^ --  --
 help: add missing lifetime argument
    |
-LL |     static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, 'static, i32>>>>> = RefCell::new(HashMap::new());
-   |                                                        +++++++++
+LL |     static f: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<'static, 'static, i32>>>>> =
+   |                                                            +++++++++
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/traits/auxiliary/traitimpl.rs b/tests/ui/traits/auxiliary/traitimpl.rs
@@ -2,6 +2,6 @@
 
 pub trait Bar<'a> : 'a {}
 
-impl<'a> Bar<'a> {
+impl<'a> dyn Bar<'a> {
     pub fn bar(&self) {}
 }
diff --git a/tests/ui/traits/const-traits/inherent-impl.rs b/tests/ui/traits/const-traits/inherent-impl.rs
@@ -7,7 +7,7 @@ trait T {}
 impl const S {}
 //~^ ERROR inherent impls cannot be `const`
 
-impl const T {}
+impl const dyn T {}
 //~^ ERROR inherent impls cannot be `const`
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/inherent-impl.stderr b/tests/ui/traits/const-traits/inherent-impl.stderr
@@ -11,8 +11,8 @@ LL | impl const S {}
 error: inherent impls cannot be `const`
   --> $DIR/inherent-impl.rs:10:12
    |
-LL | impl const T {}
-   |      ----- ^ inherent impl for this type
+LL | impl const dyn T {}
+   |      ----- ^^^^^ inherent impl for this type
    |      |
    |      `const` because of this
    |
diff --git a/tests/ui/type/auxiliary/crate_a1.rs b/tests/ui/type/auxiliary/crate_a1.rs
@@ -2,10 +2,10 @@ pub struct Foo;
 
 pub trait Bar {}
 
-pub fn bar() -> Box<Bar> {
+pub fn bar() -> Box<dyn Bar> {
     unimplemented!()
 }
 
 
 pub fn try_foo(x: Foo){}
-pub fn try_bar(x: Box<Bar>){}
+pub fn try_bar(x: Box<dyn Bar>){}
diff --git a/tests/ui/type/auxiliary/crate_a2.rs b/tests/ui/type/auxiliary/crate_a2.rs
@@ -2,6 +2,6 @@ pub struct Foo;
 
 pub trait Bar {}
 
-pub fn bar() -> Box<Bar> {
+pub fn bar() -> Box<dyn Bar> {
     unimplemented!()
 }
diff --git a/tests/ui/type/type-mismatch-same-crate-name.stderr b/tests/ui/type/type-mismatch-same-crate-name.stderr
@@ -59,7 +59,7 @@ LL |         extern crate crate_a1 as a;
 note: function defined here
   --> $DIR/auxiliary/crate_a1.rs:11:8
    |
-LL | pub fn try_bar(x: Box<Bar>){}
+LL | pub fn try_bar(x: Box<dyn Bar>){}
    |        ^^^^^^^
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/unsized/unsized3-rpass.rs b/tests/ui/unsized/unsized3-rpass.rs
@@ -37,7 +37,7 @@ impl Tr for St {
 }
 
 struct Qux<'a> {
-    f: Tr + 'a,
+    f: dyn Tr + 'a,
 }
 
 pub fn main() {
@@ -85,7 +85,7 @@ pub fn main() {
         }
 
         let obj: Box<St> = Box::new(St { f: 42 });
-        let obj: &Tr = &*obj;
+        let obj: &dyn Tr = &*obj;
         let data: Box<_> = Box::new(Qux_ { f: St { f: 234 } });
         let x: &Qux = &*ptr::from_raw_parts::<Qux>(&*data as *const _, ptr::metadata(obj));
         assert_eq!(x.f.foo(), 234);
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs
@@ -1,17 +1,11 @@
-trait Trait<const N: Trait = bar> {
+trait Trait<const N: dyn Trait = bar> {
     //~^ ERROR cannot find value `bar` in this scope
     //~| ERROR cycle detected when computing type of `Trait::N`
-    //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects]
-    //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
-    fn fnc<const N: Trait = u32>(&self) -> Trait {
+    fn fnc<const N: dyn Trait = u32>(&self) -> dyn Trait {
         //~^ ERROR the name `N` is already used for a generic parameter in this item's generic parameters
         //~| ERROR expected value, found builtin type `u32`
         //~| ERROR defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
         //~| ERROR associated item referring to unboxed trait object for its own trait
-        //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects]
-        //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
-        //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects]
-        //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
         bar
         //~^ ERROR cannot find value `bar` in this scope
     }
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr

Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,15 @@`
`1`		`-#![allow(bare_trait_objects)]`
`2`	`1`	`trait A: Sized {`
`3`		`- fn f(a: A) -> A;`
	`2`	`+ fn f(a: dyn A) -> dyn A;`
`4`	`3`	`//~^ ERROR associated item referring to unboxed trait object for its own trait`
`5`	`4`	//~\| ERROR the trait `A` is not dyn compatible
`6`	`5`	`}`
`7`	`6`	`trait B {`
`8`		`- fn f(a: B) -> B;`
	`7`	`+ fn f(a: dyn B) -> dyn B;`
`9`	`8`	`//~^ ERROR associated item referring to unboxed trait object for its own trait`
`10`	`9`	//~\| ERROR the trait `B` is not dyn compatible
`11`	`10`	`}`
`12`	`11`	`trait C {`
`13`		`- fn f(&self, a: C) -> C;`
	`12`	`+ fn f(&self, a: dyn C) -> dyn C;`
`14`	`13`	`}`
`15`	`14`
`16`	`15`	`fn main() {}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`error: associated item referring to unboxed trait object for its own trait`
`2`		`- --> $DIR/dyn-incompatible-trait-should-use-self.rs:3:13`
	`2`	`+ --> $DIR/dyn-incompatible-trait-should-use-self.rs:2:13`
`3`	`3`	`\|`
`4`	`4`	`LL \| trait A: Sized {`
`5`	`5`	`\| - in this trait`
`@@ -13,22 +13,22 @@ LL + fn f(a: Self) -> Self;`
`13`	`13`	`\|`
`14`	`14`
`15`	`15`	error[E0038]: the trait `A` is not dyn compatible
`16`		`- --> $DIR/dyn-incompatible-trait-should-use-self.rs:3:13`
	`16`	`+ --> $DIR/dyn-incompatible-trait-should-use-self.rs:2:13`
`17`	`17`	`\|`
`18`	`18`	`LL \| fn f(a: dyn A) -> dyn A;`
`19`	`19`	\| ^^^^^ `A` is not dyn compatible
`20`	`20`	`\|`
`21`	`21`	`note: for a trait to be dyn compatible it needs to allow building a vtable`
`22`	`22`	`for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>`
`23`		`- --> $DIR/dyn-incompatible-trait-should-use-self.rs:2:10`
	`23`	`+ --> $DIR/dyn-incompatible-trait-should-use-self.rs:1:10`
`24`	`24`	`\|`
`25`	`25`	`LL \| trait A: Sized {`
`26`	`26`	\| - ^^^^^ ...because it requires `Self: Sized`
`27`	`27`	`\| \|`
`28`	`28`	`\| this trait is not dyn compatible...`
`29`	`29`
`30`	`30`	`error: associated item referring to unboxed trait object for its own trait`
`31`		`- --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:13`
	`31`	`+ --> $DIR/dyn-incompatible-trait-should-use-self.rs:7:13`
`32`	`32`	`\|`
`33`	`33`	`LL \| trait B {`
`34`	`34`	`\| - in this trait`
`@@ -42,14 +42,14 @@ LL + fn f(a: Self) -> Self;`
`42`	`42`	`\|`
`43`	`43`
`44`	`44`	error[E0038]: the trait `B` is not dyn compatible
`45`		`- --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:13`
	`45`	`+ --> $DIR/dyn-incompatible-trait-should-use-self.rs:7:13`
`46`	`46`	`\|`
`47`	`47`	`LL \| fn f(a: dyn B) -> dyn B;`
`48`	`48`	\| ^^^^^ `B` is not dyn compatible
`49`	`49`	`\|`
`50`	`50`	`note: for a trait to be dyn compatible it needs to allow building a vtable`
`51`	`51`	`for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>`
`52`		`- --> $DIR/dyn-incompatible-trait-should-use-self.rs:8:8`
	`52`	`+ --> $DIR/dyn-incompatible-trait-should-use-self.rs:7:8`
`53`	`53`	`\|`
`54`	`54`	`LL \| trait B {`
`55`	`55`	`\| - this trait is not dyn compatible...`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@`
`7`	`7`	`// Different number of duplicated diagnostics on different targets`
`8`	`8`	`//@ compile-flags: -Zdeduplicate-diagnostics=yes`
`9`	`9`
`10`		`-#![allow(bare_trait_objects)]`
`11`	`10`	`use std::cell::RefCell;`
`12`	`11`	`use std::collections::HashMap;`
`13`	`12`
`@@ -28,15 +27,15 @@ thread_local! {`
`28`	`27`	`//~^ ERROR missing lifetime specifiers`
`29`	`28`	`}`
`30`	`29`	`thread_local! {`
`31`		`- static b: RefCell<HashMap<i32, Vec<Vec<&Bar>>>> = RefCell::new(HashMap::new());`
	`30`	`+ static b: RefCell<HashMap<i32, Vec<Vec<&dyn Bar>>>> = RefCell::new(HashMap::new());`
`32`	`31`	`//~^ ERROR missing lifetime specifiers`
`33`	`32`	`}`
`34`	`33`	`thread_local! {`
`35`	`34`	`static c: RefCell<HashMap<i32, Vec<Vec<Qux<i32>>>>> = RefCell::new(HashMap::new());`
`36`	`35`	`//~^ ERROR missing lifetime specifiers`
`37`	`36`	`}`
`38`	`37`	`thread_local! {`
`39`		`- static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new());`
	`38`	`+ static d: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<i32>>>>> = RefCell::new(HashMap::new());`
`40`	`39`	`//~^ ERROR missing lifetime specifiers`
`41`	`40`	`}`
`42`	`41`
`@@ -45,8 +44,9 @@ thread_local! {`
`45`	`44`	`//~^ ERROR union takes 2 lifetime arguments but 1 lifetime argument`
`46`	`45`	`}`
`47`	`46`	`thread_local! {`
`48`		`- static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());`
`49`		`- //~^ ERROR trait takes 2 lifetime arguments but 1 lifetime argument was supplied`
	`47`	`+ static f: RefCell<HashMap<i32, Vec<Vec<&dyn Tar<'static, i32>>>>> =`
	`48`	`+ RefCell::new(HashMap::new());`
	`49`	`+ //~^^ ERROR trait takes 2 lifetime arguments but 1 lifetime argument was supplied`
`50`	`50`	`//~\| ERROR missing lifetime specifier`
`51`	`51`	`}`
`52`	`52`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@`
`2`	`2`
`3`	`3`	`pub trait Bar<'a> : 'a {}`
`4`	`4`
`5`		`-impl<'a> Bar<'a> {`
	`5`	`+impl<'a> dyn Bar<'a> {`
`6`	`6`	`pub fn bar(&self) {}`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,8 @@ LL \| impl const S {}`
`11`	`11`	error: inherent impls cannot be `const`
`12`	`12`	`--> $DIR/inherent-impl.rs:10:12`
`13`	`13`	`\|`
`14`		`-LL \| impl const T {}`
`15`		`- \| ----- ^ inherent impl for this type`
	`14`	`+LL \| impl const dyn T {}`
	`15`	`+ \| ----- ^^^^^ inherent impl for this type`
`16`	`16`	`\| \|`
`17`	`17`	\| `const` because of this
`18`	`18`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,10 @@ pub struct Foo;`
`2`	`2`
`3`	`3`	`pub trait Bar {}`
`4`	`4`
`5`		`-pub fn bar() -> Box<Bar> {`
	`5`	`+pub fn bar() -> Box<dyn Bar> {`
`6`	`6`	`unimplemented!()`
`7`	`7`	`}`
`8`	`8`
`9`	`9`
`10`	`10`	`pub fn try_foo(x: Foo){}`
`11`		`-pub fn try_bar(x: Box<Bar>){}`
	`11`	`+pub fn try_bar(x: Box<dyn Bar>){}`