|
1 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
2 |
| - --> $DIR/pointer-sized-int.rs:12:11 |
| 1 | +error[E0004]: non-exhaustive patterns: `usize::MAX..` not covered |
| 2 | + --> $DIR/pointer-sized-int.rs:14:11 |
3 | 3 | |
|
4 | 4 | LL | match 0usize {
|
5 |
| - | ^^^^^^ pattern `_` not covered |
| 5 | + | ^^^^^^ pattern `usize::MAX..` not covered |
6 | 6 | |
|
7 | 7 | = note: the matched value is of type `usize`
|
8 |
| - = note: `usize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 8 | + = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively |
9 | 9 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `usize` matching
|
10 | 10 | help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
11 | 11 | |
|
12 | 12 | LL ~ 0 ..= usize::MAX => {},
|
13 |
| -LL + _ => todo!() |
| 13 | +LL + usize::MAX.. => todo!() |
14 | 14 | |
|
15 | 15 |
|
16 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
17 |
| - --> $DIR/pointer-sized-int.rs:17:11 |
| 16 | +error[E0004]: non-exhaustive patterns: `..isize::MIN` and `isize::MAX..` not covered |
| 17 | + --> $DIR/pointer-sized-int.rs:19:11 |
18 | 18 | |
|
19 | 19 | LL | match 0isize {
|
20 |
| - | ^^^^^^ pattern `_` not covered |
| 20 | + | ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered |
21 | 21 | |
|
22 | 22 | = note: the matched value is of type `isize`
|
23 |
| - = note: `isize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 23 | + = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively |
24 | 24 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `isize` matching
|
25 |
| -help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown |
| 25 | +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms |
26 | 26 | |
|
27 | 27 | LL ~ isize::MIN ..= isize::MAX => {},
|
28 |
| -LL + _ => todo!() |
| 28 | +LL + ..isize::MIN | isize::MAX.. => todo!() |
29 | 29 | |
|
30 | 30 |
|
31 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
32 |
| - --> $DIR/pointer-sized-int.rs:22:8 |
| 31 | +error[E0004]: non-exhaustive patterns: `usize::MAX..` not covered |
| 32 | + --> $DIR/pointer-sized-int.rs:25:8 |
33 | 33 | |
|
34 | 34 | LL | m!(0usize, 0..=usize::MAX);
|
35 |
| - | ^^^^^^ pattern `_` not covered |
| 35 | + | ^^^^^^ pattern `usize::MAX..` not covered |
36 | 36 | |
|
37 | 37 | = note: the matched value is of type `usize`
|
38 |
| - = note: `usize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 38 | + = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively |
39 | 39 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `usize` matching
|
40 | 40 | help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
41 | 41 | |
|
42 |
| -LL | match $s { $($t)+ => {}, _ => todo!() } |
43 |
| - | ++++++++++++++ |
| 42 | +LL | match $s { $($t)+ => {}, usize::MAX.. => todo!() } |
| 43 | + | +++++++++++++++++++++++++ |
44 | 44 |
|
45 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
46 |
| - --> $DIR/pointer-sized-int.rs:24:8 |
| 45 | +error[E0004]: non-exhaustive patterns: `usize::MAX..` not covered |
| 46 | + --> $DIR/pointer-sized-int.rs:27:8 |
47 | 47 | |
|
48 | 48 | LL | m!(0usize, 0..5 | 5..=usize::MAX);
|
49 |
| - | ^^^^^^ pattern `_` not covered |
| 49 | + | ^^^^^^ pattern `usize::MAX..` not covered |
50 | 50 | |
|
51 | 51 | = note: the matched value is of type `usize`
|
52 |
| - = note: `usize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 52 | + = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively |
53 | 53 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `usize` matching
|
54 | 54 | help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
55 | 55 | |
|
56 |
| -LL | match $s { $($t)+ => {}, _ => todo!() } |
57 |
| - | ++++++++++++++ |
| 56 | +LL | match $s { $($t)+ => {}, usize::MAX.. => todo!() } |
| 57 | + | +++++++++++++++++++++++++ |
58 | 58 |
|
59 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
60 |
| - --> $DIR/pointer-sized-int.rs:26:8 |
| 59 | +error[E0004]: non-exhaustive patterns: `usize::MAX..` not covered |
| 60 | + --> $DIR/pointer-sized-int.rs:29:8 |
61 | 61 | |
|
62 | 62 | LL | m!(0usize, 0..usize::MAX | usize::MAX);
|
63 |
| - | ^^^^^^ pattern `_` not covered |
| 63 | + | ^^^^^^ pattern `usize::MAX..` not covered |
64 | 64 | |
|
65 | 65 | = note: the matched value is of type `usize`
|
66 |
| - = note: `usize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 66 | + = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively |
67 | 67 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `usize` matching
|
68 | 68 | help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
69 | 69 | |
|
70 |
| -LL | match $s { $($t)+ => {}, _ => todo!() } |
71 |
| - | ++++++++++++++ |
| 70 | +LL | match $s { $($t)+ => {}, usize::MAX.. => todo!() } |
| 71 | + | +++++++++++++++++++++++++ |
72 | 72 |
|
73 |
| -error[E0004]: non-exhaustive patterns: `(_, _)` not covered |
74 |
| - --> $DIR/pointer-sized-int.rs:28:8 |
| 73 | +error[E0004]: non-exhaustive patterns: `(usize::MAX.., _)` not covered |
| 74 | + --> $DIR/pointer-sized-int.rs:31:8 |
75 | 75 | |
|
76 | 76 | LL | m!((0usize, true), (0..5, true) | (5..=usize::MAX, true) | (0..=usize::MAX, false));
|
77 |
| - | ^^^^^^^^^^^^^^ pattern `(_, _)` not covered |
| 77 | + | ^^^^^^^^^^^^^^ pattern `(usize::MAX.., _)` not covered |
78 | 78 | |
|
79 | 79 | = note: the matched value is of type `(usize, bool)`
|
80 |
| - = note: `usize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 80 | + = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively |
81 | 81 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `usize` matching
|
82 | 82 | help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
83 | 83 | |
|
84 |
| -LL | match $s { $($t)+ => {}, (_, _) => todo!() } |
85 |
| - | +++++++++++++++++++ |
| 84 | +LL | match $s { $($t)+ => {}, (usize::MAX.., _) => todo!() } |
| 85 | + | ++++++++++++++++++++++++++++++ |
86 | 86 |
|
87 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
88 |
| - --> $DIR/pointer-sized-int.rs:31:8 |
| 87 | +error[E0004]: non-exhaustive patterns: `..isize::MIN` and `isize::MAX..` not covered |
| 88 | + --> $DIR/pointer-sized-int.rs:36:8 |
89 | 89 | |
|
90 | 90 | LL | m!(0isize, isize::MIN..=isize::MAX);
|
91 |
| - | ^^^^^^ pattern `_` not covered |
| 91 | + | ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered |
92 | 92 | |
|
93 | 93 | = note: the matched value is of type `isize`
|
94 |
| - = note: `isize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 94 | + = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively |
95 | 95 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `isize` matching
|
96 |
| -help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown |
| 96 | +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms |
97 | 97 | |
|
98 |
| -LL | match $s { $($t)+ => {}, _ => todo!() } |
99 |
| - | ++++++++++++++ |
| 98 | +LL | match $s { $($t)+ => {}, ..isize::MIN | isize::MAX.. => todo!() } |
| 99 | + | ++++++++++++++++++++++++++++++++++++++++ |
100 | 100 |
|
101 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
102 |
| - --> $DIR/pointer-sized-int.rs:33:8 |
| 101 | +error[E0004]: non-exhaustive patterns: `..isize::MIN` and `isize::MAX..` not covered |
| 102 | + --> $DIR/pointer-sized-int.rs:38:8 |
103 | 103 | |
|
104 | 104 | LL | m!(0isize, isize::MIN..5 | 5..=isize::MAX);
|
105 |
| - | ^^^^^^ pattern `_` not covered |
| 105 | + | ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered |
106 | 106 | |
|
107 | 107 | = note: the matched value is of type `isize`
|
108 |
| - = note: `isize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 108 | + = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively |
109 | 109 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `isize` matching
|
110 |
| -help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown |
| 110 | +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms |
111 | 111 | |
|
112 |
| -LL | match $s { $($t)+ => {}, _ => todo!() } |
113 |
| - | ++++++++++++++ |
| 112 | +LL | match $s { $($t)+ => {}, ..isize::MIN | isize::MAX.. => todo!() } |
| 113 | + | ++++++++++++++++++++++++++++++++++++++++ |
114 | 114 |
|
115 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
116 |
| - --> $DIR/pointer-sized-int.rs:35:8 |
| 115 | +error[E0004]: non-exhaustive patterns: `..isize::MIN` and `isize::MAX..` not covered |
| 116 | + --> $DIR/pointer-sized-int.rs:40:8 |
117 | 117 | |
|
118 | 118 | LL | m!(0isize, isize::MIN..isize::MAX | isize::MAX);
|
119 |
| - | ^^^^^^ pattern `_` not covered |
| 119 | + | ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered |
120 | 120 | |
|
121 | 121 | = note: the matched value is of type `isize`
|
122 |
| - = note: `isize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 122 | + = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively |
123 | 123 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `isize` matching
|
124 |
| -help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown |
| 124 | +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms |
125 | 125 | |
|
126 |
| -LL | match $s { $($t)+ => {}, _ => todo!() } |
127 |
| - | ++++++++++++++ |
| 126 | +LL | match $s { $($t)+ => {}, ..isize::MIN | isize::MAX.. => todo!() } |
| 127 | + | ++++++++++++++++++++++++++++++++++++++++ |
128 | 128 |
|
129 |
| -error[E0004]: non-exhaustive patterns: `(_, _)` not covered |
130 |
| - --> $DIR/pointer-sized-int.rs:37:8 |
| 129 | +error[E0004]: non-exhaustive patterns: `(..isize::MIN, _)` and `(isize::MAX.., _)` not covered |
| 130 | + --> $DIR/pointer-sized-int.rs:42:8 |
131 | 131 | |
|
132 | 132 | LL | m!((0isize, true), (isize::MIN..5, true)
|
133 |
| - | ^^^^^^^^^^^^^^ pattern `(_, _)` not covered |
| 133 | + | ^^^^^^^^^^^^^^ patterns `(..isize::MIN, _)` and `(isize::MAX.., _)` not covered |
134 | 134 | |
|
135 | 135 | = note: the matched value is of type `(isize, bool)`
|
136 |
| - = note: `isize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 136 | + = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively |
137 | 137 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `isize` matching
|
138 |
| -help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown |
| 138 | +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms |
139 | 139 | |
|
140 |
| -LL | match $s { $($t)+ => {}, (_, _) => todo!() } |
141 |
| - | +++++++++++++++++++ |
| 140 | +LL | match $s { $($t)+ => {}, (..isize::MIN, _) | (isize::MAX.., _) => todo!() } |
| 141 | + | ++++++++++++++++++++++++++++++++++++++++++++++++++ |
142 | 142 |
|
143 |
| -error[E0004]: non-exhaustive patterns: `_` not covered |
144 |
| - --> $DIR/pointer-sized-int.rs:41:11 |
| 143 | +error[E0004]: non-exhaustive patterns: `..isize::MIN` and `isize::MAX..` not covered |
| 144 | + --> $DIR/pointer-sized-int.rs:47:11 |
145 | 145 | |
|
146 | 146 | LL | match 0isize {
|
147 |
| - | ^^^^^^ pattern `_` not covered |
| 147 | + | ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered |
148 | 148 | |
|
149 | 149 | = note: the matched value is of type `isize`
|
150 |
| - = note: `isize` does not have a fixed maximum value, so a wildcard `_` is necessary to match exhaustively |
| 150 | + = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively |
151 | 151 | = help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `isize` matching
|
152 |
| -help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown |
| 152 | +help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms |
153 | 153 | |
|
154 | 154 | LL ~ 1 ..= isize::MAX => {},
|
155 |
| -LL + _ => todo!() |
| 155 | +LL + ..isize::MIN | isize::MAX.. => todo!() |
156 | 156 | |
|
157 | 157 |
|
158 | 158 | error[E0004]: non-exhaustive patterns: type `usize` is non-empty
|
159 |
| - --> $DIR/pointer-sized-int.rs:48:11 |
| 159 | + --> $DIR/pointer-sized-int.rs:54:11 |
160 | 160 | |
|
161 | 161 | LL | match 7usize {}
|
162 | 162 | | ^^^^^^
|
|
0 commit comments