Skip to content

Commit 70a8e15

Browse files
RalfJungRalfJung
committed
make pointer_structural_match warn-by-default
1 parent af6c7e0 commit 70a8e15

File tree

8 files changed

+223
-26
lines changed

8 files changed

+223
-26
lines changed

‎compiler/rustc_lint_defs/src/builtin.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -2226,7 +2226,7 @@ declare_lint! {
22262226
/// in different crates and not deduplicated again via LTO. Pointer identity for memory
22272227
/// created by `const` is similarly unreliable.
22282228
pub POINTER_STRUCTURAL_MATCH,
2229-
Allow,
2229+
Warn,
22302230
"pointers are not structural-match",
22312231
@future_incompatible = FutureIncompatibleInfo {
22322232
reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,

‎library/core/src/marker.rs

+1
Original file line numberDiff line numberDiff line change
@@ -247,6 +247,7 @@ marker_impls! {
247247
///
248248
/// const CFN: Wrap<fn(&())> = Wrap(higher_order);
249249
///
250+
/// #[allow(pointer_structural_match)]
250251
/// fn main() {
251252
/// match CFN {
252253
/// CFN => {}

‎tests/ui/closures/2229_closure_analysis/match/match-edge-cases_1.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,8 @@ pub fn edge_case_str(event: String) {
2626
pub fn edge_case_raw_ptr(event: *const i32) {
2727
let _ = || {
2828
match event {
29-
NUMBER_POINTER => (),
29+
NUMBER_POINTER => (), //~WARN behave unpredictably
30+
//~| previously accepted
3031
_ => (),
3132
};
3233
};

‎tests/ui/closures/2229_closure_analysis/match/match-edge-cases_1.stderr

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
2+
--> $DIR/match-edge-cases_1.rs:29:13
3+
|
4+
LL | NUMBER_POINTER => (),
5+
| ^^^^^^^^^^^^^^
6+
|
7+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
8+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
9+
= note: `#[warn(pointer_structural_match)]` on by default
10+
11+
warning: 1 warning emitted
12+

‎tests/ui/pattern/usefulness/consts-opaque.rs

+16-8
Original file line numberDiff line numberDiff line change
@@ -95,8 +95,10 @@ fn main() {
9595
const QUUX: Quux = quux;
9696

9797
match QUUX {
98-
QUUX => {}
99-
QUUX => {}
98+
QUUX => {} //~WARN behave unpredictably
99+
//~| previously accepted
100+
QUUX => {} //~WARN behave unpredictably
101+
//~| previously accepted
100102
_ => {}
101103
}
102104

@@ -105,14 +107,17 @@ fn main() {
105107
const WRAPQUUX: Wrap<Quux> = Wrap(quux);
106108

107109
match WRAPQUUX {
108-
WRAPQUUX => {}
109-
WRAPQUUX => {}
110+
WRAPQUUX => {} //~WARN behave unpredictably
111+
//~| previously accepted
112+
WRAPQUUX => {} //~WARN behave unpredictably
113+
//~| previously accepted
110114
Wrap(_) => {}
111115
}
112116

113117
match WRAPQUUX {
114118
Wrap(_) => {}
115-
WRAPQUUX => {}
119+
WRAPQUUX => {} //~WARN behave unpredictably
120+
//~| previously accepted
116121
}
117122

118123
match WRAPQUUX {
@@ -121,7 +126,8 @@ fn main() {
121126

122127
match WRAPQUUX {
123128
//~^ ERROR: non-exhaustive patterns: `Wrap(_)` not covered
124-
WRAPQUUX => {}
129+
WRAPQUUX => {} //~WARN behave unpredictably
130+
//~| previously accepted
125131
}
126132

127133
#[derive(PartialEq, Eq)]
@@ -132,9 +138,11 @@ fn main() {
132138
const WHOKNOWSQUUX: WhoKnows<Quux> = WhoKnows::Yay(quux);
133139

134140
match WHOKNOWSQUUX {
135-
WHOKNOWSQUUX => {}
141+
WHOKNOWSQUUX => {} //~WARN behave unpredictably
142+
//~| previously accepted
136143
WhoKnows::Yay(_) => {}
137-
WHOKNOWSQUUX => {}
144+
WHOKNOWSQUUX => {} //~WARN behave unpredictably
145+
//~| previously accepted
138146
WhoKnows::Nope => {}
139147
}
140148
}

‎tests/ui/pattern/usefulness/consts-opaque.stderr

+78-6
Original file line numberDiff line numberDiff line change
@@ -91,24 +91,96 @@ LL | BAZ => {}
9191
= note: the traits must be derived, manual `impl`s are not sufficient
9292
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
9393

94+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
95+
--> $DIR/consts-opaque.rs:98:9
96+
|
97+
LL | QUUX => {}
98+
| ^^^^
99+
|
100+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
101+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
102+
= note: `#[warn(pointer_structural_match)]` on by default
103+
104+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
105+
--> $DIR/consts-opaque.rs:100:9
106+
|
107+
LL | QUUX => {}
108+
| ^^^^
109+
|
110+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
111+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
112+
113+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
114+
--> $DIR/consts-opaque.rs:110:9
115+
|
116+
LL | WRAPQUUX => {}
117+
| ^^^^^^^^
118+
|
119+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
120+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
121+
122+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
123+
--> $DIR/consts-opaque.rs:112:9
124+
|
125+
LL | WRAPQUUX => {}
126+
| ^^^^^^^^
127+
|
128+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
129+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
130+
131+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
132+
--> $DIR/consts-opaque.rs:119:9
133+
|
134+
LL | WRAPQUUX => {}
135+
| ^^^^^^^^
136+
|
137+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
138+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
139+
140+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
141+
--> $DIR/consts-opaque.rs:129:9
142+
|
143+
LL | WRAPQUUX => {}
144+
| ^^^^^^^^
145+
|
146+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
147+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
148+
149+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
150+
--> $DIR/consts-opaque.rs:141:9
151+
|
152+
LL | WHOKNOWSQUUX => {}
153+
| ^^^^^^^^^^^^
154+
|
155+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
156+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
157+
158+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
159+
--> $DIR/consts-opaque.rs:144:9
160+
|
161+
LL | WHOKNOWSQUUX => {}
162+
| ^^^^^^^^^^^^
163+
|
164+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
165+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
166+
94167
error[E0004]: non-exhaustive patterns: `Wrap(_)` not covered
95-
--> $DIR/consts-opaque.rs:122:11
168+
--> $DIR/consts-opaque.rs:127:11
96169
|
97170
LL | match WRAPQUUX {
98171
| ^^^^^^^^ pattern `Wrap(_)` not covered
99172
|
100173
note: `Wrap<fn(usize, usize) -> usize>` defined here
101-
--> $DIR/consts-opaque.rs:104:12
174+
--> $DIR/consts-opaque.rs:106:12
102175
|
103176
LL | struct Wrap<T>(T);
104177
| ^^^^
105178
= note: the matched value is of type `Wrap<fn(usize, usize) -> usize>`
106179
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
107180
|
108-
LL ~ WRAPQUUX => {},
109-
LL + Wrap(_) => todo!()
110-
|
181+
LL | WRAPQUUX => {}, Wrap(_) => todo!()
182+
| ++++++++++++++++++++
111183

112-
error: aborting due to 10 previous errors; 1 warning emitted
184+
error: aborting due to 10 previous errors; 9 warnings emitted
113185

114186
For more information about this error, try `rustc --explain E0004`.

‎tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/fn-ptr-is-structurally-matchable.rs

+20-10
Original file line numberDiff line numberDiff line change
@@ -40,71 +40,80 @@ fn main() {
4040
const CFN1: Wrap<fn()> = Wrap(trivial);
4141
let input: Wrap<fn()> = Wrap(trivial);
4242
match Wrap(input) {
43-
Wrap(CFN1) => count += 1,
43+
Wrap(CFN1) => count += 1, //~WARN behave unpredictably
44+
//~| previously accepted
4445
Wrap(_) => {}
4546
};
4647

4748
// Check that fn(T) is structural-match when T is too.
4849
const CFN2: Wrap<fn(SM)> = Wrap(sm_to);
4950
let input: Wrap<fn(SM)> = Wrap(sm_to);
5051
match Wrap(input) {
51-
Wrap(CFN2) => count += 1,
52+
Wrap(CFN2) => count += 1, //~WARN behave unpredictably
53+
//~| previously accepted
5254
Wrap(_) => {}
5355
};
5456

5557
// Check that fn() -> T is structural-match when T is too.
5658
const CFN3: Wrap<fn() -> SM> = Wrap(to_sm);
5759
let input: Wrap<fn() -> SM> = Wrap(to_sm);
5860
match Wrap(input) {
59-
Wrap(CFN3) => count += 1,
61+
Wrap(CFN3) => count += 1, //~WARN behave unpredictably
62+
//~| previously accepted
6063
Wrap(_) => {}
6164
};
6265

6366
// Check that fn(T) is structural-match even if T is not.
6467
const CFN4: Wrap<fn(NotSM)> = Wrap(not_sm_to);
6568
let input: Wrap<fn(NotSM)> = Wrap(not_sm_to);
6669
match Wrap(input) {
67-
Wrap(CFN4) => count += 1,
70+
Wrap(CFN4) => count += 1, //~WARN behave unpredictably
71+
//~| previously accepted
6872
Wrap(_) => {}
6973
};
7074

7175
// Check that fn() -> T is structural-match even if T is not.
7276
const CFN5: Wrap<fn() -> NotSM> = Wrap(to_not_sm);
7377
let input: Wrap<fn() -> NotSM> = Wrap(to_not_sm);
7478
match Wrap(input) {
75-
Wrap(CFN5) => count += 1,
79+
Wrap(CFN5) => count += 1, //~WARN behave unpredictably
80+
//~| previously accepted
7681
Wrap(_) => {}
7782
};
7883

7984
// Check that fn(&T) is structural-match when T is too.
8085
const CFN6: Wrap<fn(&SM)> = Wrap(r_sm_to);
8186
let input: Wrap<fn(&SM)> = Wrap(r_sm_to);
8287
match Wrap(input) {
83-
Wrap(CFN6) => count += 1,
88+
Wrap(CFN6) => count += 1, //~WARN behave unpredictably
89+
//~| previously accepted
8490
Wrap(_) => {}
8591
};
8692

8793
// Check that fn() -> &T is structural-match when T is too.
8894
const CFN7: Wrap<fn(&()) -> &SM> = Wrap(r_to_r_sm);
8995
let input: Wrap<fn(&()) -> &SM> = Wrap(r_to_r_sm);
9096
match Wrap(input) {
91-
Wrap(CFN7) => count += 1,
97+
Wrap(CFN7) => count += 1, //~WARN behave unpredictably
98+
//~| previously accepted
9299
Wrap(_) => {}
93100
};
94101

95102
// Check that fn(T) is structural-match even if T is not.
96103
const CFN8: Wrap<fn(&NotSM)> = Wrap(r_not_sm_to);
97104
let input: Wrap<fn(&NotSM)> = Wrap(r_not_sm_to);
98105
match Wrap(input) {
99-
Wrap(CFN8) => count += 1,
106+
Wrap(CFN8) => count += 1, //~WARN behave unpredictably
107+
//~| previously accepted
100108
Wrap(_) => {}
101109
};
102110

103111
// Check that fn() -> T is structural-match even if T is not.
104112
const CFN9: Wrap<fn(&()) -> &NotSM> = Wrap(r_to_r_not_sm);
105113
let input: Wrap<fn(&()) -> &NotSM> = Wrap(r_to_r_not_sm);
106114
match Wrap(input) {
107-
Wrap(CFN9) => count += 1,
115+
Wrap(CFN9) => count += 1, //~WARN behave unpredictably
116+
//~| previously accepted
108117
Wrap(_) => {}
109118
};
110119

@@ -126,7 +135,8 @@ fn main() {
126135

127136
let input = Foo { alpha: not_sm_to, beta: to_not_sm, gamma: sm_to, delta: to_sm };
128137
match input {
129-
CFOO => count += 1,
138+
CFOO => count += 1, //~WARN behave unpredictably
139+
//~| previously accepted
130140
Foo { .. } => {}
131141
};
132142

‎tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/fn-ptr-is-structurally-matchable.stderr

+93
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,93 @@
1+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
2+
--> $DIR/fn-ptr-is-structurally-matchable.rs:43:14
3+
|
4+
LL | Wrap(CFN1) => count += 1,
5+
| ^^^^
6+
|
7+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
8+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
9+
= note: `#[warn(pointer_structural_match)]` on by default
10+
11+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
12+
--> $DIR/fn-ptr-is-structurally-matchable.rs:52:14
13+
|
14+
LL | Wrap(CFN2) => count += 1,
15+
| ^^^^
16+
|
17+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
18+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
19+
20+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
21+
--> $DIR/fn-ptr-is-structurally-matchable.rs:61:14
22+
|
23+
LL | Wrap(CFN3) => count += 1,
24+
| ^^^^
25+
|
26+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
27+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
28+
29+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
30+
--> $DIR/fn-ptr-is-structurally-matchable.rs:70:14
31+
|
32+
LL | Wrap(CFN4) => count += 1,
33+
| ^^^^
34+
|
35+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
36+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
37+
38+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
39+
--> $DIR/fn-ptr-is-structurally-matchable.rs:79:14
40+
|
41+
LL | Wrap(CFN5) => count += 1,
42+
| ^^^^
43+
|
44+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
45+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
46+
47+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
48+
--> $DIR/fn-ptr-is-structurally-matchable.rs:88:14
49+
|
50+
LL | Wrap(CFN6) => count += 1,
51+
| ^^^^
52+
|
53+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
54+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
55+
56+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
57+
--> $DIR/fn-ptr-is-structurally-matchable.rs:97:14
58+
|
59+
LL | Wrap(CFN7) => count += 1,
60+
| ^^^^
61+
|
62+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
63+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
64+
65+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
66+
--> $DIR/fn-ptr-is-structurally-matchable.rs:106:14
67+
|
68+
LL | Wrap(CFN8) => count += 1,
69+
| ^^^^
70+
|
71+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
72+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
73+
74+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
75+
--> $DIR/fn-ptr-is-structurally-matchable.rs:115:14
76+
|
77+
LL | Wrap(CFN9) => count += 1,
78+
| ^^^^
79+
|
80+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
81+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
82+
83+
warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
84+
--> $DIR/fn-ptr-is-structurally-matchable.rs:138:9
85+
|
86+
LL | CFOO => count += 1,
87+
| ^^^^
88+
|
89+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
90+
= note: for more information, see issue #62411 <https://github.com/rust-lang/rust/issues/70861>
91+
92+
warning: 10 warnings emitted
93+

0 commit comments

Comments
 (0)