Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit c82d619

Browse files
ShE3pyShE3py
committedApr 12, 2024··
Update tests
1 parent 360de09 commit c82d619

7 files changed

+513
-122
lines changed
 

‎tests/ui/parser/recover/recover-pat-exprs.rs

+47-4
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,57 @@
1+
// FieldExpression, TupleIndexingExpression
2+
fn field_access() {
3+
match 0 {
4+
x => (),
5+
x.y => (), //~ error: expected a pattern, found an expression
6+
x.0 => (), //~ error: expected a pattern, found an expression
7+
x._0 => (), //~ error: expected a pattern, found an expression
8+
x.0.1 => (), //~ error: expected a pattern, found an expression
9+
x.4.y.17.__z => (), //~ error: expected a pattern, found an expression
10+
x.0e0 => (), //~ error: expected one of `=>`, `@`, `if`, or `|`, found `.`
11+
}
12+
}
13+
14+
// MethodCallExpression, CallExpression, ErrorPropagationExpression
15+
fn method_call() {
16+
match 0 {
17+
x.f() => (), //~ error: expected a pattern, found an expression
18+
x._f() => (), //~ error: expected a pattern, found an expression
19+
x? => (), //~ error: expected a pattern, found an expression
20+
().f() => (), //~ error: expected a pattern, found an expression
21+
(0, x)?.f() => (), //~ error: expected a pattern, found an expression
22+
x.f().g() => (), //~ error: expected a pattern, found an expression
23+
0.f()?.g()?? => (), //~ error: expected a pattern, found an expression
24+
}
25+
}
26+
27+
// TypeCastExpression
28+
fn type_cast() {
29+
match 0 {
30+
x as usize => (), //~ error: expected a pattern, found an expression
31+
0 as usize => (), //~ error: expected a pattern, found an expression
32+
x.f().0.4 as f32 => (), //~ error: expected a pattern, found an expression
33+
}
34+
}
35+
36+
// ArithmeticOrLogicalExpression
37+
fn operator() {
38+
match 0 {
39+
1 + 1 => (), //~ error: expected a pattern, found an expression
40+
(1 + 2) * 3 => (), //~ error: expected a pattern, found an expression
41+
}
42+
}
43+
144
fn main() {
245
match u8::MAX {
346
u8::MAX.abs() => (),
4-
//~^ error: expected a pattern, found a method call
47+
//~^ error: expected a pattern, found an expression
548
x.sqrt() @ .. => (),
6-
//~^ error: expected a pattern, found a method call
49+
//~^ error: expected a pattern, found an expression
750
//~| error: left-hand side of `@` must be a binding
851
z @ w @ v.u() => (),
9-
//~^ error: expected a pattern, found a method call
52+
//~^ error: expected a pattern, found an expression
1053
y.ilog(3) => (),
11-
//~^ error: expected a pattern, found a method call
54+
//~^ error: expected a pattern, found an expression
1255
n + 1 => (),
1356
//~^ error: expected a pattern, found an expression
1457
("".f() + 14 * 8) => (),

‎tests/ui/parser/recover/recover-pat-exprs.stderr

+292-34
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,11 @@
1-
error: expected a pattern, found a method call
2-
--> $DIR/pat-recover-exprs.rs:3:9
1+
error: expected one of `=>`, `@`, `if`, or `|`, found `.`
2+
--> $DIR/recover-pat-exprs.rs:10:10
33
|
4-
LL | u8::MAX.abs() => (),
5-
| ^^^^^^^^^^^^^ method calls are not allowed in patterns
6-
7-
error: expected a pattern, found a method call
8-
--> $DIR/pat-recover-exprs.rs:5:9
9-
|
10-
LL | x.sqrt() @ .. => (),
11-
| ^^^^^^^^ method calls are not allowed in patterns
4+
LL | x.0e0 => (),
5+
| ^ expected one of `=>`, `@`, `if`, or `|`
126

137
error: left-hand side of `@` must be a binding
14-
--> $DIR/pat-recover-exprs.rs:5:9
8+
--> $DIR/recover-pat-exprs.rs:48:9
159
|
1610
LL | x.sqrt() @ .. => (),
1711
| --------^^^--
@@ -21,56 +15,320 @@ LL | x.sqrt() @ .. => (),
2115
|
2216
= note: bindings are `x`, `mut x`, `ref x`, and `ref mut x`
2317

24-
error: expected a pattern, found a method call
25-
--> $DIR/pat-recover-exprs.rs:8:17
18+
error: expected one of `)`, `,`, or `|`, found `+`
19+
--> $DIR/recover-pat-exprs.rs:62:12
20+
|
21+
LL | (_ + 1) => (),
22+
| ^ expected one of `)`, `,`, or `|`
23+
24+
error: expected one of `)`, `,`, `@`, or `|`, found `*`
25+
--> $DIR/recover-pat-exprs.rs:69:28
26+
|
27+
LL | let b = matches!(x, (x * x | x.f()) | x[0]);
28+
| ^ expected one of `)`, `,`, `@`, or `|`
29+
--> $SRC_DIR/core/src/macros/mod.rs:LL:COL
30+
|
31+
= note: while parsing argument for this `pat` macro fragment
32+
33+
error: expected a pattern, found an expression
34+
--> $DIR/recover-pat-exprs.rs:5:9
35+
|
36+
LL | x.y => (),
37+
| ^^^ arbitrary expressions are not allowed in patterns
38+
|
39+
= help: extract the expression into a `const` and refer to it
40+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
41+
|
42+
LL | const { x.y } => (),
43+
| +++++++ +
44+
45+
error: expected a pattern, found an expression
46+
--> $DIR/recover-pat-exprs.rs:6:9
47+
|
48+
LL | x.0 => (),
49+
| ^^^ arbitrary expressions are not allowed in patterns
50+
|
51+
= help: extract the expression into a `const` and refer to it
52+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
53+
|
54+
LL | const { x.0 } => (),
55+
| +++++++ +
56+
57+
error: expected a pattern, found an expression
58+
--> $DIR/recover-pat-exprs.rs:7:9
59+
|
60+
LL | x._0 => (),
61+
| ^^^^ arbitrary expressions are not allowed in patterns
62+
|
63+
= help: extract the expression into a `const` and refer to it
64+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
65+
|
66+
LL | const { x._0 } => (),
67+
| +++++++ +
68+
69+
error: expected a pattern, found an expression
70+
--> $DIR/recover-pat-exprs.rs:8:9
71+
|
72+
LL | x.0.1 => (),
73+
| ^^^^^ arbitrary expressions are not allowed in patterns
74+
|
75+
= help: extract the expression into a `const` and refer to it
76+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
77+
|
78+
LL | const { x.0.1 } => (),
79+
| +++++++ +
80+
81+
error: expected a pattern, found an expression
82+
--> $DIR/recover-pat-exprs.rs:9:9
83+
|
84+
LL | x.4.y.17.__z => (),
85+
| ^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
86+
|
87+
= help: extract the expression into a `const` and refer to it
88+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
89+
|
90+
LL | const { x.4.y.17.__z } => (),
91+
| +++++++ +
92+
93+
error: expected a pattern, found an expression
94+
--> $DIR/recover-pat-exprs.rs:17:9
95+
|
96+
LL | x.f() => (),
97+
| ^^^^^ arbitrary expressions are not allowed in patterns
98+
|
99+
= help: extract the expression into a `const` and refer to it
100+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
101+
|
102+
LL | const { x.f() } => (),
103+
| +++++++ +
104+
105+
error: expected a pattern, found an expression
106+
--> $DIR/recover-pat-exprs.rs:18:9
107+
|
108+
LL | x._f() => (),
109+
| ^^^^^^ arbitrary expressions are not allowed in patterns
110+
|
111+
= help: extract the expression into a `const` and refer to it
112+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
113+
|
114+
LL | const { x._f() } => (),
115+
| +++++++ +
116+
117+
error: expected a pattern, found an expression
118+
--> $DIR/recover-pat-exprs.rs:19:9
119+
|
120+
LL | x? => (),
121+
| ^^ arbitrary expressions are not allowed in patterns
122+
|
123+
= help: extract the expression into a `const` and refer to it
124+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
125+
|
126+
LL | const { x? } => (),
127+
| +++++++ +
128+
129+
error: expected a pattern, found an expression
130+
--> $DIR/recover-pat-exprs.rs:20:9
131+
|
132+
LL | ().f() => (),
133+
| ^^^^^^ arbitrary expressions are not allowed in patterns
134+
|
135+
= help: extract the expression into a `const` and refer to it
136+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
137+
|
138+
LL | const { ().f() } => (),
139+
| +++++++ +
140+
141+
error: expected a pattern, found an expression
142+
--> $DIR/recover-pat-exprs.rs:21:9
143+
|
144+
LL | (0, x)?.f() => (),
145+
| ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
146+
|
147+
= help: extract the expression into a `const` and refer to it
148+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
149+
|
150+
LL | const { (0, x)?.f() } => (),
151+
| +++++++ +
152+
153+
error: expected a pattern, found an expression
154+
--> $DIR/recover-pat-exprs.rs:22:9
155+
|
156+
LL | x.f().g() => (),
157+
| ^^^^^^^^^ arbitrary expressions are not allowed in patterns
158+
|
159+
= help: extract the expression into a `const` and refer to it
160+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
161+
|
162+
LL | const { x.f().g() } => (),
163+
| +++++++ +
164+
165+
error: expected a pattern, found an expression
166+
--> $DIR/recover-pat-exprs.rs:23:9
167+
|
168+
LL | 0.f()?.g()?? => (),
169+
| ^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
170+
|
171+
= help: extract the expression into a `const` and refer to it
172+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
173+
|
174+
LL | const { 0.f()?.g()?? } => (),
175+
| +++++++ +
176+
177+
error: expected a pattern, found an expression
178+
--> $DIR/recover-pat-exprs.rs:30:9
179+
|
180+
LL | x as usize => (),
181+
| ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
182+
|
183+
= help: extract the expression into a `const` and refer to it
184+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
185+
|
186+
LL | const { x as usize } => (),
187+
| +++++++ +
188+
189+
error: expected a pattern, found an expression
190+
--> $DIR/recover-pat-exprs.rs:31:9
191+
|
192+
LL | 0 as usize => (),
193+
| ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
194+
|
195+
= help: extract the expression into a `const` and refer to it
196+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
197+
|
198+
LL | const { 0 as usize } => (),
199+
| +++++++ +
200+
201+
error: expected a pattern, found an expression
202+
--> $DIR/recover-pat-exprs.rs:32:9
203+
|
204+
LL | x.f().0.4 as f32 => (),
205+
| ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
206+
|
207+
= help: extract the expression into a `const` and refer to it
208+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
209+
|
210+
LL | const { x.f().0.4 as f32 } => (),
211+
| +++++++ +
212+
213+
error: expected a pattern, found an expression
214+
--> $DIR/recover-pat-exprs.rs:39:9
215+
|
216+
LL | 1 + 1 => (),
217+
| ^^^^^ arbitrary expressions are not allowed in patterns
218+
|
219+
= help: extract the expression into a `const` and refer to it
220+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
221+
|
222+
LL | const { 1 + 1 } => (),
223+
| +++++++ +
224+
225+
error: expected a pattern, found an expression
226+
--> $DIR/recover-pat-exprs.rs:40:9
227+
|
228+
LL | (1 + 2) * 3 => (),
229+
| ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
230+
|
231+
= help: extract the expression into a `const` and refer to it
232+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
233+
|
234+
LL | const { (1 + 2) * 3 } => (),
235+
| +++++++ +
236+
237+
error: expected a pattern, found an expression
238+
--> $DIR/recover-pat-exprs.rs:46:9
239+
|
240+
LL | u8::MAX.abs() => (),
241+
| ^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
242+
|
243+
= help: extract the expression into a `const` and refer to it
244+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
245+
|
246+
LL | const { u8::MAX.abs() } => (),
247+
| +++++++ +
248+
249+
error: expected a pattern, found an expression
250+
--> $DIR/recover-pat-exprs.rs:48:9
251+
|
252+
LL | x.sqrt() @ .. => (),
253+
| ^^^^^^^^ arbitrary expressions are not allowed in patterns
254+
|
255+
= help: extract the expression into a `const` and refer to it
256+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
257+
|
258+
LL | const { x.sqrt() } @ .. => (),
259+
| +++++++ +
260+
261+
error: expected a pattern, found an expression
262+
--> $DIR/recover-pat-exprs.rs:51:17
26263
|
27264
LL | z @ w @ v.u() => (),
28-
| ^^^^^ method calls are not allowed in patterns
265+
| ^^^^^ arbitrary expressions are not allowed in patterns
266+
|
267+
= help: extract the expression into a `const` and refer to it
268+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
269+
|
270+
LL | z @ w @ const { v.u() } => (),
271+
| +++++++ +
29272

30-
error: expected a pattern, found a method call
31-
--> $DIR/pat-recover-exprs.rs:10:9
273+
error: expected a pattern, found an expression
274+
--> $DIR/recover-pat-exprs.rs:53:9
32275
|
33276
LL | y.ilog(3) => (),
34-
| ^^^^^^^^^ method calls are not allowed in patterns
277+
| ^^^^^^^^^ arbitrary expressions are not allowed in patterns
278+
|
279+
= help: extract the expression into a `const` and refer to it
280+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
281+
|
282+
LL | const { y.ilog(3) } => (),
283+
| +++++++ +
35284

36285
error: expected a pattern, found an expression
37-
--> $DIR/pat-recover-exprs.rs:12:9
286+
--> $DIR/recover-pat-exprs.rs:55:9
38287
|
39288
LL | n + 1 => (),
40289
| ^^^^^ arbitrary expressions are not allowed in patterns
290+
|
291+
= help: extract the expression into a `const` and refer to it
292+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
293+
|
294+
LL | const { n + 1 } => (),
295+
| +++++++ +
41296

42297
error: expected a pattern, found an expression
43-
--> $DIR/pat-recover-exprs.rs:14:10
298+
--> $DIR/recover-pat-exprs.rs:57:10
44299
|
45300
LL | ("".f() + 14 * 8) => (),
46301
| ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
302+
|
303+
= help: extract the expression into a `const` and refer to it
304+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
305+
|
306+
LL | (const { "".f() + 14 * 8 }) => (),
307+
| +++++++ +
47308

48309
error: expected a pattern, found an expression
49-
--> $DIR/pat-recover-exprs.rs:17:9
310+
--> $DIR/recover-pat-exprs.rs:60:9
50311
|
51312
LL | f?() => (),
52313
| ^^^^ arbitrary expressions are not allowed in patterns
53-
54-
error: expected one of `)`, `,`, or `|`, found `+`
55-
--> $DIR/pat-recover-exprs.rs:19:12
56314
|
57-
LL | (_ + 1) => (),
58-
| ^ expected one of `)`, `,`, or `|`
315+
= help: extract the expression into a `const` and refer to it
316+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
317+
|
318+
LL | const { f?() } => (),
319+
| +++++++ +
59320

60321
error: expected a pattern, found an expression
61-
--> $DIR/pat-recover-exprs.rs:23:9
322+
--> $DIR/recover-pat-exprs.rs:66:9
62323
|
63324
LL | let 1 + 1 = 2;
64325
| ^^^^^ arbitrary expressions are not allowed in patterns
65-
66-
error: expected one of `)`, `,`, `@`, or `|`, found `*`
67-
--> $DIR/pat-recover-exprs.rs:26:28
68326
|
69-
LL | let b = matches!(x, (x * x | x.f()) | x[0]);
70-
| ^ expected one of `)`, `,`, `@`, or `|`
71-
--> $SRC_DIR/core/src/macros/mod.rs:LL:COL
327+
= help: extract the expression into a `const` and refer to it
328+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
72329
|
73-
= note: while parsing argument for this `pat` macro fragment
330+
LL | let const { 1 + 1 } = 2;
331+
| +++++++ +
74332

75-
error: aborting due to 11 previous errors
333+
error: aborting due to 29 previous errors
76334

‎tests/ui/parser/recover/recover-pat-issues.rs

+16-7
Original file line numberDiff line numberDiff line change
@@ -4,34 +4,43 @@ struct Bar { baz: String }
44
fn foo(foo: Foo) -> bool {
55
match foo {
66
Foo("hi".to_owned()) => true,
7-
//~^ error: expected a pattern, found a method call
7+
//~^ error: expected a pattern, found an expression
88
_ => false
99
}
1010
}
1111

1212
fn bar(bar: Bar) -> bool {
1313
match bar {
1414
Bar { baz: "hi".to_owned() } => true,
15-
//~^ error: expected a pattern, found a method call
15+
//~^ error: expected a pattern, found an expression
1616
_ => false
1717
}
1818
}
1919

20-
fn baz() { // issue #90121
20+
/// Issue #90121
21+
fn baz() {
2122
let foo = vec!["foo".to_string()];
2223

2324
match foo.as_slice() {
2425
&["foo".to_string()] => {}
25-
//~^ error: expected a pattern, found a method call
26+
//~^ error: expected a pattern, found an expression
2627
_ => {}
2728
};
2829
}
2930

31+
/// Issue #104996
32+
fn qux() {
33+
struct Magic(pub u16);
34+
const MAGIC: Magic = Magic(42);
35+
36+
if let Some(MAGIC.0 as usize) = None::<usize> {}
37+
//~^ error: expected a pattern, found an expression
38+
}
39+
3040
fn main() {
3141
if let (-1.some(4)) = (0, Some(4)) {}
32-
//~^ error: expected a pattern, found a method call
42+
//~^ error: expected a pattern, found an expression
3343

3444
if let (-1.Some(4)) = (0, Some(4)) {}
35-
//~^ error: expected one of `)`, `,`, `...`, `..=`, `..`, or `|`, found `.`
36-
//~| help: missing `,`
45+
//~^ error: expected a pattern, found an expression
3746
}

‎tests/ui/parser/recover/recover-pat-issues.stderr

+58-19
Original file line numberDiff line numberDiff line change
@@ -1,35 +1,74 @@
1-
error: expected a pattern, found a method call
2-
--> $DIR/pat-recover-methodcalls.rs:6:13
1+
error: expected a pattern, found an expression
2+
--> $DIR/recover-pat-issues.rs:6:13
33
|
44
LL | Foo("hi".to_owned()) => true,
5-
| ^^^^^^^^^^^^^^^ method calls are not allowed in patterns
5+
| ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
6+
|
7+
= help: extract the expression into a `const` and refer to it
8+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
9+
|
10+
LL | Foo(const { "hi".to_owned() }) => true,
11+
| +++++++ +
612

7-
error: expected a pattern, found a method call
8-
--> $DIR/pat-recover-methodcalls.rs:14:20
13+
error: expected a pattern, found an expression
14+
--> $DIR/recover-pat-issues.rs:14:20
915
|
1016
LL | Bar { baz: "hi".to_owned() } => true,
11-
| ^^^^^^^^^^^^^^^ method calls are not allowed in patterns
17+
| ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
18+
|
19+
= help: extract the expression into a `const` and refer to it
20+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
21+
|
22+
LL | Bar { baz: const { "hi".to_owned() } } => true,
23+
| +++++++ +
1224

13-
error: expected a pattern, found a method call
14-
--> $DIR/pat-recover-methodcalls.rs:24:11
25+
error: expected a pattern, found an expression
26+
--> $DIR/recover-pat-issues.rs:25:11
1527
|
1628
LL | &["foo".to_string()] => {}
17-
| ^^^^^^^^^^^^^^^^^ method calls are not allowed in patterns
29+
| ^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
30+
|
31+
= help: extract the expression into a `const` and refer to it
32+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
33+
|
34+
LL | &[const { "foo".to_string() }] => {}
35+
| +++++++ +
36+
37+
error: expected a pattern, found an expression
38+
--> $DIR/recover-pat-issues.rs:36:17
39+
|
40+
LL | if let Some(MAGIC.0 as usize) = None::<usize> {}
41+
| ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
42+
|
43+
= help: extract the expression into a `const` and refer to it
44+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
45+
|
46+
LL | if let Some(const { MAGIC.0 as usize }) = None::<usize> {}
47+
| +++++++ +
1848

19-
error: expected a pattern, found a method call
20-
--> $DIR/pat-recover-methodcalls.rs:31:13
49+
error: expected a pattern, found an expression
50+
--> $DIR/recover-pat-issues.rs:41:13
2151
|
2252
LL | if let (-1.some(4)) = (0, Some(4)) {}
23-
| ^^^^^^^^^^ method calls are not allowed in patterns
53+
| ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
54+
|
55+
= help: extract the expression into a `const` and refer to it
56+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
57+
|
58+
LL | if let (const { -1.some(4) }) = (0, Some(4)) {}
59+
| +++++++ +
2460

25-
error: expected one of `)`, `,`, `...`, `..=`, `..`, or `|`, found `.`
26-
--> $DIR/pat-recover-methodcalls.rs:34:15
61+
error: expected a pattern, found an expression
62+
--> $DIR/recover-pat-issues.rs:44:13
2763
|
2864
LL | if let (-1.Some(4)) = (0, Some(4)) {}
29-
| ^
30-
| |
31-
| expected one of `)`, `,`, `...`, `..=`, `..`, or `|`
32-
| help: missing `,`
65+
| ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
66+
|
67+
= help: extract the expression into a `const` and refer to it
68+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
69+
|
70+
LL | if let (const { -1.Some(4) }) = (0, Some(4)) {}
71+
| +++++++ +
3372

34-
error: aborting due to 5 previous errors
73+
error: aborting due to 6 previous errors
3574

‎tests/ui/parser/recover/recover-pat-ranges.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@ fn main() {
2222
//~| warning: `...` range patterns are deprecated
2323
//~| warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
2424
0.x()..="y".z() => (),
25-
//~^ error: expected a pattern range bound, found a method call
26-
//~| error: expected a pattern range bound, found a method call
25+
//~^ error: expected a pattern range bound, found an expression
26+
//~| error: expected a pattern range bound, found an expression
2727
};
2828
}
2929

‎tests/ui/parser/recover/recover-pat-ranges.stderr

+76-40
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
error: range pattern bounds cannot have parentheses
2-
--> $DIR/pat-recover-ranges.rs:4:13
2+
--> $DIR/recover-pat-ranges.rs:4:13
33
|
44
LL | 0..=(1) => (),
55
| ^ ^
@@ -11,7 +11,7 @@ LL + 0..=1 => (),
1111
|
1212

1313
error: range pattern bounds cannot have parentheses
14-
--> $DIR/pat-recover-ranges.rs:6:9
14+
--> $DIR/recover-pat-ranges.rs:6:9
1515
|
1616
LL | (-12)..=4 => (),
1717
| ^ ^
@@ -23,7 +23,7 @@ LL + -12..=4 => (),
2323
|
2424

2525
error: range pattern bounds cannot have parentheses
26-
--> $DIR/pat-recover-ranges.rs:8:9
26+
--> $DIR/recover-pat-ranges.rs:8:9
2727
|
2828
LL | (0)..=(-4) => (),
2929
| ^ ^
@@ -35,7 +35,7 @@ LL + 0..=(-4) => (),
3535
|
3636

3737
error: range pattern bounds cannot have parentheses
38-
--> $DIR/pat-recover-ranges.rs:8:15
38+
--> $DIR/recover-pat-ranges.rs:8:15
3939
|
4040
LL | (0)..=(-4) => (),
4141
| ^ ^
@@ -46,14 +46,8 @@ LL - (0)..=(-4) => (),
4646
LL + (0)..=-4 => (),
4747
|
4848

49-
error: expected a pattern range bound, found an expression
50-
--> $DIR/pat-recover-ranges.rs:11:12
51-
|
52-
LL | ..=1 + 2 => (),
53-
| ^^^^^ arbitrary expressions are not allowed in patterns
54-
5549
error: range pattern bounds cannot have parentheses
56-
--> $DIR/pat-recover-ranges.rs:13:9
50+
--> $DIR/recover-pat-ranges.rs:13:9
5751
|
5852
LL | (4).. => (),
5953
| ^ ^
@@ -64,14 +58,8 @@ LL - (4).. => (),
6458
LL + 4.. => (),
6559
|
6660

67-
error: expected a pattern range bound, found an expression
68-
--> $DIR/pat-recover-ranges.rs:15:10
69-
|
70-
LL | (-4 + 0).. => (),
71-
| ^^^^^^ arbitrary expressions are not allowed in patterns
72-
7361
error: range pattern bounds cannot have parentheses
74-
--> $DIR/pat-recover-ranges.rs:15:9
62+
--> $DIR/recover-pat-ranges.rs:15:9
7563
|
7664
LL | (-4 + 0).. => (),
7765
| ^ ^
@@ -82,14 +70,8 @@ LL - (-4 + 0).. => (),
8270
LL + -4 + 0.. => (),
8371
|
8472

85-
error: expected a pattern range bound, found an expression
86-
--> $DIR/pat-recover-ranges.rs:18:10
87-
|
88-
LL | (1 + 4)...1 * 2 => (),
89-
| ^^^^^ arbitrary expressions are not allowed in patterns
90-
9173
error: range pattern bounds cannot have parentheses
92-
--> $DIR/pat-recover-ranges.rs:18:9
74+
--> $DIR/recover-pat-ranges.rs:18:9
9375
|
9476
LL | (1 + 4)...1 * 2 => (),
9577
| ^ ^
@@ -100,33 +82,87 @@ LL - (1 + 4)...1 * 2 => (),
10082
LL + 1 + 4...1 * 2 => (),
10183
|
10284

85+
warning: `...` range patterns are deprecated
86+
--> $DIR/recover-pat-ranges.rs:18:16
87+
|
88+
LL | (1 + 4)...1 * 2 => (),
89+
| ^^^ help: use `..=` for an inclusive range
90+
|
91+
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
92+
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
93+
= note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
94+
95+
error: expected a pattern range bound, found an expression
96+
--> $DIR/recover-pat-ranges.rs:11:12
97+
|
98+
LL | ..=1 + 2 => (),
99+
| ^^^^^ arbitrary expressions are not allowed in patterns
100+
|
101+
= help: extract the expression into a `const` and refer to it
102+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
103+
|
104+
LL | ..=const { 1 + 2 } => (),
105+
| +++++++ +
106+
103107
error: expected a pattern range bound, found an expression
104-
--> $DIR/pat-recover-ranges.rs:18:19
108+
--> $DIR/recover-pat-ranges.rs:15:10
109+
|
110+
LL | (-4 + 0).. => (),
111+
| ^^^^^^ arbitrary expressions are not allowed in patterns
112+
|
113+
= help: extract the expression into a `const` and refer to it
114+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
115+
|
116+
LL | (const { -4 + 0 }).. => (),
117+
| +++++++ +
118+
119+
error: expected a pattern range bound, found an expression
120+
--> $DIR/recover-pat-ranges.rs:18:10
121+
|
122+
LL | (1 + 4)...1 * 2 => (),
123+
| ^^^^^ arbitrary expressions are not allowed in patterns
124+
|
125+
= help: extract the expression into a `const` and refer to it
126+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
127+
|
128+
LL | (const { 1 + 4 })...1 * 2 => (),
129+
| +++++++ +
130+
131+
error: expected a pattern range bound, found an expression
132+
--> $DIR/recover-pat-ranges.rs:18:19
105133
|
106134
LL | (1 + 4)...1 * 2 => (),
107135
| ^^^^^ arbitrary expressions are not allowed in patterns
136+
|
137+
= help: extract the expression into a `const` and refer to it
138+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
139+
|
140+
LL | (1 + 4)...const { 1 * 2 } => (),
141+
| +++++++ +
108142

109-
error: expected a pattern range bound, found a method call
110-
--> $DIR/pat-recover-ranges.rs:24:9
143+
error: expected a pattern range bound, found an expression
144+
--> $DIR/recover-pat-ranges.rs:24:9
111145
|
112146
LL | 0.x()..="y".z() => (),
113-
| ^^^^^ method calls are not allowed in patterns
147+
| ^^^^^ arbitrary expressions are not allowed in patterns
148+
|
149+
= help: extract the expression into a `const` and refer to it
150+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
151+
|
152+
LL | const { 0.x() }..="y".z() => (),
153+
| +++++++ +
114154

115-
error: expected a pattern range bound, found a method call
116-
--> $DIR/pat-recover-ranges.rs:24:17
155+
error: expected a pattern range bound, found an expression
156+
--> $DIR/recover-pat-ranges.rs:24:17
117157
|
118158
LL | 0.x()..="y".z() => (),
119-
| ^^^^^^^ method calls are not allowed in patterns
120-
121-
warning: `...` range patterns are deprecated
122-
--> $DIR/pat-recover-ranges.rs:18:16
159+
| ^^^^^^^ arbitrary expressions are not allowed in patterns
123160
|
124-
LL | (1 + 4)...1 * 2 => (),
125-
| ^^^ help: use `..=` for an inclusive range
161+
= help: extract the expression into a `const` and refer to it
162+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
126163
|
127-
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
128-
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
129-
= note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
164+
LL | 0.x()..=const { "y".z() } => (),
165+
| +++++++ +
130166

131167
error: aborting due to 13 previous errors; 1 warning emitted
132168

‎tests/ui/parser/recover/recover-pat-wildcards.stderr

+22-16
Original file line numberDiff line numberDiff line change
@@ -1,67 +1,61 @@
11
error: expected one of `=>`, `if`, or `|`, found `+`
2-
--> $DIR/pat-recover-wildcards.rs:5:11
2+
--> $DIR/recover-pat-wildcards.rs:5:11
33
|
44
LL | _ + 1 => ()
55
| ^ expected one of `=>`, `if`, or `|`
66

77
error: expected one of `)`, `,`, or `|`, found `%`
8-
--> $DIR/pat-recover-wildcards.rs:11:12
8+
--> $DIR/recover-pat-wildcards.rs:11:12
99
|
1010
LL | (_ % 4) => ()
1111
| ^ expected one of `)`, `,`, or `|`
1212

1313
error: expected one of `=>`, `if`, or `|`, found `.`
14-
--> $DIR/pat-recover-wildcards.rs:17:10
14+
--> $DIR/recover-pat-wildcards.rs:17:10
1515
|
1616
LL | _.x() => ()
1717
| ^ expected one of `=>`, `if`, or `|`
1818

1919
error: expected one of `=>`, `if`, or `|`, found `..=`
20-
--> $DIR/pat-recover-wildcards.rs:23:10
20+
--> $DIR/recover-pat-wildcards.rs:23:10
2121
|
2222
LL | _..=4 => ()
2323
| ^^^ expected one of `=>`, `if`, or `|`
2424

2525
error: expected one of `=>`, `if`, or `|`, found reserved identifier `_`
26-
--> $DIR/pat-recover-wildcards.rs:29:11
26+
--> $DIR/recover-pat-wildcards.rs:29:11
2727
|
2828
LL | .._ => ()
2929
| ^ expected one of `=>`, `if`, or `|`
3030

3131
error[E0586]: inclusive range with no end
32-
--> $DIR/pat-recover-wildcards.rs:35:10
32+
--> $DIR/recover-pat-wildcards.rs:35:10
3333
|
3434
LL | 0..._ => ()
3535
| ^^^ help: use `..` instead
3636
|
3737
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
3838

3939
error: expected one of `=>`, `if`, or `|`, found reserved identifier `_`
40-
--> $DIR/pat-recover-wildcards.rs:35:13
40+
--> $DIR/recover-pat-wildcards.rs:35:13
4141
|
4242
LL | 0..._ => ()
4343
| ^ expected one of `=>`, `if`, or `|`
4444

4545
error: expected one of `)`, `,`, or `|`, found `*`
46-
--> $DIR/pat-recover-wildcards.rs:43:12
46+
--> $DIR/recover-pat-wildcards.rs:43:12
4747
|
4848
LL | (_ * 0)..5 => ()
4949
| ^ expected one of `)`, `,`, or `|`
5050

5151
error: expected one of `=>`, `if`, or `|`, found `(`
52-
--> $DIR/pat-recover-wildcards.rs:49:11
52+
--> $DIR/recover-pat-wildcards.rs:49:11
5353
|
5454
LL | ..(_) => ()
5555
| ^ expected one of `=>`, `if`, or `|`
5656

57-
error: expected a pattern range bound, found an expression
58-
--> $DIR/pat-recover-wildcards.rs:55:14
59-
|
60-
LL | 4..=(2 + _) => ()
61-
| ^^^^^ arbitrary expressions are not allowed in patterns
62-
6357
error: range pattern bounds cannot have parentheses
64-
--> $DIR/pat-recover-wildcards.rs:55:13
58+
--> $DIR/recover-pat-wildcards.rs:55:13
6559
|
6660
LL | 4..=(2 + _) => ()
6761
| ^ ^
@@ -72,6 +66,18 @@ LL - 4..=(2 + _) => ()
7266
LL + 4..=2 + _ => ()
7367
|
7468

69+
error: expected a pattern range bound, found an expression
70+
--> $DIR/recover-pat-wildcards.rs:55:14
71+
|
72+
LL | 4..=(2 + _) => ()
73+
| ^^^^^ arbitrary expressions are not allowed in patterns
74+
|
75+
= help: extract the expression into a `const` and refer to it
76+
help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
77+
|
78+
LL | 4..=(const { 2 + _ }) => ()
79+
| +++++++ +
80+
7581
error: aborting due to 11 previous errors
7682

7783
For more information about this error, try `rustc --explain E0586`.

0 commit comments

Comments
 (0)
Please sign in to comment.