fork/rust

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

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

master
26.7 KiB939 linesraw
1error[E0308]: mismatched types
2  --> $DIR/integer-literal-suffix-inference.rs:38:11
3   |
4LL |     id_i8(a16);
5   |     ----- ^^^ expected `i8`, found `i16`
6   |     |
7   |     arguments to this function are incorrect
8   |
9note: function defined here
10  --> $DIR/integer-literal-suffix-inference.rs:15:8
11   |
12LL |     fn id_i8(n: i8) -> i8 { n }
13   |        ^^^^^ -----
14help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
15   |
16LL |     id_i8(a16.try_into().unwrap());
17   |              ++++++++++++++++++++
18
19error[E0308]: mismatched types
20  --> $DIR/integer-literal-suffix-inference.rs:41:11
21   |
22LL |     id_i8(a32);
23   |     ----- ^^^ expected `i8`, found `i32`
24   |     |
25   |     arguments to this function are incorrect
26   |
27note: function defined here
28  --> $DIR/integer-literal-suffix-inference.rs:15:8
29   |
30LL |     fn id_i8(n: i8) -> i8 { n }
31   |        ^^^^^ -----
32help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
33   |
34LL |     id_i8(a32.try_into().unwrap());
35   |              ++++++++++++++++++++
36
37error[E0308]: mismatched types
38  --> $DIR/integer-literal-suffix-inference.rs:44:11
39   |
40LL |     id_i8(a64);
41   |     ----- ^^^ expected `i8`, found `i64`
42   |     |
43   |     arguments to this function are incorrect
44   |
45note: function defined here
46  --> $DIR/integer-literal-suffix-inference.rs:15:8
47   |
48LL |     fn id_i8(n: i8) -> i8 { n }
49   |        ^^^^^ -----
50help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
51   |
52LL |     id_i8(a64.try_into().unwrap());
53   |              ++++++++++++++++++++
54
55error[E0308]: mismatched types
56  --> $DIR/integer-literal-suffix-inference.rs:47:11
57   |
58LL |     id_i8(asize);
59   |     ----- ^^^^^ expected `i8`, found `isize`
60   |     |
61   |     arguments to this function are incorrect
62   |
63note: function defined here
64  --> $DIR/integer-literal-suffix-inference.rs:15:8
65   |
66LL |     fn id_i8(n: i8) -> i8 { n }
67   |        ^^^^^ -----
68help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit
69   |
70LL |     id_i8(asize.try_into().unwrap());
71   |                ++++++++++++++++++++
72
73error[E0308]: mismatched types
74  --> $DIR/integer-literal-suffix-inference.rs:51:12
75   |
76LL |     id_i16(a8);
77   |     ------ ^^ expected `i16`, found `i8`
78   |     |
79   |     arguments to this function are incorrect
80   |
81note: function defined here
82  --> $DIR/integer-literal-suffix-inference.rs:16:8
83   |
84LL |     fn id_i16(n: i16) -> i16 { n }
85   |        ^^^^^^ ------
86help: you can convert an `i8` to an `i16`
87   |
88LL |     id_i16(a8.into());
89   |              +++++++
90
91error[E0308]: mismatched types
92  --> $DIR/integer-literal-suffix-inference.rs:55:12
93   |
94LL |     id_i16(a32);
95   |     ------ ^^^ expected `i16`, found `i32`
96   |     |
97   |     arguments to this function are incorrect
98   |
99note: function defined here
100  --> $DIR/integer-literal-suffix-inference.rs:16:8
101   |
102LL |     fn id_i16(n: i16) -> i16 { n }
103   |        ^^^^^^ ------
104help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
105   |
106LL |     id_i16(a32.try_into().unwrap());
107   |               ++++++++++++++++++++
108
109error[E0308]: mismatched types
110  --> $DIR/integer-literal-suffix-inference.rs:58:12
111   |
112LL |     id_i16(a64);
113   |     ------ ^^^ expected `i16`, found `i64`
114   |     |
115   |     arguments to this function are incorrect
116   |
117note: function defined here
118  --> $DIR/integer-literal-suffix-inference.rs:16:8
119   |
120LL |     fn id_i16(n: i16) -> i16 { n }
121   |        ^^^^^^ ------
122help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
123   |
124LL |     id_i16(a64.try_into().unwrap());
125   |               ++++++++++++++++++++
126
127error[E0308]: mismatched types
128  --> $DIR/integer-literal-suffix-inference.rs:61:12
129   |
130LL |     id_i16(asize);
131   |     ------ ^^^^^ expected `i16`, found `isize`
132   |     |
133   |     arguments to this function are incorrect
134   |
135note: function defined here
136  --> $DIR/integer-literal-suffix-inference.rs:16:8
137   |
138LL |     fn id_i16(n: i16) -> i16 { n }
139   |        ^^^^^^ ------
140help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
141   |
142LL |     id_i16(asize.try_into().unwrap());
143   |                 ++++++++++++++++++++
144
145error[E0308]: mismatched types
146  --> $DIR/integer-literal-suffix-inference.rs:65:12
147   |
148LL |     id_i32(a8);
149   |     ------ ^^ expected `i32`, found `i8`
150   |     |
151   |     arguments to this function are incorrect
152   |
153note: function defined here
154  --> $DIR/integer-literal-suffix-inference.rs:17:8
155   |
156LL |     fn id_i32(n: i32) -> i32 { n }
157   |        ^^^^^^ ------
158help: you can convert an `i8` to an `i32`
159   |
160LL |     id_i32(a8.into());
161   |              +++++++
162
163error[E0308]: mismatched types
164  --> $DIR/integer-literal-suffix-inference.rs:68:12
165   |
166LL |     id_i32(a16);
167   |     ------ ^^^ expected `i32`, found `i16`
168   |     |
169   |     arguments to this function are incorrect
170   |
171note: function defined here
172  --> $DIR/integer-literal-suffix-inference.rs:17:8
173   |
174LL |     fn id_i32(n: i32) -> i32 { n }
175   |        ^^^^^^ ------
176help: you can convert an `i16` to an `i32`
177   |
178LL |     id_i32(a16.into());
179   |               +++++++
180
181error[E0308]: mismatched types
182  --> $DIR/integer-literal-suffix-inference.rs:72:12
183   |
184LL |     id_i32(a64);
185   |     ------ ^^^ expected `i32`, found `i64`
186   |     |
187   |     arguments to this function are incorrect
188   |
189note: function defined here
190  --> $DIR/integer-literal-suffix-inference.rs:17:8
191   |
192LL |     fn id_i32(n: i32) -> i32 { n }
193   |        ^^^^^^ ------
194help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
195   |
196LL |     id_i32(a64.try_into().unwrap());
197   |               ++++++++++++++++++++
198
199error[E0308]: mismatched types
200  --> $DIR/integer-literal-suffix-inference.rs:75:12
201   |
202LL |     id_i32(asize);
203   |     ------ ^^^^^ expected `i32`, found `isize`
204   |     |
205   |     arguments to this function are incorrect
206   |
207note: function defined here
208  --> $DIR/integer-literal-suffix-inference.rs:17:8
209   |
210LL |     fn id_i32(n: i32) -> i32 { n }
211   |        ^^^^^^ ------
212help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
213   |
214LL |     id_i32(asize.try_into().unwrap());
215   |                 ++++++++++++++++++++
216
217error[E0308]: mismatched types
218  --> $DIR/integer-literal-suffix-inference.rs:79:12
219   |
220LL |     id_i64(a8);
221   |     ------ ^^ expected `i64`, found `i8`
222   |     |
223   |     arguments to this function are incorrect
224   |
225note: function defined here
226  --> $DIR/integer-literal-suffix-inference.rs:18:8
227   |
228LL |     fn id_i64(n: i64) -> i64 { n }
229   |        ^^^^^^ ------
230help: you can convert an `i8` to an `i64`
231   |
232LL |     id_i64(a8.into());
233   |              +++++++
234
235error[E0308]: mismatched types
236  --> $DIR/integer-literal-suffix-inference.rs:82:12
237   |
238LL |     id_i64(a16);
239   |     ------ ^^^ expected `i64`, found `i16`
240   |     |
241   |     arguments to this function are incorrect
242   |
243note: function defined here
244  --> $DIR/integer-literal-suffix-inference.rs:18:8
245   |
246LL |     fn id_i64(n: i64) -> i64 { n }
247   |        ^^^^^^ ------
248help: you can convert an `i16` to an `i64`
249   |
250LL |     id_i64(a16.into());
251   |               +++++++
252
253error[E0308]: mismatched types
254  --> $DIR/integer-literal-suffix-inference.rs:85:12
255   |
256LL |     id_i64(a32);
257   |     ------ ^^^ expected `i64`, found `i32`
258   |     |
259   |     arguments to this function are incorrect
260   |
261note: function defined here
262  --> $DIR/integer-literal-suffix-inference.rs:18:8
263   |
264LL |     fn id_i64(n: i64) -> i64 { n }
265   |        ^^^^^^ ------
266help: you can convert an `i32` to an `i64`
267   |
268LL |     id_i64(a32.into());
269   |               +++++++
270
271error[E0308]: mismatched types
272  --> $DIR/integer-literal-suffix-inference.rs:89:12
273   |
274LL |     id_i64(asize);
275   |     ------ ^^^^^ expected `i64`, found `isize`
276   |     |
277   |     arguments to this function are incorrect
278   |
279note: function defined here
280  --> $DIR/integer-literal-suffix-inference.rs:18:8
281   |
282LL |     fn id_i64(n: i64) -> i64 { n }
283   |        ^^^^^^ ------
284help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
285   |
286LL |     id_i64(asize.try_into().unwrap());
287   |                 ++++++++++++++++++++
288
289error[E0308]: mismatched types
290  --> $DIR/integer-literal-suffix-inference.rs:93:14
291   |
292LL |     id_isize(a8);
293   |     -------- ^^ expected `isize`, found `i8`
294   |     |
295   |     arguments to this function are incorrect
296   |
297note: function defined here
298  --> $DIR/integer-literal-suffix-inference.rs:19:8
299   |
300LL |     fn id_isize(n: isize) -> isize { n }
301   |        ^^^^^^^^ --------
302help: you can convert an `i8` to an `isize`
303   |
304LL |     id_isize(a8.into());
305   |                +++++++
306
307error[E0308]: mismatched types
308  --> $DIR/integer-literal-suffix-inference.rs:96:14
309   |
310LL |     id_isize(a16);
311   |     -------- ^^^ expected `isize`, found `i16`
312   |     |
313   |     arguments to this function are incorrect
314   |
315note: function defined here
316  --> $DIR/integer-literal-suffix-inference.rs:19:8
317   |
318LL |     fn id_isize(n: isize) -> isize { n }
319   |        ^^^^^^^^ --------
320help: you can convert an `i16` to an `isize`
321   |
322LL |     id_isize(a16.into());
323   |                 +++++++
324
325error[E0308]: mismatched types
326  --> $DIR/integer-literal-suffix-inference.rs:99:14
327   |
328LL |     id_isize(a32);
329   |     -------- ^^^ expected `isize`, found `i32`
330   |     |
331   |     arguments to this function are incorrect
332   |
333note: function defined here
334  --> $DIR/integer-literal-suffix-inference.rs:19:8
335   |
336LL |     fn id_isize(n: isize) -> isize { n }
337   |        ^^^^^^^^ --------
338help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
339   |
340LL |     id_isize(a32.try_into().unwrap());
341   |                 ++++++++++++++++++++
342
343error[E0308]: mismatched types
344  --> $DIR/integer-literal-suffix-inference.rs:102:14
345   |
346LL |     id_isize(a64);
347   |     -------- ^^^ expected `isize`, found `i64`
348   |     |
349   |     arguments to this function are incorrect
350   |
351note: function defined here
352  --> $DIR/integer-literal-suffix-inference.rs:19:8
353   |
354LL |     fn id_isize(n: isize) -> isize { n }
355   |        ^^^^^^^^ --------
356help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
357   |
358LL |     id_isize(a64.try_into().unwrap());
359   |                 ++++++++++++++++++++
360
361error[E0308]: mismatched types
362  --> $DIR/integer-literal-suffix-inference.rs:108:11
363   |
364LL |     id_i8(c16);
365   |     ----- ^^^ expected `i8`, found `i16`
366   |     |
367   |     arguments to this function are incorrect
368   |
369note: function defined here
370  --> $DIR/integer-literal-suffix-inference.rs:15:8
371   |
372LL |     fn id_i8(n: i8) -> i8 { n }
373   |        ^^^^^ -----
374help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
375   |
376LL |     id_i8(c16.try_into().unwrap());
377   |              ++++++++++++++++++++
378
379error[E0308]: mismatched types
380  --> $DIR/integer-literal-suffix-inference.rs:111:11
381   |
382LL |     id_i8(c32);
383   |     ----- ^^^ expected `i8`, found `i32`
384   |     |
385   |     arguments to this function are incorrect
386   |
387note: function defined here
388  --> $DIR/integer-literal-suffix-inference.rs:15:8
389   |
390LL |     fn id_i8(n: i8) -> i8 { n }
391   |        ^^^^^ -----
392help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
393   |
394LL |     id_i8(c32.try_into().unwrap());
395   |              ++++++++++++++++++++
396
397error[E0308]: mismatched types
398  --> $DIR/integer-literal-suffix-inference.rs:114:11
399   |
400LL |     id_i8(c64);
401   |     ----- ^^^ expected `i8`, found `i64`
402   |     |
403   |     arguments to this function are incorrect
404   |
405note: function defined here
406  --> $DIR/integer-literal-suffix-inference.rs:15:8
407   |
408LL |     fn id_i8(n: i8) -> i8 { n }
409   |        ^^^^^ -----
410help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
411   |
412LL |     id_i8(c64.try_into().unwrap());
413   |              ++++++++++++++++++++
414
415error[E0308]: mismatched types
416  --> $DIR/integer-literal-suffix-inference.rs:118:12
417   |
418LL |     id_i16(c8);
419   |     ------ ^^ expected `i16`, found `i8`
420   |     |
421   |     arguments to this function are incorrect
422   |
423note: function defined here
424  --> $DIR/integer-literal-suffix-inference.rs:16:8
425   |
426LL |     fn id_i16(n: i16) -> i16 { n }
427   |        ^^^^^^ ------
428help: you can convert an `i8` to an `i16`
429   |
430LL |     id_i16(c8.into());
431   |              +++++++
432
433error[E0308]: mismatched types
434  --> $DIR/integer-literal-suffix-inference.rs:122:12
435   |
436LL |     id_i16(c32);
437   |     ------ ^^^ expected `i16`, found `i32`
438   |     |
439   |     arguments to this function are incorrect
440   |
441note: function defined here
442  --> $DIR/integer-literal-suffix-inference.rs:16:8
443   |
444LL |     fn id_i16(n: i16) -> i16 { n }
445   |        ^^^^^^ ------
446help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
447   |
448LL |     id_i16(c32.try_into().unwrap());
449   |               ++++++++++++++++++++
450
451error[E0308]: mismatched types
452  --> $DIR/integer-literal-suffix-inference.rs:125:12
453   |
454LL |     id_i16(c64);
455   |     ------ ^^^ expected `i16`, found `i64`
456   |     |
457   |     arguments to this function are incorrect
458   |
459note: function defined here
460  --> $DIR/integer-literal-suffix-inference.rs:16:8
461   |
462LL |     fn id_i16(n: i16) -> i16 { n }
463   |        ^^^^^^ ------
464help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
465   |
466LL |     id_i16(c64.try_into().unwrap());
467   |               ++++++++++++++++++++
468
469error[E0308]: mismatched types
470  --> $DIR/integer-literal-suffix-inference.rs:129:12
471   |
472LL |     id_i32(c8);
473   |     ------ ^^ expected `i32`, found `i8`
474   |     |
475   |     arguments to this function are incorrect
476   |
477note: function defined here
478  --> $DIR/integer-literal-suffix-inference.rs:17:8
479   |
480LL |     fn id_i32(n: i32) -> i32 { n }
481   |        ^^^^^^ ------
482help: you can convert an `i8` to an `i32`
483   |
484LL |     id_i32(c8.into());
485   |              +++++++
486
487error[E0308]: mismatched types
488  --> $DIR/integer-literal-suffix-inference.rs:132:12
489   |
490LL |     id_i32(c16);
491   |     ------ ^^^ expected `i32`, found `i16`
492   |     |
493   |     arguments to this function are incorrect
494   |
495note: function defined here
496  --> $DIR/integer-literal-suffix-inference.rs:17:8
497   |
498LL |     fn id_i32(n: i32) -> i32 { n }
499   |        ^^^^^^ ------
500help: you can convert an `i16` to an `i32`
501   |
502LL |     id_i32(c16.into());
503   |               +++++++
504
505error[E0308]: mismatched types
506  --> $DIR/integer-literal-suffix-inference.rs:136:12
507   |
508LL |     id_i32(c64);
509   |     ------ ^^^ expected `i32`, found `i64`
510   |     |
511   |     arguments to this function are incorrect
512   |
513note: function defined here
514  --> $DIR/integer-literal-suffix-inference.rs:17:8
515   |
516LL |     fn id_i32(n: i32) -> i32 { n }
517   |        ^^^^^^ ------
518help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
519   |
520LL |     id_i32(c64.try_into().unwrap());
521   |               ++++++++++++++++++++
522
523error[E0308]: mismatched types
524  --> $DIR/integer-literal-suffix-inference.rs:140:12
525   |
526LL |     id_i64(a8);
527   |     ------ ^^ expected `i64`, found `i8`
528   |     |
529   |     arguments to this function are incorrect
530   |
531note: function defined here
532  --> $DIR/integer-literal-suffix-inference.rs:18:8
533   |
534LL |     fn id_i64(n: i64) -> i64 { n }
535   |        ^^^^^^ ------
536help: you can convert an `i8` to an `i64`
537   |
538LL |     id_i64(a8.into());
539   |              +++++++
540
541error[E0308]: mismatched types
542  --> $DIR/integer-literal-suffix-inference.rs:143:12
543   |
544LL |     id_i64(a16);
545   |     ------ ^^^ expected `i64`, found `i16`
546   |     |
547   |     arguments to this function are incorrect
548   |
549note: function defined here
550  --> $DIR/integer-literal-suffix-inference.rs:18:8
551   |
552LL |     fn id_i64(n: i64) -> i64 { n }
553   |        ^^^^^^ ------
554help: you can convert an `i16` to an `i64`
555   |
556LL |     id_i64(a16.into());
557   |               +++++++
558
559error[E0308]: mismatched types
560  --> $DIR/integer-literal-suffix-inference.rs:146:12
561   |
562LL |     id_i64(a32);
563   |     ------ ^^^ expected `i64`, found `i32`
564   |     |
565   |     arguments to this function are incorrect
566   |
567note: function defined here
568  --> $DIR/integer-literal-suffix-inference.rs:18:8
569   |
570LL |     fn id_i64(n: i64) -> i64 { n }
571   |        ^^^^^^ ------
572help: you can convert an `i32` to an `i64`
573   |
574LL |     id_i64(a32.into());
575   |               +++++++
576
577error[E0308]: mismatched types
578  --> $DIR/integer-literal-suffix-inference.rs:152:11
579   |
580LL |     id_u8(b16);
581   |     ----- ^^^ expected `u8`, found `u16`
582   |     |
583   |     arguments to this function are incorrect
584   |
585note: function defined here
586  --> $DIR/integer-literal-suffix-inference.rs:27:8
587   |
588LL |     fn id_u8(n: u8) -> u8 { n }
589   |        ^^^^^ -----
590help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit
591   |
592LL |     id_u8(b16.try_into().unwrap());
593   |              ++++++++++++++++++++
594
595error[E0308]: mismatched types
596  --> $DIR/integer-literal-suffix-inference.rs:155:11
597   |
598LL |     id_u8(b32);
599   |     ----- ^^^ expected `u8`, found `u32`
600   |     |
601   |     arguments to this function are incorrect
602   |
603note: function defined here
604  --> $DIR/integer-literal-suffix-inference.rs:27:8
605   |
606LL |     fn id_u8(n: u8) -> u8 { n }
607   |        ^^^^^ -----
608help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit
609   |
610LL |     id_u8(b32.try_into().unwrap());
611   |              ++++++++++++++++++++
612
613error[E0308]: mismatched types
614  --> $DIR/integer-literal-suffix-inference.rs:158:11
615   |
616LL |     id_u8(b64);
617   |     ----- ^^^ expected `u8`, found `u64`
618   |     |
619   |     arguments to this function are incorrect
620   |
621note: function defined here
622  --> $DIR/integer-literal-suffix-inference.rs:27:8
623   |
624LL |     fn id_u8(n: u8) -> u8 { n }
625   |        ^^^^^ -----
626help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit
627   |
628LL |     id_u8(b64.try_into().unwrap());
629   |              ++++++++++++++++++++
630
631error[E0308]: mismatched types
632  --> $DIR/integer-literal-suffix-inference.rs:161:11
633   |
634LL |     id_u8(bsize);
635   |     ----- ^^^^^ expected `u8`, found `usize`
636   |     |
637   |     arguments to this function are incorrect
638   |
639note: function defined here
640  --> $DIR/integer-literal-suffix-inference.rs:27:8
641   |
642LL |     fn id_u8(n: u8) -> u8 { n }
643   |        ^^^^^ -----
644help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit
645   |
646LL |     id_u8(bsize.try_into().unwrap());
647   |                ++++++++++++++++++++
648
649error[E0308]: mismatched types
650  --> $DIR/integer-literal-suffix-inference.rs:165:12
651   |
652LL |     id_u16(b8);
653   |     ------ ^^ expected `u16`, found `u8`
654   |     |
655   |     arguments to this function are incorrect
656   |
657note: function defined here
658  --> $DIR/integer-literal-suffix-inference.rs:28:8
659   |
660LL |     fn id_u16(n: u16) -> u16 { n }
661   |        ^^^^^^ ------
662help: you can convert a `u8` to a `u16`
663   |
664LL |     id_u16(b8.into());
665   |              +++++++
666
667error[E0308]: mismatched types
668  --> $DIR/integer-literal-suffix-inference.rs:169:12
669   |
670LL |     id_u16(b32);
671   |     ------ ^^^ expected `u16`, found `u32`
672   |     |
673   |     arguments to this function are incorrect
674   |
675note: function defined here
676  --> $DIR/integer-literal-suffix-inference.rs:28:8
677   |
678LL |     fn id_u16(n: u16) -> u16 { n }
679   |        ^^^^^^ ------
680help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit
681   |
682LL |     id_u16(b32.try_into().unwrap());
683   |               ++++++++++++++++++++
684
685error[E0308]: mismatched types
686  --> $DIR/integer-literal-suffix-inference.rs:172:12
687   |
688LL |     id_u16(b64);
689   |     ------ ^^^ expected `u16`, found `u64`
690   |     |
691   |     arguments to this function are incorrect
692   |
693note: function defined here
694  --> $DIR/integer-literal-suffix-inference.rs:28:8
695   |
696LL |     fn id_u16(n: u16) -> u16 { n }
697   |        ^^^^^^ ------
698help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit
699   |
700LL |     id_u16(b64.try_into().unwrap());
701   |               ++++++++++++++++++++
702
703error[E0308]: mismatched types
704  --> $DIR/integer-literal-suffix-inference.rs:175:12
705   |
706LL |     id_u16(bsize);
707   |     ------ ^^^^^ expected `u16`, found `usize`
708   |     |
709   |     arguments to this function are incorrect
710   |
711note: function defined here
712  --> $DIR/integer-literal-suffix-inference.rs:28:8
713   |
714LL |     fn id_u16(n: u16) -> u16 { n }
715   |        ^^^^^^ ------
716help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit
717   |
718LL |     id_u16(bsize.try_into().unwrap());
719   |                 ++++++++++++++++++++
720
721error[E0308]: mismatched types
722  --> $DIR/integer-literal-suffix-inference.rs:179:12
723   |
724LL |     id_u32(b8);
725   |     ------ ^^ expected `u32`, found `u8`
726   |     |
727   |     arguments to this function are incorrect
728   |
729note: function defined here
730  --> $DIR/integer-literal-suffix-inference.rs:29:8
731   |
732LL |     fn id_u32(n: u32) -> u32 { n }
733   |        ^^^^^^ ------
734help: you can convert a `u8` to a `u32`
735   |
736LL |     id_u32(b8.into());
737   |              +++++++
738
739error[E0308]: mismatched types
740  --> $DIR/integer-literal-suffix-inference.rs:182:12
741   |
742LL |     id_u32(b16);
743   |     ------ ^^^ expected `u32`, found `u16`
744   |     |
745   |     arguments to this function are incorrect
746   |
747note: function defined here
748  --> $DIR/integer-literal-suffix-inference.rs:29:8
749   |
750LL |     fn id_u32(n: u32) -> u32 { n }
751   |        ^^^^^^ ------
752help: you can convert a `u16` to a `u32`
753   |
754LL |     id_u32(b16.into());
755   |               +++++++
756
757error[E0308]: mismatched types
758  --> $DIR/integer-literal-suffix-inference.rs:186:12
759   |
760LL |     id_u32(b64);
761   |     ------ ^^^ expected `u32`, found `u64`
762   |     |
763   |     arguments to this function are incorrect
764   |
765note: function defined here
766  --> $DIR/integer-literal-suffix-inference.rs:29:8
767   |
768LL |     fn id_u32(n: u32) -> u32 { n }
769   |        ^^^^^^ ------
770help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
771   |
772LL |     id_u32(b64.try_into().unwrap());
773   |               ++++++++++++++++++++
774
775error[E0308]: mismatched types
776  --> $DIR/integer-literal-suffix-inference.rs:189:12
777   |
778LL |     id_u32(bsize);
779   |     ------ ^^^^^ expected `u32`, found `usize`
780   |     |
781   |     arguments to this function are incorrect
782   |
783note: function defined here
784  --> $DIR/integer-literal-suffix-inference.rs:29:8
785   |
786LL |     fn id_u32(n: u32) -> u32 { n }
787   |        ^^^^^^ ------
788help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
789   |
790LL |     id_u32(bsize.try_into().unwrap());
791   |                 ++++++++++++++++++++
792
793error[E0308]: mismatched types
794  --> $DIR/integer-literal-suffix-inference.rs:193:12
795   |
796LL |     id_u64(b8);
797   |     ------ ^^ expected `u64`, found `u8`
798   |     |
799   |     arguments to this function are incorrect
800   |
801note: function defined here
802  --> $DIR/integer-literal-suffix-inference.rs:30:8
803   |
804LL |     fn id_u64(n: u64) -> u64 { n }
805   |        ^^^^^^ ------
806help: you can convert a `u8` to a `u64`
807   |
808LL |     id_u64(b8.into());
809   |              +++++++
810
811error[E0308]: mismatched types
812  --> $DIR/integer-literal-suffix-inference.rs:196:12
813   |
814LL |     id_u64(b16);
815   |     ------ ^^^ expected `u64`, found `u16`
816   |     |
817   |     arguments to this function are incorrect
818   |
819note: function defined here
820  --> $DIR/integer-literal-suffix-inference.rs:30:8
821   |
822LL |     fn id_u64(n: u64) -> u64 { n }
823   |        ^^^^^^ ------
824help: you can convert a `u16` to a `u64`
825   |
826LL |     id_u64(b16.into());
827   |               +++++++
828
829error[E0308]: mismatched types
830  --> $DIR/integer-literal-suffix-inference.rs:199:12
831   |
832LL |     id_u64(b32);
833   |     ------ ^^^ expected `u64`, found `u32`
834   |     |
835   |     arguments to this function are incorrect
836   |
837note: function defined here
838  --> $DIR/integer-literal-suffix-inference.rs:30:8
839   |
840LL |     fn id_u64(n: u64) -> u64 { n }
841   |        ^^^^^^ ------
842help: you can convert a `u32` to a `u64`
843   |
844LL |     id_u64(b32.into());
845   |               +++++++
846
847error[E0308]: mismatched types
848  --> $DIR/integer-literal-suffix-inference.rs:203:12
849   |
850LL |     id_u64(bsize);
851   |     ------ ^^^^^ expected `u64`, found `usize`
852   |     |
853   |     arguments to this function are incorrect
854   |
855note: function defined here
856  --> $DIR/integer-literal-suffix-inference.rs:30:8
857   |
858LL |     fn id_u64(n: u64) -> u64 { n }
859   |        ^^^^^^ ------
860help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
861   |
862LL |     id_u64(bsize.try_into().unwrap());
863   |                 ++++++++++++++++++++
864
865error[E0308]: mismatched types
866  --> $DIR/integer-literal-suffix-inference.rs:207:14
867   |
868LL |     id_usize(b8);
869   |     -------- ^^ expected `usize`, found `u8`
870   |     |
871   |     arguments to this function are incorrect
872   |
873note: function defined here
874  --> $DIR/integer-literal-suffix-inference.rs:31:8
875   |
876LL |     fn id_usize(n: usize) -> usize { n }
877   |        ^^^^^^^^ --------
878help: you can convert a `u8` to a `usize`
879   |
880LL |     id_usize(b8.into());
881   |                +++++++
882
883error[E0308]: mismatched types
884  --> $DIR/integer-literal-suffix-inference.rs:210:14
885   |
886LL |     id_usize(b16);
887   |     -------- ^^^ expected `usize`, found `u16`
888   |     |
889   |     arguments to this function are incorrect
890   |
891note: function defined here
892  --> $DIR/integer-literal-suffix-inference.rs:31:8
893   |
894LL |     fn id_usize(n: usize) -> usize { n }
895   |        ^^^^^^^^ --------
896help: you can convert a `u16` to a `usize`
897   |
898LL |     id_usize(b16.into());
899   |                 +++++++
900
901error[E0308]: mismatched types
902  --> $DIR/integer-literal-suffix-inference.rs:213:14
903   |
904LL |     id_usize(b32);
905   |     -------- ^^^ expected `usize`, found `u32`
906   |     |
907   |     arguments to this function are incorrect
908   |
909note: function defined here
910  --> $DIR/integer-literal-suffix-inference.rs:31:8
911   |
912LL |     fn id_usize(n: usize) -> usize { n }
913   |        ^^^^^^^^ --------
914help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
915   |
916LL |     id_usize(b32.try_into().unwrap());
917   |                 ++++++++++++++++++++
918
919error[E0308]: mismatched types
920  --> $DIR/integer-literal-suffix-inference.rs:216:14
921   |
922LL |     id_usize(b64);
923   |     -------- ^^^ expected `usize`, found `u64`
924   |     |
925   |     arguments to this function are incorrect
926   |
927note: function defined here
928  --> $DIR/integer-literal-suffix-inference.rs:31:8
929   |
930LL |     fn id_usize(n: usize) -> usize { n }
931   |        ^^^^^^^^ --------
932help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
933   |
934LL |     id_usize(b64.try_into().unwrap());
935   |                 ++++++++++++++++++++
936
937error: aborting due to 52 previous errors
938
939For more information about this error, try `rustc --explain E0308`.