fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
16.4 KiB484 linesraw
1error: float literals must have an integer part
2  --> $DIR/recover-range-pats.rs:21:12
3   |
4LL |     if let .0..Y = 0 {}
5   |            ^^ help: must have an integer part: `0.0`
6
7error: float literals must have an integer part
8  --> $DIR/recover-range-pats.rs:23:16
9   |
10LL |     if let X.. .0 = 0 {}
11   |                ^^ help: must have an integer part: `0.0`
12
13error: float literals must have an integer part
14  --> $DIR/recover-range-pats.rs:34:12
15   |
16LL |     if let .0..=Y = 0 {}
17   |            ^^ help: must have an integer part: `0.0`
18
19error: float literals must have an integer part
20  --> $DIR/recover-range-pats.rs:36:16
21   |
22LL |     if let X..=.0 = 0 {}
23   |                ^^ help: must have an integer part: `0.0`
24
25error: float literals must have an integer part
26  --> $DIR/recover-range-pats.rs:59:12
27   |
28LL |     if let .0...Y = 0 {}
29   |            ^^ help: must have an integer part: `0.0`
30
31error: float literals must have an integer part
32  --> $DIR/recover-range-pats.rs:63:17
33   |
34LL |     if let X... .0 = 0 {}
35   |                 ^^ help: must have an integer part: `0.0`
36
37error: float literals must have an integer part
38  --> $DIR/recover-range-pats.rs:74:12
39   |
40LL |     if let .0.. = 0 {}
41   |            ^^ help: must have an integer part: `0.0`
42
43error[E0586]: inclusive range with no end
44  --> $DIR/recover-range-pats.rs:80:13
45   |
46LL |     if let 0..= = 0 {}
47   |             ^^^ help: use `..` instead
48   |
49   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
50
51error[E0586]: inclusive range with no end
52  --> $DIR/recover-range-pats.rs:81:13
53   |
54LL |     if let X..= = 0 {}
55   |             ^^^ help: use `..` instead
56   |
57   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
58
59error[E0586]: inclusive range with no end
60  --> $DIR/recover-range-pats.rs:82:16
61   |
62LL |     if let true..= = 0 {}
63   |                ^^^ help: use `..` instead
64   |
65   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
66
67error: float literals must have an integer part
68  --> $DIR/recover-range-pats.rs:84:12
69   |
70LL |     if let .0..= = 0 {}
71   |            ^^ help: must have an integer part: `0.0`
72
73error[E0586]: inclusive range with no end
74  --> $DIR/recover-range-pats.rs:84:14
75   |
76LL |     if let .0..= = 0 {}
77   |              ^^^ help: use `..` instead
78   |
79   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
80
81error[E0586]: inclusive range with no end
82  --> $DIR/recover-range-pats.rs:90:13
83   |
84LL |     if let 0... = 0 {}
85   |             ^^^ help: use `..` instead
86   |
87   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
88
89error[E0586]: inclusive range with no end
90  --> $DIR/recover-range-pats.rs:91:13
91   |
92LL |     if let X... = 0 {}
93   |             ^^^ help: use `..` instead
94   |
95   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
96
97error[E0586]: inclusive range with no end
98  --> $DIR/recover-range-pats.rs:92:16
99   |
100LL |     if let true... = 0 {}
101   |                ^^^ help: use `..` instead
102   |
103   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
104
105error: float literals must have an integer part
106  --> $DIR/recover-range-pats.rs:94:12
107   |
108LL |     if let .0... = 0 {}
109   |            ^^ help: must have an integer part: `0.0`
110
111error[E0586]: inclusive range with no end
112  --> $DIR/recover-range-pats.rs:94:14
113   |
114LL |     if let .0... = 0 {}
115   |              ^^^ help: use `..` instead
116   |
117   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
118
119error: float literals must have an integer part
120  --> $DIR/recover-range-pats.rs:104:15
121   |
122LL |     if let .. .0 = 0 {}
123   |               ^^ help: must have an integer part: `0.0`
124
125error: float literals must have an integer part
126  --> $DIR/recover-range-pats.rs:114:15
127   |
128LL |     if let ..=.0 = 0 {}
129   |               ^^ help: must have an integer part: `0.0`
130
131error: range-to patterns with `...` are not allowed
132  --> $DIR/recover-range-pats.rs:120:12
133   |
134LL |     if let ...3 = 0 {}
135   |            ^^^ help: use `..=` instead
136
137error: range-to patterns with `...` are not allowed
138  --> $DIR/recover-range-pats.rs:122:12
139   |
140LL |     if let ...Y = 0 {}
141   |            ^^^ help: use `..=` instead
142
143error: range-to patterns with `...` are not allowed
144  --> $DIR/recover-range-pats.rs:124:12
145   |
146LL |     if let ...true = 0 {}
147   |            ^^^ help: use `..=` instead
148
149error: float literals must have an integer part
150  --> $DIR/recover-range-pats.rs:127:15
151   |
152LL |     if let ....3 = 0 {}
153   |               ^^ help: must have an integer part: `0.3`
154
155error: range-to patterns with `...` are not allowed
156  --> $DIR/recover-range-pats.rs:127:12
157   |
158LL |     if let ....3 = 0 {}
159   |            ^^^ help: use `..=` instead
160
161error: range-to patterns with `...` are not allowed
162  --> $DIR/recover-range-pats.rs:149:17
163   |
164LL |             let ...$e;
165   |                 ^^^ help: use `..=` instead
166...
167LL |     mac!(0);
168   |     ------- in this macro invocation
169   |
170   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
171
172error[E0586]: inclusive range with no end
173  --> $DIR/recover-range-pats.rs:153:19
174   |
175LL |             let $e...;
176   |                   ^^^ help: use `..` instead
177...
178LL |     mac!(0);
179   |     ------- in this macro invocation
180   |
181   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
182   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
183
184error[E0586]: inclusive range with no end
185  --> $DIR/recover-range-pats.rs:154:19
186   |
187LL |             let $e..=;
188   |                   ^^^ help: use `..` instead
189...
190LL |     mac!(0);
191   |     ------- in this macro invocation
192   |
193   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
194   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
195
196error: `...` range patterns are deprecated
197  --> $DIR/recover-range-pats.rs:41:13
198   |
199LL |     if let 0...3 = 0 {}
200   |             ^^^ help: use `..=` for an inclusive range
201   |
202   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
203   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
204note: the lint level is defined here
205  --> $DIR/recover-range-pats.rs:7:9
206   |
207LL | #![deny(ellipsis_inclusive_range_patterns)]
208   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
209
210error: `...` range patterns are deprecated
211  --> $DIR/recover-range-pats.rs:44:13
212   |
213LL |     if let 0...Y = 0 {}
214   |             ^^^ help: use `..=` for an inclusive range
215   |
216   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
217   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
218
219error: `...` range patterns are deprecated
220  --> $DIR/recover-range-pats.rs:47:13
221   |
222LL |     if let X...3 = 0 {}
223   |             ^^^ help: use `..=` for an inclusive range
224   |
225   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
226   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
227
228error: `...` range patterns are deprecated
229  --> $DIR/recover-range-pats.rs:50:13
230   |
231LL |     if let X...Y = 0 {}
232   |             ^^^ help: use `..=` for an inclusive range
233   |
234   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
235   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
236
237error: `...` range patterns are deprecated
238  --> $DIR/recover-range-pats.rs:53:16
239   |
240LL |     if let true...Y = 0 {}
241   |                ^^^ help: use `..=` for an inclusive range
242   |
243   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
244   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
245
246error: `...` range patterns are deprecated
247  --> $DIR/recover-range-pats.rs:56:13
248   |
249LL |     if let X...true = 0 {}
250   |             ^^^ help: use `..=` for an inclusive range
251   |
252   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
253   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
254
255error: `...` range patterns are deprecated
256  --> $DIR/recover-range-pats.rs:59:14
257   |
258LL |     if let .0...Y = 0 {}
259   |              ^^^ help: use `..=` for an inclusive range
260   |
261   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
262   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
263
264error: `...` range patterns are deprecated
265  --> $DIR/recover-range-pats.rs:63:13
266   |
267LL |     if let X... .0 = 0 {}
268   |             ^^^ help: use `..=` for an inclusive range
269   |
270   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
271   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
272
273error: `...` range patterns are deprecated
274  --> $DIR/recover-range-pats.rs:137:20
275   |
276LL |             let $e1...$e2;
277   |                    ^^^ help: use `..=` for an inclusive range
278...
279LL |     mac2!(0, 1);
280   |     ----------- in this macro invocation
281   |
282   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
283   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
284   = note: this error originates in the macro `mac2` (in Nightly builds, run with -Z macro-backtrace for more info)
285
286error[E0029]: only `char` and numeric types are allowed in range patterns
287  --> $DIR/recover-range-pats.rs:19:12
288   |
289LL |     if let true..Y = 0 {}
290   |            ^^^^  - this is of type `u8`
291   |            |
292   |            this is of type `bool` but it should be `char` or numeric
293
294error[E0029]: only `char` and numeric types are allowed in range patterns
295  --> $DIR/recover-range-pats.rs:20:15
296   |
297LL |     if let X..true = 0 {}
298   |            -  ^^^^ this is of type `bool` but it should be `char` or numeric
299   |            |
300   |            this is of type `u8`
301
302error[E0308]: mismatched types
303  --> $DIR/recover-range-pats.rs:21:12
304   |
305LL |     if let .0..Y = 0 {}
306   |            ^^  -   - this expression has type `{integer}`
307   |            |   |
308   |            |   this is of type `u8`
309   |            expected integer, found floating-point number
310
311error[E0308]: mismatched types
312  --> $DIR/recover-range-pats.rs:23:16
313   |
314LL |     if let X.. .0 = 0 {}
315   |            -   ^^   - this expression has type `u8`
316   |            |   |
317   |            |   expected `u8`, found floating-point number
318   |            this is of type `u8`
319   |
320   = note: expected type `u8`
321              found type `{float}`
322
323error[E0029]: only `char` and numeric types are allowed in range patterns
324  --> $DIR/recover-range-pats.rs:32:12
325   |
326LL |     if let true..=Y = 0 {}
327   |            ^^^^   - this is of type `u8`
328   |            |
329   |            this is of type `bool` but it should be `char` or numeric
330
331error[E0029]: only `char` and numeric types are allowed in range patterns
332  --> $DIR/recover-range-pats.rs:33:16
333   |
334LL |     if let X..=true = 0 {}
335   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
336   |            |
337   |            this is of type `u8`
338
339error[E0308]: mismatched types
340  --> $DIR/recover-range-pats.rs:34:12
341   |
342LL |     if let .0..=Y = 0 {}
343   |            ^^   -   - this expression has type `{integer}`
344   |            |    |
345   |            |    this is of type `u8`
346   |            expected integer, found floating-point number
347
348error[E0308]: mismatched types
349  --> $DIR/recover-range-pats.rs:36:16
350   |
351LL |     if let X..=.0 = 0 {}
352   |            -   ^^   - this expression has type `u8`
353   |            |   |
354   |            |   expected `u8`, found floating-point number
355   |            this is of type `u8`
356   |
357   = note: expected type `u8`
358              found type `{float}`
359
360error[E0029]: only `char` and numeric types are allowed in range patterns
361  --> $DIR/recover-range-pats.rs:53:12
362   |
363LL |     if let true...Y = 0 {}
364   |            ^^^^   - this is of type `u8`
365   |            |
366   |            this is of type `bool` but it should be `char` or numeric
367
368error[E0029]: only `char` and numeric types are allowed in range patterns
369  --> $DIR/recover-range-pats.rs:56:16
370   |
371LL |     if let X...true = 0 {}
372   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
373   |            |
374   |            this is of type `u8`
375
376error[E0308]: mismatched types
377  --> $DIR/recover-range-pats.rs:59:12
378   |
379LL |     if let .0...Y = 0 {}
380   |            ^^   -   - this expression has type `{integer}`
381   |            |    |
382   |            |    this is of type `u8`
383   |            expected integer, found floating-point number
384
385error[E0308]: mismatched types
386  --> $DIR/recover-range-pats.rs:63:17
387   |
388LL |     if let X... .0 = 0 {}
389   |            -    ^^   - this expression has type `u8`
390   |            |    |
391   |            |    expected `u8`, found floating-point number
392   |            this is of type `u8`
393   |
394   = note: expected type `u8`
395              found type `{float}`
396
397error[E0029]: only `char` and numeric types are allowed in range patterns
398  --> $DIR/recover-range-pats.rs:72:12
399   |
400LL |     if let true.. = 0 {}
401   |            ^^^^ this is of type `bool` but it should be `char` or numeric
402
403error[E0308]: mismatched types
404  --> $DIR/recover-range-pats.rs:74:12
405   |
406LL |     if let .0.. = 0 {}
407   |            ^^     - this expression has type `{integer}`
408   |            |
409   |            expected integer, found floating-point number
410
411error[E0029]: only `char` and numeric types are allowed in range patterns
412  --> $DIR/recover-range-pats.rs:82:12
413   |
414LL |     if let true..= = 0 {}
415   |            ^^^^ this is of type `bool` but it should be `char` or numeric
416
417error[E0308]: mismatched types
418  --> $DIR/recover-range-pats.rs:84:12
419   |
420LL |     if let .0..= = 0 {}
421   |            ^^      - this expression has type `{integer}`
422   |            |
423   |            expected integer, found floating-point number
424
425error[E0029]: only `char` and numeric types are allowed in range patterns
426  --> $DIR/recover-range-pats.rs:92:12
427   |
428LL |     if let true... = 0 {}
429   |            ^^^^ this is of type `bool` but it should be `char` or numeric
430
431error[E0308]: mismatched types
432  --> $DIR/recover-range-pats.rs:94:12
433   |
434LL |     if let .0... = 0 {}
435   |            ^^      - this expression has type `{integer}`
436   |            |
437   |            expected integer, found floating-point number
438
439error[E0029]: only `char` and numeric types are allowed in range patterns
440  --> $DIR/recover-range-pats.rs:102:14
441   |
442LL |     if let ..true = 0 {}
443   |              ^^^^ this is of type `bool` but it should be `char` or numeric
444
445error[E0308]: mismatched types
446  --> $DIR/recover-range-pats.rs:104:15
447   |
448LL |     if let .. .0 = 0 {}
449   |               ^^   - this expression has type `{integer}`
450   |               |
451   |               expected integer, found floating-point number
452
453error[E0029]: only `char` and numeric types are allowed in range patterns
454  --> $DIR/recover-range-pats.rs:112:15
455   |
456LL |     if let ..=true = 0 {}
457   |               ^^^^ this is of type `bool` but it should be `char` or numeric
458
459error[E0308]: mismatched types
460  --> $DIR/recover-range-pats.rs:114:15
461   |
462LL |     if let ..=.0 = 0 {}
463   |               ^^   - this expression has type `{integer}`
464   |               |
465   |               expected integer, found floating-point number
466
467error[E0029]: only `char` and numeric types are allowed in range patterns
468  --> $DIR/recover-range-pats.rs:124:15
469   |
470LL |     if let ...true = 0 {}
471   |               ^^^^ this is of type `bool` but it should be `char` or numeric
472
473error[E0308]: mismatched types
474  --> $DIR/recover-range-pats.rs:127:15
475   |
476LL |     if let ....3 = 0 {}
477   |               ^^   - this expression has type `{integer}`
478   |               |
479   |               expected integer, found floating-point number
480
481error: aborting due to 60 previous errors
482
483Some errors have detailed explanations: E0029, E0308, E0586.
484For more information about an error, try `rustc --explain E0029`.