fork/rust

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

borsAuto merge of #71868 - Mark-Simulacrum:stable-1.43.1, r=pietroalbini8d69840ab92

1.43.1
13.5 KiB435 linesraw
1error: float literals must have an integer part
2  --> $DIR/recover-range-pats.rs:22: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:24: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:35: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:37: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:50: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:53: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:63: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:69: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:70: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:71: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:73: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:73: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:79: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:80: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:81: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:83: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:83: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:93: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:103: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:109: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:111: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:113: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:116: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:116: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:137: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 a macro (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:141: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 a macro (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:142: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 a macro (in Nightly builds, run with -Z macro-backtrace for more info)
195
196error: `...` range patterns are deprecated
197  --> $DIR/recover-range-pats.rs:42:13
198   |
199LL |     if let 0...3 = 0 {}
200   |             ^^^ help: use `..=` for an inclusive range
201   |
202note: the lint level is defined here
203  --> $DIR/recover-range-pats.rs:8:9
204   |
205LL | #![deny(ellipsis_inclusive_range_patterns)]
206   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
207
208error: `...` range patterns are deprecated
209  --> $DIR/recover-range-pats.rs:43:13
210   |
211LL |     if let 0...Y = 0 {}
212   |             ^^^ help: use `..=` for an inclusive range
213
214error: `...` range patterns are deprecated
215  --> $DIR/recover-range-pats.rs:44:13
216   |
217LL |     if let X...3 = 0 {}
218   |             ^^^ help: use `..=` for an inclusive range
219
220error: `...` range patterns are deprecated
221  --> $DIR/recover-range-pats.rs:45:13
222   |
223LL |     if let X...Y = 0 {}
224   |             ^^^ help: use `..=` for an inclusive range
225
226error: `...` range patterns are deprecated
227  --> $DIR/recover-range-pats.rs:46:16
228   |
229LL |     if let true...Y = 0 {}
230   |                ^^^ help: use `..=` for an inclusive range
231
232error: `...` range patterns are deprecated
233  --> $DIR/recover-range-pats.rs:48:13
234   |
235LL |     if let X...true = 0 {}
236   |             ^^^ help: use `..=` for an inclusive range
237
238error: `...` range patterns are deprecated
239  --> $DIR/recover-range-pats.rs:50:14
240   |
241LL |     if let .0...Y = 0 {}
242   |              ^^^ help: use `..=` for an inclusive range
243
244error: `...` range patterns are deprecated
245  --> $DIR/recover-range-pats.rs:53:13
246   |
247LL |     if let X... .0 = 0 {}
248   |             ^^^ help: use `..=` for an inclusive range
249
250error: `...` range patterns are deprecated
251  --> $DIR/recover-range-pats.rs:126:20
252   |
253LL |             let $e1...$e2;
254   |                    ^^^ help: use `..=` for an inclusive range
255...
256LL |     mac2!(0, 1);
257   |     ------------ in this macro invocation
258   |
259   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
260
261error[E0029]: only char and numeric types are allowed in range patterns
262  --> $DIR/recover-range-pats.rs:20:12
263   |
264LL |     if let true..Y = 0 {}
265   |            ^^^^  - this is of type `u8`
266   |            |
267   |            this is of type `bool` but it should be `char` or numeric
268
269error[E0029]: only char and numeric types are allowed in range patterns
270  --> $DIR/recover-range-pats.rs:21:15
271   |
272LL |     if let X..true = 0 {}
273   |            -  ^^^^ this is of type `bool` but it should be `char` or numeric
274   |            |
275   |            this is of type `u8`
276
277error[E0308]: mismatched types
278  --> $DIR/recover-range-pats.rs:22:12
279   |
280LL |     if let .0..Y = 0 {}
281   |            ^^  - this is of type `u8`
282   |            |
283   |            expected integer, found floating-point number
284
285error[E0308]: mismatched types
286  --> $DIR/recover-range-pats.rs:24:16
287   |
288LL |     if let X.. .0 = 0 {}
289   |            -   ^^   - this expression has type `u8`
290   |            |   |
291   |            |   expected integer, found floating-point number
292   |            this is of type `u8`
293
294error[E0029]: only char and numeric types are allowed in range patterns
295  --> $DIR/recover-range-pats.rs:33:12
296   |
297LL |     if let true..=Y = 0 {}
298   |            ^^^^   - this is of type `u8`
299   |            |
300   |            this is of type `bool` but it should be `char` or numeric
301
302error[E0029]: only char and numeric types are allowed in range patterns
303  --> $DIR/recover-range-pats.rs:34:16
304   |
305LL |     if let X..=true = 0 {}
306   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
307   |            |
308   |            this is of type `u8`
309
310error[E0308]: mismatched types
311  --> $DIR/recover-range-pats.rs:35:12
312   |
313LL |     if let .0..=Y = 0 {}
314   |            ^^   - this is of type `u8`
315   |            |
316   |            expected integer, found floating-point number
317
318error[E0308]: mismatched types
319  --> $DIR/recover-range-pats.rs:37:16
320   |
321LL |     if let X..=.0 = 0 {}
322   |            -   ^^   - this expression has type `u8`
323   |            |   |
324   |            |   expected integer, found floating-point number
325   |            this is of type `u8`
326
327error[E0029]: only char and numeric types are allowed in range patterns
328  --> $DIR/recover-range-pats.rs:46:12
329   |
330LL |     if let true...Y = 0 {}
331   |            ^^^^   - this is of type `u8`
332   |            |
333   |            this is of type `bool` but it should be `char` or numeric
334
335error[E0029]: only char and numeric types are allowed in range patterns
336  --> $DIR/recover-range-pats.rs:48:16
337   |
338LL |     if let X...true = 0 {}
339   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
340   |            |
341   |            this is of type `u8`
342
343error[E0308]: mismatched types
344  --> $DIR/recover-range-pats.rs:50:12
345   |
346LL |     if let .0...Y = 0 {}
347   |            ^^   - this is of type `u8`
348   |            |
349   |            expected integer, found floating-point number
350
351error[E0308]: mismatched types
352  --> $DIR/recover-range-pats.rs:53:17
353   |
354LL |     if let X... .0 = 0 {}
355   |            -    ^^   - this expression has type `u8`
356   |            |    |
357   |            |    expected integer, found floating-point number
358   |            this is of type `u8`
359
360error[E0029]: only char and numeric types are allowed in range patterns
361  --> $DIR/recover-range-pats.rs:61:12
362   |
363LL |     if let true.. = 0 {}
364   |            ^^^^ this is of type `bool` but it should be `char` or numeric
365
366error[E0308]: mismatched types
367  --> $DIR/recover-range-pats.rs:63:12
368   |
369LL |     if let .0.. = 0 {}
370   |            ^^ expected integer, found floating-point number
371
372error[E0029]: only char and numeric types are allowed in range patterns
373  --> $DIR/recover-range-pats.rs:71:12
374   |
375LL |     if let true..= = 0 {}
376   |            ^^^^ this is of type `bool` but it should be `char` or numeric
377
378error[E0308]: mismatched types
379  --> $DIR/recover-range-pats.rs:73:12
380   |
381LL |     if let .0..= = 0 {}
382   |            ^^ expected integer, found floating-point number
383
384error[E0029]: only char and numeric types are allowed in range patterns
385  --> $DIR/recover-range-pats.rs:81:12
386   |
387LL |     if let true... = 0 {}
388   |            ^^^^ this is of type `bool` but it should be `char` or numeric
389
390error[E0308]: mismatched types
391  --> $DIR/recover-range-pats.rs:83:12
392   |
393LL |     if let .0... = 0 {}
394   |            ^^ expected integer, found floating-point number
395
396error[E0029]: only char and numeric types are allowed in range patterns
397  --> $DIR/recover-range-pats.rs:91:14
398   |
399LL |     if let ..true = 0 {}
400   |              ^^^^ this is of type `bool` but it should be `char` or numeric
401
402error[E0308]: mismatched types
403  --> $DIR/recover-range-pats.rs:93:15
404   |
405LL |     if let .. .0 = 0 {}
406   |               ^^ expected integer, found floating-point number
407
408error[E0029]: only char and numeric types are allowed in range patterns
409  --> $DIR/recover-range-pats.rs:101:15
410   |
411LL |     if let ..=true = 0 {}
412   |               ^^^^ this is of type `bool` but it should be `char` or numeric
413
414error[E0308]: mismatched types
415  --> $DIR/recover-range-pats.rs:103:15
416   |
417LL |     if let ..=.0 = 0 {}
418   |               ^^ expected integer, found floating-point number
419
420error[E0029]: only char and numeric types are allowed in range patterns
421  --> $DIR/recover-range-pats.rs:113:15
422   |
423LL |     if let ...true = 0 {}
424   |               ^^^^ this is of type `bool` but it should be `char` or numeric
425
426error[E0308]: mismatched types
427  --> $DIR/recover-range-pats.rs:116:15
428   |
429LL |     if let ....3 = 0 {}
430   |               ^^ expected integer, found floating-point number
431
432error: aborting due to 60 previous errors
433
434Some errors have detailed explanations: E0029, E0308, E0586.
435For more information about an error, try `rustc --explain E0029`.