Skip to content

Commit 7edbc95

Browse files
estebankestebank
committed
Update tests after rebase
Fix #119652.
1 parent 6b7e6ea commit 7edbc95

File tree

4 files changed

+238
-6
lines changed

4 files changed

+238
-6
lines changed

‎tests/ui/object-safety/avoid-ice-on-warning-3.rs‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
trait B { fn f(a: A) -> A; }
2+
//~^ WARN trait objects without an explicit `dyn` are deprecated
3+
//~| WARN trait objects without an explicit `dyn` are deprecated
4+
//~| WARN trait objects without an explicit `dyn` are deprecated
5+
//~| WARN this is accepted in the current edition
6+
//~| WARN this is accepted in the current edition
7+
//~| WARN this is accepted in the current edition
8+
//~| ERROR the trait `A` cannot be made into an object
9+
trait A { fn g(b: B) -> B; }
10+
//~^ WARN trait objects without an explicit `dyn` are deprecated
11+
//~| WARN trait objects without an explicit `dyn` are deprecated
12+
//~| WARN trait objects without an explicit `dyn` are deprecated
13+
//~| WARN this is accepted in the current edition
14+
//~| WARN this is accepted in the current edition
15+
//~| WARN this is accepted in the current edition
16+
//~| ERROR the trait `B` cannot be made into an object
17+
fn main() {}

‎tests/ui/object-safety/avoid-ice-on-warning-3.stderr‎

