fork/rust

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

borsAuto merge of #67350 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum73528e339aa

1.40.0
18.4 KiB619 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   |            ^^^^ ranges require char or numeric types
405   |
406   = note: start type: bool
407   = note: end type: u8
408
409error[E0029]: only char and numeric types are allowed in range patterns
410  --> $DIR/recover-range-pats.rs:20:15
411   |
412LL |     if let X..true = 0 {}
413   |               ^^^^ ranges require char or numeric types
414   |
415   = note: start type: u8
416   = note: end type: bool
417
418error[E0308]: mismatched types
419  --> $DIR/recover-range-pats.rs:21:12
420   |
421LL |     if let .0..Y = 0 {}
422   |            ^^^^^ expected integer, found floating-point number
423   |
424   = note: expected type `{integer}`
425              found type `{float}`
426
427error[E0308]: mismatched types
428  --> $DIR/recover-range-pats.rs:23:12
429   |
430LL |     if let X.. .0 = 0 {}
431   |            ^^^^^^ expected integer, found floating-point number
432   |
433   = note: expected type `u8`
434              found type `{float}`
435
436error[E0029]: only char and numeric types are allowed in range patterns
437  --> $DIR/recover-range-pats.rs:32:12
438   |
439LL |     if let true..=Y = 0 {}
440   |            ^^^^ ranges require char or numeric types
441   |
442   = note: start type: bool
443   = note: end type: u8
444
445error[E0029]: only char and numeric types are allowed in range patterns
446  --> $DIR/recover-range-pats.rs:33:16
447   |
448LL |     if let X..=true = 0 {}
449   |                ^^^^ ranges require char or numeric types
450   |
451   = note: start type: u8
452   = note: end type: bool
453
454error[E0308]: mismatched types
455  --> $DIR/recover-range-pats.rs:34:12
456   |
457LL |     if let .0..=Y = 0 {}
458   |            ^^^^^^ expected integer, found floating-point number
459   |
460   = note: expected type `{integer}`
461              found type `{float}`
462
463error[E0308]: mismatched types
464  --> $DIR/recover-range-pats.rs:36:12
465   |
466LL |     if let X..=.0 = 0 {}
467   |            ^^^^^^ expected integer, found floating-point number
468   |
469   = note: expected type `u8`
470              found type `{float}`
471
472error[E0029]: only char and numeric types are allowed in range patterns
473  --> $DIR/recover-range-pats.rs:45:12
474   |
475LL |     if let true...Y = 0 {}
476   |            ^^^^ ranges require char or numeric types
477   |
478   = note: start type: bool
479   = note: end type: u8
480
481error[E0029]: only char and numeric types are allowed in range patterns
482  --> $DIR/recover-range-pats.rs:47:16
483   |
484LL |     if let X...true = 0 {}
485   |                ^^^^ ranges require char or numeric types
486   |
487   = note: start type: u8
488   = note: end type: bool
489
490error[E0308]: mismatched types
491  --> $DIR/recover-range-pats.rs:49:12
492   |
493LL |     if let .0...Y = 0 {}
494   |            ^^^^^^ expected integer, found floating-point number
495   |
496   = note: expected type `{integer}`
497              found type `{float}`
498
499error[E0308]: mismatched types
500  --> $DIR/recover-range-pats.rs:52:12
501   |
502LL |     if let X... .0 = 0 {}
503   |            ^^^^^^^ expected integer, found floating-point number
504   |
505   = note: expected type `u8`
506              found type `{float}`
507
508error[E0029]: only char and numeric types are allowed in range patterns
509  --> $DIR/recover-range-pats.rs:60:12
510   |
511LL |     if let true.. = 0 {}
512   |            ^^^^ ranges require char or numeric types
513   |
514   = note: start type: bool
515   = note: end type: [type error]
516
517error[E0308]: mismatched types
518  --> $DIR/recover-range-pats.rs:62:12
519   |
520LL |     if let .0.. = 0 {}
521   |            ^^^^ expected integer, found floating-point number
522   |
523   = note: expected type `{integer}`
524              found type `{float}`
525
526error[E0029]: only char and numeric types are allowed in range patterns
527  --> $DIR/recover-range-pats.rs:70:12
528   |
529LL |     if let true..= = 0 {}
530   |            ^^^^ ranges require char or numeric types
531   |
532   = note: start type: bool
533   = note: end type: [type error]
534
535error[E0308]: mismatched types
536  --> $DIR/recover-range-pats.rs:72:12
537   |
538LL |     if let .0..= = 0 {}
539   |            ^^^^^ expected integer, found floating-point number
540   |
541   = note: expected type `{integer}`
542              found type `{float}`
543
544error[E0029]: only char and numeric types are allowed in range patterns
545  --> $DIR/recover-range-pats.rs:82:12
546   |
547LL |     if let true... = 0 {}
548   |            ^^^^ ranges require char or numeric types
549   |
550   = note: start type: bool
551   = note: end type: [type error]
552
553error[E0308]: mismatched types
554  --> $DIR/recover-range-pats.rs:85:12
555   |
556LL |     if let .0... = 0 {}
557   |            ^^^^^ expected integer, found floating-point number
558   |
559   = note: expected type `{integer}`
560              found type `{float}`
561
562error[E0029]: only char and numeric types are allowed in range patterns
563  --> $DIR/recover-range-pats.rs:94:14
564   |
565LL |     if let ..true = 0 {}
566   |              ^^^^ ranges require char or numeric types
567   |
568   = note: start type: [type error]
569   = note: end type: bool
570
571error[E0308]: mismatched types
572  --> $DIR/recover-range-pats.rs:96:12
573   |
574LL |     if let .. .0 = 0 {}
575   |            ^^^^^ expected integer, found floating-point number
576   |
577   = note: expected type `{integer}`
578              found type `{float}`
579
580error[E0029]: only char and numeric types are allowed in range patterns
581  --> $DIR/recover-range-pats.rs:104:15
582   |
583LL |     if let ..=true = 0 {}
584   |               ^^^^ ranges require char or numeric types
585   |
586   = note: start type: [type error]
587   = note: end type: bool
588
589error[E0308]: mismatched types
590  --> $DIR/recover-range-pats.rs:106:12
591   |
592LL |     if let ..=.0 = 0 {}
593   |            ^^^^^ expected integer, found floating-point number
594   |
595   = note: expected type `{integer}`
596              found type `{float}`
597
598error[E0029]: only char and numeric types are allowed in range patterns
599  --> $DIR/recover-range-pats.rs:116:15
600   |
601LL |     if let ...true = 0 {}
602   |               ^^^^ ranges require char or numeric types
603   |
604   = note: start type: [type error]
605   = note: end type: bool
606
607error[E0308]: mismatched types
608  --> $DIR/recover-range-pats.rs:119:12
609   |
610LL |     if let ....3 = 0 {}
611   |            ^^^^^ expected integer, found floating-point number
612   |
613   = note: expected type `{integer}`
614              found type `{float}`
615
616error: aborting due to 85 previous errors
617
618Some errors have detailed explanations: E0029, E0308.
619For more information about an error, try `rustc --explain E0029`.