fork/rust

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

borsAuto merge of #68568 - pietroalbini:stable-next, r=pietroalbini5e1a799842b

1.41.0
17.3 KiB559 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:49: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:52:17
33   |
34LL |     if let X... .0 = 0 {}
35   |                 ^^ help: must have an integer part: `0.0`
36
37error: `X..` range patterns are not supported
38  --> $DIR/recover-range-pats.rs:58:12
39   |
40LL |     if let 0.. = 0 {}
41   |            ^^^ help: try using the maximum value for the type: `0..MAX`
42
43error: `X..` range patterns are not supported
44  --> $DIR/recover-range-pats.rs:59:12
45   |
46LL |     if let X.. = 0 {}
47   |            ^^^ help: try using the maximum value for the type: `X..MAX`
48
49error: `X..` range patterns are not supported
50  --> $DIR/recover-range-pats.rs:60:12
51   |
52LL |     if let true.. = 0 {}
53   |            ^^^^^^ help: try using the maximum value for the type: `true..MAX`
54
55error: float literals must have an integer part
56  --> $DIR/recover-range-pats.rs:62:12
57   |
58LL |     if let .0.. = 0 {}
59   |            ^^ help: must have an integer part: `0.0`
60
61error: `X..` range patterns are not supported
62  --> $DIR/recover-range-pats.rs:62:12
63   |
64LL |     if let .0.. = 0 {}
65   |            ^^^^ help: try using the maximum value for the type: `0.0..MAX`
66
67error: `X..=` range patterns are not supported
68  --> $DIR/recover-range-pats.rs:68:12
69   |
70LL |     if let 0..= = 0 {}
71   |            ^^^^ help: try using the maximum value for the type: `0..=MAX`
72
73error: `X..=` range patterns are not supported
74  --> $DIR/recover-range-pats.rs:69:12
75   |
76LL |     if let X..= = 0 {}
77   |            ^^^^ help: try using the maximum value for the type: `X..=MAX`
78
79error: `X..=` range patterns are not supported
80  --> $DIR/recover-range-pats.rs:70:12
81   |
82LL |     if let true..= = 0 {}
83   |            ^^^^^^^ help: try using the maximum value for the type: `true..=MAX`
84
85error: float literals must have an integer part
86  --> $DIR/recover-range-pats.rs:72:12
87   |
88LL |     if let .0..= = 0 {}
89   |            ^^ help: must have an integer part: `0.0`
90
91error: `X..=` range patterns are not supported
92  --> $DIR/recover-range-pats.rs:72:12
93   |
94LL |     if let .0..= = 0 {}
95   |            ^^^^^ help: try using the maximum value for the type: `0.0..=MAX`
96
97error: `X...` range patterns are not supported
98  --> $DIR/recover-range-pats.rs:78:12
99   |
100LL |     if let 0... = 0 {}
101   |            ^^^^ help: try using the maximum value for the type: `0...MAX`
102
103error: `X...` range patterns are not supported
104  --> $DIR/recover-range-pats.rs:80:12
105   |
106LL |     if let X... = 0 {}
107   |            ^^^^ help: try using the maximum value for the type: `X...MAX`
108
109error: `X...` range patterns are not supported
110  --> $DIR/recover-range-pats.rs:82:12
111   |
112LL |     if let true... = 0 {}
113   |            ^^^^^^^ help: try using the maximum value for the type: `true...MAX`
114
115error: float literals must have an integer part
116  --> $DIR/recover-range-pats.rs:85:12
117   |
118LL |     if let .0... = 0 {}
119   |            ^^ help: must have an integer part: `0.0`
120
121error: `X...` range patterns are not supported
122  --> $DIR/recover-range-pats.rs:85:12
123   |
124LL |     if let .0... = 0 {}
125   |            ^^^^^ help: try using the maximum value for the type: `0.0...MAX`
126
127error: `..X` range patterns are not supported
128  --> $DIR/recover-range-pats.rs:92:12
129   |
130LL |     if let ..0 = 0 {}
131   |            ^^^ help: try using the minimum value for the type: `MIN..0`
132
133error: `..X` range patterns are not supported
134  --> $DIR/recover-range-pats.rs:93:12
135   |
136LL |     if let ..Y = 0 {}
137   |            ^^^ help: try using the minimum value for the type: `MIN..Y`
138
139error: `..X` range patterns are not supported
140  --> $DIR/recover-range-pats.rs:94:12
141   |
142LL |     if let ..true = 0 {}
143   |            ^^^^^^ help: try using the minimum value for the type: `MIN..true`
144
145error: float literals must have an integer part
146  --> $DIR/recover-range-pats.rs:96:15
147   |
148LL |     if let .. .0 = 0 {}
149   |               ^^ help: must have an integer part: `0.0`
150
151error: `..X` range patterns are not supported
152  --> $DIR/recover-range-pats.rs:96:12
153   |
154LL |     if let .. .0 = 0 {}
155   |            ^^^^^ help: try using the minimum value for the type: `MIN..0.0`
156
157error: `..=X` range patterns are not supported
158  --> $DIR/recover-range-pats.rs:102:12
159   |
160LL |     if let ..=3 = 0 {}
161   |            ^^^^ help: try using the minimum value for the type: `MIN..=3`
162
163error: `..=X` range patterns are not supported
164  --> $DIR/recover-range-pats.rs:103:12
165   |
166LL |     if let ..=Y = 0 {}
167   |            ^^^^ help: try using the minimum value for the type: `MIN..=Y`
168
169error: `..=X` range patterns are not supported
170  --> $DIR/recover-range-pats.rs:104:12
171   |
172LL |     if let ..=true = 0 {}
173   |            ^^^^^^^ help: try using the minimum value for the type: `MIN..=true`
174
175error: float literals must have an integer part
176  --> $DIR/recover-range-pats.rs:106:15
177   |
178LL |     if let ..=.0 = 0 {}
179   |               ^^ help: must have an integer part: `0.0`
180
181error: `..=X` range patterns are not supported
182  --> $DIR/recover-range-pats.rs:106:12
183   |
184LL |     if let ..=.0 = 0 {}
185   |            ^^^^^ help: try using the minimum value for the type: `MIN..=0.0`
186
187error: `...X` range patterns are not supported
188  --> $DIR/recover-range-pats.rs:112:12
189   |
190LL |     if let ...3 = 0 {}
191   |            ^^^^ help: try using the minimum value for the type: `MIN...3`
192
193error: `...X` range patterns are not supported
194  --> $DIR/recover-range-pats.rs:114:12
195   |
196LL |     if let ...Y = 0 {}
197   |            ^^^^ help: try using the minimum value for the type: `MIN...Y`
198
199error: `...X` range patterns are not supported
200  --> $DIR/recover-range-pats.rs:116:12
201   |
202LL |     if let ...true = 0 {}
203   |            ^^^^^^^ help: try using the minimum value for the type: `MIN...true`
204
205error: float literals must have an integer part
206  --> $DIR/recover-range-pats.rs:119:15
207   |
208LL |     if let ....3 = 0 {}
209   |               ^^ help: must have an integer part: `0.3`
210
211error: `...X` range patterns are not supported
212  --> $DIR/recover-range-pats.rs:119:12
213   |
214LL |     if let ....3 = 0 {}
215   |            ^^^^^ help: try using the minimum value for the type: `MIN...0.3`
216
217error: `..X` range patterns are not supported
218  --> $DIR/recover-range-pats.rs:139:17
219   |
220LL |             let ..$e;
221   |                 ^^ help: try using the minimum value for the type: `MIN..0`
222...
223LL |     mac!(0);
224   |     -------- in this macro invocation
225
226error: `...X` range patterns are not supported
227  --> $DIR/recover-range-pats.rs:140:17
228   |
229LL |             let ...$e;
230   |                 ^^^ help: try using the minimum value for the type: `MIN...0`
231...
232LL |     mac!(0);
233   |     -------- in this macro invocation
234
235error: `..=X` range patterns are not supported
236  --> $DIR/recover-range-pats.rs:142:17
237   |
238LL |             let ..=$e;
239   |                 ^^^ help: try using the minimum value for the type: `MIN..=0`
240...
241LL |     mac!(0);
242   |     -------- in this macro invocation
243
244error: `X..` range patterns are not supported
245  --> $DIR/recover-range-pats.rs:143:19
246   |
247LL |             let $e..;
248   |                   ^^ help: try using the maximum value for the type: `0..MAX`
249...
250LL |     mac!(0);
251   |     -------- in this macro invocation
252
253error: `X...` range patterns are not supported
254  --> $DIR/recover-range-pats.rs:144:19
255   |
256LL |             let $e...;
257   |                   ^^^ help: try using the maximum value for the type: `0...MAX`
258...
259LL |     mac!(0);
260   |     -------- in this macro invocation
261
262error: `X..=` range patterns are not supported
263  --> $DIR/recover-range-pats.rs:146:19
264   |
265LL |             let $e..=;
266   |                   ^^^ help: try using the maximum value for the type: `0..=MAX`
267...
268LL |     mac!(0);
269   |     -------- in this macro invocation
270
271error: `...` range patterns are deprecated
272  --> $DIR/recover-range-pats.rs:41:13
273   |
274LL |     if let 0...3 = 0 {}
275   |             ^^^ help: use `..=` for an inclusive range
276   |
277note: lint level defined here
278  --> $DIR/recover-range-pats.rs:7:9
279   |
280LL | #![deny(ellipsis_inclusive_range_patterns)]
281   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
282
283error: `...` range patterns are deprecated
284  --> $DIR/recover-range-pats.rs:42:13
285   |
286LL |     if let 0...Y = 0 {}
287   |             ^^^ help: use `..=` for an inclusive range
288
289error: `...` range patterns are deprecated
290  --> $DIR/recover-range-pats.rs:43:13
291   |
292LL |     if let X...3 = 0 {}
293   |             ^^^ help: use `..=` for an inclusive range
294
295error: `...` range patterns are deprecated
296  --> $DIR/recover-range-pats.rs:44:13
297   |
298LL |     if let X...Y = 0 {}
299   |             ^^^ help: use `..=` for an inclusive range
300
301error: `...` range patterns are deprecated
302  --> $DIR/recover-range-pats.rs:45:16
303   |
304LL |     if let true...Y = 0 {}
305   |                ^^^ help: use `..=` for an inclusive range
306
307error: `...` range patterns are deprecated
308  --> $DIR/recover-range-pats.rs:47:13
309   |
310LL |     if let X...true = 0 {}
311   |             ^^^ help: use `..=` for an inclusive range
312
313error: `...` range patterns are deprecated
314  --> $DIR/recover-range-pats.rs:49:14
315   |
316LL |     if let .0...Y = 0 {}
317   |              ^^^ help: use `..=` for an inclusive range
318
319error: `...` range patterns are deprecated
320  --> $DIR/recover-range-pats.rs:52:13
321   |
322LL |     if let X... .0 = 0 {}
323   |             ^^^ help: use `..=` for an inclusive range
324
325error: `...` range patterns are deprecated
326  --> $DIR/recover-range-pats.rs:78:13
327   |
328LL |     if let 0... = 0 {}
329   |             ^^^ help: use `..=` for an inclusive range
330
331error: `...` range patterns are deprecated
332  --> $DIR/recover-range-pats.rs:80:13
333   |
334LL |     if let X... = 0 {}
335   |             ^^^ help: use `..=` for an inclusive range
336
337error: `...` range patterns are deprecated
338  --> $DIR/recover-range-pats.rs:82:16
339   |
340LL |     if let true... = 0 {}
341   |                ^^^ help: use `..=` for an inclusive range
342
343error: `...` range patterns are deprecated
344  --> $DIR/recover-range-pats.rs:85:14
345   |
346LL |     if let .0... = 0 {}
347   |              ^^^ help: use `..=` for an inclusive range
348
349error: `...` range patterns are deprecated
350  --> $DIR/recover-range-pats.rs:112:12
351   |
352LL |     if let ...3 = 0 {}
353   |            ^^^ help: use `..=` for an inclusive range
354
355error: `...` range patterns are deprecated
356  --> $DIR/recover-range-pats.rs:114:12
357   |
358LL |     if let ...Y = 0 {}
359   |            ^^^ help: use `..=` for an inclusive range
360
361error: `...` range patterns are deprecated
362  --> $DIR/recover-range-pats.rs:116:12
363   |
364LL |     if let ...true = 0 {}
365   |            ^^^ help: use `..=` for an inclusive range
366
367error: `...` range patterns are deprecated
368  --> $DIR/recover-range-pats.rs:119:12
369   |
370LL |     if let ....3 = 0 {}
371   |            ^^^ help: use `..=` for an inclusive range
372
373error: `...` range patterns are deprecated
374  --> $DIR/recover-range-pats.rs:129:20
375   |
376LL |             let $e1...$e2;
377   |                    ^^^ help: use `..=` for an inclusive range
378...
379LL |     mac2!(0, 1);
380   |     ------------ in this macro invocation
381
382error: `...` range patterns are deprecated
383  --> $DIR/recover-range-pats.rs:140:17
384   |
385LL |             let ...$e;
386   |                 ^^^ help: use `..=` for an inclusive range
387...
388LL |     mac!(0);
389   |     -------- in this macro invocation
390
391error: `...` range patterns are deprecated
392  --> $DIR/recover-range-pats.rs:144:19
393   |
394LL |             let $e...;
395   |                   ^^^ help: use `..=` for an inclusive range
396...
397LL |     mac!(0);
398   |     -------- in this macro invocation
399
400error[E0029]: only char and numeric types are allowed in range patterns
401  --> $DIR/recover-range-pats.rs:19:12
402   |
403LL |     if let true..Y = 0 {}
404   |            ^^^^  - this is of type `u8`
405   |            |
406   |            this is of type `bool` but it should be `char` or numeric
407
408error[E0029]: only char and numeric types are allowed in range patterns
409  --> $DIR/recover-range-pats.rs:20:15
410   |
411LL |     if let X..true = 0 {}
412   |            -  ^^^^ this is of type `bool` but it should be `char` or numeric
413   |            |
414   |            this is of type `u8`
415
416error[E0308]: mismatched types
417  --> $DIR/recover-range-pats.rs:21:12
418   |
419LL |     if let .0..Y = 0 {}
420   |            ^^^^^ expected integer, found floating-point number
421
422error[E0308]: mismatched types
423  --> $DIR/recover-range-pats.rs:23:12
424   |
425LL |     if let X.. .0 = 0 {}
426   |            ^^^^^^ expected integer, found floating-point number
427
428error[E0029]: only char and numeric types are allowed in range patterns
429  --> $DIR/recover-range-pats.rs:32:12
430   |
431LL |     if let true..=Y = 0 {}
432   |            ^^^^   - this is of type `u8`
433   |            |
434   |            this is of type `bool` but it should be `char` or numeric
435
436error[E0029]: only char and numeric types are allowed in range patterns
437  --> $DIR/recover-range-pats.rs:33:16
438   |
439LL |     if let X..=true = 0 {}
440   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
441   |            |
442   |            this is of type `u8`
443
444error[E0308]: mismatched types
445  --> $DIR/recover-range-pats.rs:34:12
446   |
447LL |     if let .0..=Y = 0 {}
448   |            ^^^^^^ expected integer, found floating-point number
449
450error[E0308]: mismatched types
451  --> $DIR/recover-range-pats.rs:36:12
452   |
453LL |     if let X..=.0 = 0 {}
454   |            ^^^^^^ expected integer, found floating-point number
455
456error[E0029]: only char and numeric types are allowed in range patterns
457  --> $DIR/recover-range-pats.rs:45:12
458   |
459LL |     if let true...Y = 0 {}
460   |            ^^^^   - this is of type `u8`
461   |            |
462   |            this is of type `bool` but it should be `char` or numeric
463
464error[E0029]: only char and numeric types are allowed in range patterns
465  --> $DIR/recover-range-pats.rs:47:16
466   |
467LL |     if let X...true = 0 {}
468   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
469   |            |
470   |            this is of type `u8`
471
472error[E0308]: mismatched types
473  --> $DIR/recover-range-pats.rs:49:12
474   |
475LL |     if let .0...Y = 0 {}
476   |            ^^^^^^ expected integer, found floating-point number
477
478error[E0308]: mismatched types
479  --> $DIR/recover-range-pats.rs:52:12
480   |
481LL |     if let X... .0 = 0 {}
482   |            ^^^^^^^ expected integer, found floating-point number
483
484error[E0029]: only char and numeric types are allowed in range patterns
485  --> $DIR/recover-range-pats.rs:60:12
486   |
487LL |     if let true.. = 0 {}
488   |            ^^^^ this is of type `bool` but it should be `char` or numeric
489
490error[E0308]: mismatched types
491  --> $DIR/recover-range-pats.rs:62:12
492   |
493LL |     if let .0.. = 0 {}
494   |            ^^^^ expected integer, found floating-point number
495
496error[E0029]: only char and numeric types are allowed in range patterns
497  --> $DIR/recover-range-pats.rs:70:12
498   |
499LL |     if let true..= = 0 {}
500   |            ^^^^ this is of type `bool` but it should be `char` or numeric
501
502error[E0308]: mismatched types
503  --> $DIR/recover-range-pats.rs:72:12
504   |
505LL |     if let .0..= = 0 {}
506   |            ^^^^^ expected integer, found floating-point number
507
508error[E0029]: only char and numeric types are allowed in range patterns
509  --> $DIR/recover-range-pats.rs:82:12
510   |
511LL |     if let true... = 0 {}
512   |            ^^^^ this is of type `bool` but it should be `char` or numeric
513
514error[E0308]: mismatched types
515  --> $DIR/recover-range-pats.rs:85:12
516   |
517LL |     if let .0... = 0 {}
518   |            ^^^^^ expected integer, found floating-point number
519
520error[E0029]: only char and numeric types are allowed in range patterns
521  --> $DIR/recover-range-pats.rs:94:14
522   |
523LL |     if let ..true = 0 {}
524   |              ^^^^ this is of type `bool` but it should be `char` or numeric
525
526error[E0308]: mismatched types
527  --> $DIR/recover-range-pats.rs:96:12
528   |
529LL |     if let .. .0 = 0 {}
530   |            ^^^^^ expected integer, found floating-point number
531
532error[E0029]: only char and numeric types are allowed in range patterns
533  --> $DIR/recover-range-pats.rs:104:15
534   |
535LL |     if let ..=true = 0 {}
536   |               ^^^^ this is of type `bool` but it should be `char` or numeric
537
538error[E0308]: mismatched types
539  --> $DIR/recover-range-pats.rs:106:12
540   |
541LL |     if let ..=.0 = 0 {}
542   |            ^^^^^ expected integer, found floating-point number
543
544error[E0029]: only char and numeric types are allowed in range patterns
545  --> $DIR/recover-range-pats.rs:116:15
546   |
547LL |     if let ...true = 0 {}
548   |               ^^^^ this is of type `bool` but it should be `char` or numeric
549
550error[E0308]: mismatched types
551  --> $DIR/recover-range-pats.rs:119:12
552   |
553LL |     if let ....3 = 0 {}
554   |            ^^^^^ expected integer, found floating-point number
555
556error: aborting due to 85 previous errors
557
558Some errors have detailed explanations: E0029, E0308.
559For more information about an error, try `rustc --explain E0029`.