Lines changed: 148 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,148 @@
1+
warning: trait objects without an explicit `dyn` are deprecated
2+
--> $DIR/avoid-ice-on-warning-3.rs:9:19
3+
|
4+
LL | trait A { fn g(b: B) -> B; }
5+
| ^
6+
|
7+
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
8+
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
9+
= note: `B` it is not object safe, so it can't be `dyn`
10+
= note: `#[warn(bare_trait_objects)]` on by default
11+
help: use a new generic type parameter, constrained by `B`
12+
|
13+
LL | trait A { fn g<T: B>(b: T) -> B; }
14+
| ++++++ ~
15+
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
16+
|
17+
LL | trait A { fn g(b: impl B) -> B; }
18+
| ++++
19+
20+
warning: trait objects without an explicit `dyn` are deprecated
21+
--> $DIR/avoid-ice-on-warning-3.rs:9:25
22+
|
23+
LL | trait A { fn g(b: B) -> B; }
24+
| ^
25+
|
26+
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
27+
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
28+
help: `B` is not object safe, use `impl B` to return an opaque type, as long as you return a single underlying type
29+
|
30+
LL | trait A { fn g(b: B) -> impl B; }
31+
| ++++
32+
33+
warning: trait objects without an explicit `dyn` are deprecated
34+
--> $DIR/avoid-ice-on-warning-3.rs:1:19
35+
|
36+
LL | trait B { fn f(a: A) -> A; }
37+
| ^
38+
|
39+
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
40+
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
41+
= note: `A` it is not object safe, so it can't be `dyn`
42+
help: use a new generic type parameter, constrained by `A`
43+
|
44+
LL | trait B { fn f<T: A>(a: T) -> A; }
45+
| ++++++ ~
46+
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
47+
|
48+
LL | trait B { fn f(a: impl A) -> A; }
49+
| ++++
50+
51+
warning: trait objects without an explicit `dyn` are deprecated
52+
--> $DIR/avoid-ice-on-warning-3.rs:1:25
53+
|
54+
LL | trait B { fn f(a: A) -> A; }
55+
| ^
56+
|
57+
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
58+
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
59+
help: `A` is not object safe, use `impl A` to return an opaque type, as long as you return a single underlying type
60+
|
61+
LL | trait B { fn f(a: A) -> impl A; }
62+
| ++++
63+
64+
warning: trait objects without an explicit `dyn` are deprecated
65+
--> $DIR/avoid-ice-on-warning-3.rs:1:19
66+
|
67+
LL | trait B { fn f(a: A) -> A; }
68+
| ^
69+
|
70+
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
71+
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
72+
= note: `A` it is not object safe, so it can't be `dyn`
73+
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
74+
help: use a new generic type parameter, constrained by `A`
75+
|
76+
LL | trait B { fn f<T: A>(a: T) -> A; }
77+
| ++++++ ~
78+
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
79+
|
80+
LL | trait B { fn f(a: impl A) -> A; }
81+
| ++++
82+
83+
error[E0038]: the trait `A` cannot be made into an object
84+
--> $DIR/avoid-ice-on-warning-3.rs:1:19
85+
|
86+
LL | trait B { fn f(a: A) -> A; }
87+
| ^ `A` cannot be made into an object
88+
|
89+
note: for a trait to be "object safe" 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>
90+
--> $DIR/avoid-ice-on-warning-3.rs:9:14
91+
|
92+
LL | trait A { fn g(b: B) -> B; }
93+
| - ^ ...because associated function `g` has no `self` parameter
94+
| |
95+
| this trait cannot be made into an object...
96+
help: consider turning `g` into a method by giving it a `&self` argument
97+
|
98+
LL | trait A { fn g(&self, b: B) -> B; }
99+
| ++++++
100+
help: alternatively, consider constraining `g` so it does not apply to trait objects
101+
|
102+
LL | trait A { fn g(b: B) -> B where Self: Sized; }
103+
| +++++++++++++++++
104+
105+
warning: trait objects without an explicit `dyn` are deprecated
106+
--> $DIR/avoid-ice-on-warning-3.rs:9:19
107+
|
108+
LL | trait A { fn g(b: B) -> B; }
109+
| ^
110+
|
111+
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
112+
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
113+
= note: `B` it is not object safe, so it can't be `dyn`
114+
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
115+
help: use a new generic type parameter, constrained by `B`
116+
|
117+
LL | trait A { fn g<T: B>(b: T) -> B; }
118+
| ++++++ ~
119+
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
120+
|
121+
LL | trait A { fn g(b: impl B) -> B; }
122+
| ++++
123+
124+
error[E0038]: the trait `B` cannot be made into an object
125+
--> $DIR/avoid-ice-on-warning-3.rs:9:19
126+
|
127+
LL | trait A { fn g(b: B) -> B; }
128+
| ^ `B` cannot be made into an object
129+
|
130+
note: for a trait to be "object safe" 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>
131+
--> $DIR/avoid-ice-on-warning-3.rs:1:14
132+
|
133+
LL | trait B { fn f(a: A) -> A; }
134+
| - ^ ...because associated function `f` has no `self` parameter
135+
| |
136+
| this trait cannot be made into an object...
137+
help: consider turning `f` into a method by giving it a `&self` argument
138+
|
139+
LL | trait B { fn f(&self, a: A) -> A; }
140+
| ++++++
141+
help: alternatively, consider constraining `f` so it does not apply to trait objects
142+
|
143+
LL | trait B { fn f(a: A) -> A where Self: Sized; }
144+
| +++++++++++++++++
145+
146+
error: aborting due to 2 previous errors; 6 warnings emitted
147+
148+
For more information about this error, try `rustc --explain E0038`.

‎tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.rs‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,11 +4,15 @@ trait A: Sized {
44
fn f(a: A) -> A;
55
//~^ ERROR trait objects must include the `dyn` keyword
66
//~| ERROR trait objects must include the `dyn` keyword
7+
//~| ERROR associated item referring to unboxed trait object for its own trait
8+
//~| ERROR the trait `A` cannot be made into an object
79
}
810
trait B {
911
fn f(a: B) -> B;
1012
//~^ ERROR trait objects must include the `dyn` keyword
1113
//~| ERROR trait objects must include the `dyn` keyword
14+
//~| ERROR associated item referring to unboxed trait object for its own trait
15+
//~| ERROR the trait `B` cannot be made into an object
1216
}
1317
trait C {
1418
fn f(&self, a: C) -> C;

‎tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.stderr‎

Lines changed: 69 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,65 @@
1+
error: associated item referring to unboxed trait object for its own trait
2+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
3+
|
4+
LL | trait A: Sized {
5+
| - in this trait
6+
LL | fn f(a: A) -> A;
7+
| ^ ^
8+
|
9+
help: you might have meant to use `Self` to refer to the implementing type
10+
|
11+
LL | fn f(a: Self) -> Self;
12+
| ~~~~ ~~~~
13+
14+
error[E0038]: the trait `A` cannot be made into an object
15+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
16+
|
17+
LL | fn f(a: A) -> A;
18+
| ^ `A` cannot be made into an object
19+
|
20+
note: for a trait to be "object safe" 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>
21+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:3:10
22+
|
23+
LL | trait A: Sized {
24+
| - ^^^^^ ...because it requires `Self: Sized`
25+
| |
26+
| this trait cannot be made into an object...
27+
28+
error: associated item referring to unboxed trait object for its own trait
29+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
30+
|
31+
LL | trait B {
32+
| - in this trait
33+
LL | fn f(a: B) -> B;
34+
| ^ ^
35+
|
36+
help: you might have meant to use `Self` to refer to the implementing type
37+
|
38+
LL | fn f(a: Self) -> Self;
39+
| ~~~~ ~~~~
40+
41+
error[E0038]: the trait `B` cannot be made into an object
42+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
43+
|
44+
LL | fn f(a: B) -> B;
45+
| ^ `B` cannot be made into an object
46+
|
47+
note: for a trait to be "object safe" 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>
48+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:8
49+
|
50+
LL | trait B {
51+
| - this trait cannot be made into an object...
52+
LL | fn f(a: B) -> B;
53+
| ^ ...because associated function `f` has no `self` parameter
54+
help: consider turning `f` into a method by giving it a `&self` argument
55+
|
56+
LL | fn f(&self, a: B) -> B;
57+
| ++++++
58+
help: alternatively, consider constraining `f` so it does not apply to trait objects
59+
|
60+
LL | fn f(a: B) -> B where Self: Sized;
61+
| +++++++++++++++++
62+
163
error[E0782]: trait objects must include the `dyn` keyword
264
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
365
|
@@ -33,7 +95,7 @@ LL | fn f(a: A) -> Box<dyn A>;
3395
| +++++++ +
3496

3597
error[E0782]: trait objects must include the `dyn` keyword
36-
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:9:13
98+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
3799
|
38100
LL | fn f(a: B) -> B;
39101
| ^
@@ -52,7 +114,7 @@ LL | fn f(a: &dyn B) -> B;
52114
| ++++
53115

54116
error[E0782]: trait objects must include the `dyn` keyword
55-
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:9:19
117+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:19
56118
|
57119
LL | fn f(a: B) -> B;
58120
| ^
@@ -67,7 +129,7 @@ LL | fn f(a: B) -> Box<dyn B>;
67129
| +++++++ +
68130

69131
error[E0782]: trait objects must include the `dyn` keyword
70-
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:14:20
132+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:20
71133
|
72134
LL | fn f(&self, a: C) -> C;
73135
| ^
@@ -86,7 +148,7 @@ LL | fn f(&self, a: &dyn C) -> C;
86148
| ++++
87149

88150
error[E0782]: trait objects must include the `dyn` keyword
89-
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:14:26
151+
--> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:26
90152
|
91153
LL | fn f(&self, a: C) -> C;
92154
| ^
@@ -100,6 +162,7 @@ help: alternatively, you can return an owned trait object
100162
LL | fn f(&self, a: C) -> Box<dyn C>;
101163
| +++++++ +
102164

103-
error: aborting due to 6 previous errors
165+
error: aborting due to 10 previous errors
104166

105-
For more information about this error, try `rustc --explain E0782`.
167+
Some errors have detailed explanations: E0038, E0782.
168+
For more information about an error, try `rustc --explain E0038`.

0 commit comments

Comments
 (0)