fork/rust

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

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

master
50.1 KiB1719 linesraw
1error[E0308]: mismatched types
2  --> $DIR/numeric-cast-binop.rs:23:16
3   |
4LL |         x_u8 > x_u16;
5   |         ----   ^^^^^ expected `u8`, found `u16`
6   |         |
7   |         expected because this is `u8`
8   |
9help: you can convert `x_u8` from `u8` to `u16`, matching the type of `x_u16`
10   |
11LL |         u16::from(x_u8) > x_u16;
12   |         ++++++++++    +
13
14error[E0308]: mismatched types
15  --> $DIR/numeric-cast-binop.rs:25:16
16   |
17LL |         x_u8 > x_u32;
18   |         ----   ^^^^^ expected `u8`, found `u32`
19   |         |
20   |         expected because this is `u8`
21   |
22help: you can convert `x_u8` from `u8` to `u32`, matching the type of `x_u32`
23   |
24LL |         u32::from(x_u8) > x_u32;
25   |         ++++++++++    +
26
27error[E0308]: mismatched types
28  --> $DIR/numeric-cast-binop.rs:27:16
29   |
30LL |         x_u8 > x_u64;
31   |         ----   ^^^^^ expected `u8`, found `u64`
32   |         |
33   |         expected because this is `u8`
34   |
35help: you can convert `x_u8` from `u8` to `u64`, matching the type of `x_u64`
36   |
37LL |         u64::from(x_u8) > x_u64;
38   |         ++++++++++    +
39
40error[E0308]: mismatched types
41  --> $DIR/numeric-cast-binop.rs:29:16
42   |
43LL |         x_u8 > x_u128;
44   |         ----   ^^^^^^ expected `u8`, found `u128`
45   |         |
46   |         expected because this is `u8`
47   |
48help: you can convert `x_u8` from `u8` to `u128`, matching the type of `x_u128`
49   |
50LL |         u128::from(x_u8) > x_u128;
51   |         +++++++++++    +
52
53error[E0308]: mismatched types
54  --> $DIR/numeric-cast-binop.rs:31:16
55   |
56LL |         x_u8 > x_usize;
57   |         ----   ^^^^^^^ expected `u8`, found `usize`
58   |         |
59   |         expected because this is `u8`
60   |
61help: you can convert `x_u8` from `u8` to `usize`, matching the type of `x_usize`
62   |
63LL |         usize::from(x_u8) > x_usize;
64   |         ++++++++++++    +
65
66error[E0308]: mismatched types
67  --> $DIR/numeric-cast-binop.rs:34:17
68   |
69LL |         x_u16 > x_u8;
70   |         -----   ^^^^ expected `u16`, found `u8`
71   |         |
72   |         expected because this is `u16`
73   |
74help: you can convert a `u8` to a `u16`
75   |
76LL |         x_u16 > x_u8.into();
77   |                     +++++++
78
79error[E0308]: mismatched types
80  --> $DIR/numeric-cast-binop.rs:36:17
81   |
82LL |         x_u16 > x_u32;
83   |         -----   ^^^^^ expected `u16`, found `u32`
84   |         |
85   |         expected because this is `u16`
86   |
87help: you can convert `x_u16` from `u16` to `u32`, matching the type of `x_u32`
88   |
89LL |         u32::from(x_u16) > x_u32;
90   |         ++++++++++     +
91
92error[E0308]: mismatched types
93  --> $DIR/numeric-cast-binop.rs:38:17
94   |
95LL |         x_u16 > x_u64;
96   |         -----   ^^^^^ expected `u16`, found `u64`
97   |         |
98   |         expected because this is `u16`
99   |
100help: you can convert `x_u16` from `u16` to `u64`, matching the type of `x_u64`
101   |
102LL |         u64::from(x_u16) > x_u64;
103   |         ++++++++++     +
104
105error[E0308]: mismatched types
106  --> $DIR/numeric-cast-binop.rs:40:17
107   |
108LL |         x_u16 > x_u128;
109   |         -----   ^^^^^^ expected `u16`, found `u128`
110   |         |
111   |         expected because this is `u16`
112   |
113help: you can convert `x_u16` from `u16` to `u128`, matching the type of `x_u128`
114   |
115LL |         u128::from(x_u16) > x_u128;
116   |         +++++++++++     +
117
118error[E0308]: mismatched types
119  --> $DIR/numeric-cast-binop.rs:42:17
120   |
121LL |         x_u16 > x_usize;
122   |         -----   ^^^^^^^ expected `u16`, found `usize`
123   |         |
124   |         expected because this is `u16`
125   |
126help: you can convert `x_u16` from `u16` to `usize`, matching the type of `x_usize`
127   |
128LL |         usize::from(x_u16) > x_usize;
129   |         ++++++++++++     +
130
131error[E0308]: mismatched types
132  --> $DIR/numeric-cast-binop.rs:45:17
133   |
134LL |         x_u32 > x_u8;
135   |         -----   ^^^^ expected `u32`, found `u8`
136   |         |
137   |         expected because this is `u32`
138   |
139help: you can convert a `u8` to a `u32`
140   |
141LL |         x_u32 > x_u8.into();
142   |                     +++++++
143
144error[E0308]: mismatched types
145  --> $DIR/numeric-cast-binop.rs:47:17
146   |
147LL |         x_u32 > x_u16;
148   |         -----   ^^^^^ expected `u32`, found `u16`
149   |         |
150   |         expected because this is `u32`
151   |
152help: you can convert a `u16` to a `u32`
153   |
154LL |         x_u32 > x_u16.into();
155   |                      +++++++
156
157error[E0308]: mismatched types
158  --> $DIR/numeric-cast-binop.rs:49:17
159   |
160LL |         x_u32 > x_u64;
161   |         -----   ^^^^^ expected `u32`, found `u64`
162   |         |
163   |         expected because this is `u32`
164   |
165help: you can convert `x_u32` from `u32` to `u64`, matching the type of `x_u64`
166   |
167LL |         u64::from(x_u32) > x_u64;
168   |         ++++++++++     +
169
170error[E0308]: mismatched types
171  --> $DIR/numeric-cast-binop.rs:51:17
172   |
173LL |         x_u32 > x_u128;
174   |         -----   ^^^^^^ expected `u32`, found `u128`
175   |         |
176   |         expected because this is `u32`
177   |
178help: you can convert `x_u32` from `u32` to `u128`, matching the type of `x_u128`
179   |
180LL |         u128::from(x_u32) > x_u128;
181   |         +++++++++++     +
182
183error[E0308]: mismatched types
184  --> $DIR/numeric-cast-binop.rs:53:17
185   |
186LL |         x_u32 > x_usize;
187   |         -----   ^^^^^^^ expected `u32`, found `usize`
188   |         |
189   |         expected because this is `u32`
190   |
191help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
192   |
193LL |         x_u32 > x_usize.try_into().unwrap();
194   |                        ++++++++++++++++++++
195
196error[E0308]: mismatched types
197  --> $DIR/numeric-cast-binop.rs:56:17
198   |
199LL |         x_u64 > x_u8;
200   |         -----   ^^^^ expected `u64`, found `u8`
201   |         |
202   |         expected because this is `u64`
203   |
204help: you can convert a `u8` to a `u64`
205   |
206LL |         x_u64 > x_u8.into();
207   |                     +++++++
208
209error[E0308]: mismatched types
210  --> $DIR/numeric-cast-binop.rs:58:17
211   |
212LL |         x_u64 > x_u16;
213   |         -----   ^^^^^ expected `u64`, found `u16`
214   |         |
215   |         expected because this is `u64`
216   |
217help: you can convert a `u16` to a `u64`
218   |
219LL |         x_u64 > x_u16.into();
220   |                      +++++++
221
222error[E0308]: mismatched types
223  --> $DIR/numeric-cast-binop.rs:60:17
224   |
225LL |         x_u64 > x_u32;
226   |         -----   ^^^^^ expected `u64`, found `u32`
227   |         |
228   |         expected because this is `u64`
229   |
230help: you can convert a `u32` to a `u64`
231   |
232LL |         x_u64 > x_u32.into();
233   |                      +++++++
234
235error[E0308]: mismatched types
236  --> $DIR/numeric-cast-binop.rs:62:17
237   |
238LL |         x_u64 > x_u128;
239   |         -----   ^^^^^^ expected `u64`, found `u128`
240   |         |
241   |         expected because this is `u64`
242   |
243help: you can convert `x_u64` from `u64` to `u128`, matching the type of `x_u128`
244   |
245LL |         u128::from(x_u64) > x_u128;
246   |         +++++++++++     +
247
248error[E0308]: mismatched types
249  --> $DIR/numeric-cast-binop.rs:64:17
250   |
251LL |         x_u64 > x_usize;
252   |         -----   ^^^^^^^ expected `u64`, found `usize`
253   |         |
254   |         expected because this is `u64`
255   |
256help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
257   |
258LL |         x_u64 > x_usize.try_into().unwrap();
259   |                        ++++++++++++++++++++
260
261error[E0308]: mismatched types
262  --> $DIR/numeric-cast-binop.rs:67:18
263   |
264LL |         x_u128 > x_u8;
265   |         ------   ^^^^ expected `u128`, found `u8`
266   |         |
267   |         expected because this is `u128`
268   |
269help: you can convert a `u8` to a `u128`
270   |
271LL |         x_u128 > x_u8.into();
272   |                      +++++++
273
274error[E0308]: mismatched types
275  --> $DIR/numeric-cast-binop.rs:69:18
276   |
277LL |         x_u128 > x_u16;
278   |         ------   ^^^^^ expected `u128`, found `u16`
279   |         |
280   |         expected because this is `u128`
281   |
282help: you can convert a `u16` to a `u128`
283   |
284LL |         x_u128 > x_u16.into();
285   |                       +++++++
286
287error[E0308]: mismatched types
288  --> $DIR/numeric-cast-binop.rs:71:18
289   |
290LL |         x_u128 > x_u32;
291   |         ------   ^^^^^ expected `u128`, found `u32`
292   |         |
293   |         expected because this is `u128`
294   |
295help: you can convert a `u32` to a `u128`
296   |
297LL |         x_u128 > x_u32.into();
298   |                       +++++++
299
300error[E0308]: mismatched types
301  --> $DIR/numeric-cast-binop.rs:73:18
302   |
303LL |         x_u128 > x_u64;
304   |         ------   ^^^^^ expected `u128`, found `u64`
305   |         |
306   |         expected because this is `u128`
307   |
308help: you can convert a `u64` to a `u128`
309   |
310LL |         x_u128 > x_u64.into();
311   |                       +++++++
312
313error[E0308]: mismatched types
314  --> $DIR/numeric-cast-binop.rs:75:18
315   |
316LL |         x_u128 > x_usize;
317   |         ------   ^^^^^^^ expected `u128`, found `usize`
318   |         |
319   |         expected because this is `u128`
320   |
321help: you can convert a `usize` to a `u128` and panic if the converted value doesn't fit
322   |
323LL |         x_u128 > x_usize.try_into().unwrap();
324   |                         ++++++++++++++++++++
325
326error[E0308]: mismatched types
327  --> $DIR/numeric-cast-binop.rs:78:19
328   |
329LL |         x_usize > x_u8;
330   |         -------   ^^^^ expected `usize`, found `u8`
331   |         |
332   |         expected because this is `usize`
333   |
334help: you can convert a `u8` to a `usize`
335   |
336LL |         x_usize > x_u8.into();
337   |                       +++++++
338
339error[E0308]: mismatched types
340  --> $DIR/numeric-cast-binop.rs:80:19
341   |
342LL |         x_usize > x_u16;
343   |         -------   ^^^^^ expected `usize`, found `u16`
344   |         |
345   |         expected because this is `usize`
346   |
347help: you can convert a `u16` to a `usize`
348   |
349LL |         x_usize > x_u16.into();
350   |                        +++++++
351
352error[E0308]: mismatched types
353  --> $DIR/numeric-cast-binop.rs:82:19
354   |
355LL |         x_usize > x_u32;
356   |         -------   ^^^^^ expected `usize`, found `u32`
357   |         |
358   |         expected because this is `usize`
359   |
360help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
361   |
362LL |         x_usize > x_u32.try_into().unwrap();
363   |                        ++++++++++++++++++++
364
365error[E0308]: mismatched types
366  --> $DIR/numeric-cast-binop.rs:84:19
367   |
368LL |         x_usize > x_u64;
369   |         -------   ^^^^^ expected `usize`, found `u64`
370   |         |
371   |         expected because this is `usize`
372   |
373help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
374   |
375LL |         x_usize > x_u64.try_into().unwrap();
376   |                        ++++++++++++++++++++
377
378error[E0308]: mismatched types
379  --> $DIR/numeric-cast-binop.rs:86:19
380   |
381LL |         x_usize > x_u128;
382   |         -------   ^^^^^^ expected `usize`, found `u128`
383   |         |
384   |         expected because this is `usize`
385   |
386help: you can convert a `u128` to a `usize` and panic if the converted value doesn't fit
387   |
388LL |         x_usize > x_u128.try_into().unwrap();
389   |                         ++++++++++++++++++++
390
391error[E0308]: mismatched types
392  --> $DIR/numeric-cast-binop.rs:92:16
393   |
394LL |         x_i8 > x_i16;
395   |         ----   ^^^^^ expected `i8`, found `i16`
396   |         |
397   |         expected because this is `i8`
398   |
399help: you can convert `x_i8` from `i8` to `i16`, matching the type of `x_i16`
400   |
401LL |         i16::from(x_i8) > x_i16;
402   |         ++++++++++    +
403
404error[E0308]: mismatched types
405  --> $DIR/numeric-cast-binop.rs:94:16
406   |
407LL |         x_i8 > x_i32;
408   |         ----   ^^^^^ expected `i8`, found `i32`
409   |         |
410   |         expected because this is `i8`
411   |
412help: you can convert `x_i8` from `i8` to `i32`, matching the type of `x_i32`
413   |
414LL |         i32::from(x_i8) > x_i32;
415   |         ++++++++++    +
416
417error[E0308]: mismatched types
418  --> $DIR/numeric-cast-binop.rs:96:16
419   |
420LL |         x_i8 > x_i64;
421   |         ----   ^^^^^ expected `i8`, found `i64`
422   |         |
423   |         expected because this is `i8`
424   |
425help: you can convert `x_i8` from `i8` to `i64`, matching the type of `x_i64`
426   |
427LL |         i64::from(x_i8) > x_i64;
428   |         ++++++++++    +
429
430error[E0308]: mismatched types
431  --> $DIR/numeric-cast-binop.rs:98:16
432   |
433LL |         x_i8 > x_i128;
434   |         ----   ^^^^^^ expected `i8`, found `i128`
435   |         |
436   |         expected because this is `i8`
437   |
438help: you can convert `x_i8` from `i8` to `i128`, matching the type of `x_i128`
439   |
440LL |         i128::from(x_i8) > x_i128;
441   |         +++++++++++    +
442
443error[E0308]: mismatched types
444  --> $DIR/numeric-cast-binop.rs:100:16
445   |
446LL |         x_i8 > x_isize;
447   |         ----   ^^^^^^^ expected `i8`, found `isize`
448   |         |
449   |         expected because this is `i8`
450   |
451help: you can convert `x_i8` from `i8` to `isize`, matching the type of `x_isize`
452   |
453LL |         isize::from(x_i8) > x_isize;
454   |         ++++++++++++    +
455
456error[E0308]: mismatched types
457  --> $DIR/numeric-cast-binop.rs:103:17
458   |
459LL |         x_i16 > x_i8;
460   |         -----   ^^^^ expected `i16`, found `i8`
461   |         |
462   |         expected because this is `i16`
463   |
464help: you can convert an `i8` to an `i16`
465   |
466LL |         x_i16 > x_i8.into();
467   |                     +++++++
468
469error[E0308]: mismatched types
470  --> $DIR/numeric-cast-binop.rs:105:17
471   |
472LL |         x_i16 > x_i32;
473   |         -----   ^^^^^ expected `i16`, found `i32`
474   |         |
475   |         expected because this is `i16`
476   |
477help: you can convert `x_i16` from `i16` to `i32`, matching the type of `x_i32`
478   |
479LL |         i32::from(x_i16) > x_i32;
480   |         ++++++++++     +
481
482error[E0308]: mismatched types
483  --> $DIR/numeric-cast-binop.rs:107:17
484   |
485LL |         x_i16 > x_i64;
486   |         -----   ^^^^^ expected `i16`, found `i64`
487   |         |
488   |         expected because this is `i16`
489   |
490help: you can convert `x_i16` from `i16` to `i64`, matching the type of `x_i64`
491   |
492LL |         i64::from(x_i16) > x_i64;
493   |         ++++++++++     +
494
495error[E0308]: mismatched types
496  --> $DIR/numeric-cast-binop.rs:109:17
497   |
498LL |         x_i16 > x_i128;
499   |         -----   ^^^^^^ expected `i16`, found `i128`
500   |         |
501   |         expected because this is `i16`
502   |
503help: you can convert `x_i16` from `i16` to `i128`, matching the type of `x_i128`
504   |
505LL |         i128::from(x_i16) > x_i128;
506   |         +++++++++++     +
507
508error[E0308]: mismatched types
509  --> $DIR/numeric-cast-binop.rs:111:17
510   |
511LL |         x_i16 > x_isize;
512   |         -----   ^^^^^^^ expected `i16`, found `isize`
513   |         |
514   |         expected because this is `i16`
515   |
516help: you can convert `x_i16` from `i16` to `isize`, matching the type of `x_isize`
517   |
518LL |         isize::from(x_i16) > x_isize;
519   |         ++++++++++++     +
520
521error[E0308]: mismatched types
522  --> $DIR/numeric-cast-binop.rs:114:17
523   |
524LL |         x_i32 > x_i8;
525   |         -----   ^^^^ expected `i32`, found `i8`
526   |         |
527   |         expected because this is `i32`
528   |
529help: you can convert an `i8` to an `i32`
530   |
531LL |         x_i32 > x_i8.into();
532   |                     +++++++
533
534error[E0308]: mismatched types
535  --> $DIR/numeric-cast-binop.rs:116:17
536   |
537LL |         x_i32 > x_i16;
538   |         -----   ^^^^^ expected `i32`, found `i16`
539   |         |
540   |         expected because this is `i32`
541   |
542help: you can convert an `i16` to an `i32`
543   |
544LL |         x_i32 > x_i16.into();
545   |                      +++++++
546
547error[E0308]: mismatched types
548  --> $DIR/numeric-cast-binop.rs:118:17
549   |
550LL |         x_i32 > x_i64;
551   |         -----   ^^^^^ expected `i32`, found `i64`
552   |         |
553   |         expected because this is `i32`
554   |
555help: you can convert `x_i32` from `i32` to `i64`, matching the type of `x_i64`
556   |
557LL |         i64::from(x_i32) > x_i64;
558   |         ++++++++++     +
559
560error[E0308]: mismatched types
561  --> $DIR/numeric-cast-binop.rs:120:17
562   |
563LL |         x_i32 > x_i128;
564   |         -----   ^^^^^^ expected `i32`, found `i128`
565   |         |
566   |         expected because this is `i32`
567   |
568help: you can convert `x_i32` from `i32` to `i128`, matching the type of `x_i128`
569   |
570LL |         i128::from(x_i32) > x_i128;
571   |         +++++++++++     +
572
573error[E0308]: mismatched types
574  --> $DIR/numeric-cast-binop.rs:122:17
575   |
576LL |         x_i32 > x_isize;
577   |         -----   ^^^^^^^ expected `i32`, found `isize`
578   |         |
579   |         expected because this is `i32`
580   |
581help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
582   |
583LL |         x_i32 > x_isize.try_into().unwrap();
584   |                        ++++++++++++++++++++
585
586error[E0308]: mismatched types
587  --> $DIR/numeric-cast-binop.rs:125:17
588   |
589LL |         x_i64 > x_i8;
590   |         -----   ^^^^ expected `i64`, found `i8`
591   |         |
592   |         expected because this is `i64`
593   |
594help: you can convert an `i8` to an `i64`
595   |
596LL |         x_i64 > x_i8.into();
597   |                     +++++++
598
599error[E0308]: mismatched types
600  --> $DIR/numeric-cast-binop.rs:127:17
601   |
602LL |         x_i64 > x_i16;
603   |         -----   ^^^^^ expected `i64`, found `i16`
604   |         |
605   |         expected because this is `i64`
606   |
607help: you can convert an `i16` to an `i64`
608   |
609LL |         x_i64 > x_i16.into();
610   |                      +++++++
611
612error[E0308]: mismatched types
613  --> $DIR/numeric-cast-binop.rs:129:17
614   |
615LL |         x_i64 > x_i32;
616   |         -----   ^^^^^ expected `i64`, found `i32`
617   |         |
618   |         expected because this is `i64`
619   |
620help: you can convert an `i32` to an `i64`
621   |
622LL |         x_i64 > x_i32.into();
623   |                      +++++++
624
625error[E0308]: mismatched types
626  --> $DIR/numeric-cast-binop.rs:131:17
627   |
628LL |         x_i64 > x_i128;
629   |         -----   ^^^^^^ expected `i64`, found `i128`
630   |         |
631   |         expected because this is `i64`
632   |
633help: you can convert `x_i64` from `i64` to `i128`, matching the type of `x_i128`
634   |
635LL |         i128::from(x_i64) > x_i128;
636   |         +++++++++++     +
637
638error[E0308]: mismatched types
639  --> $DIR/numeric-cast-binop.rs:133:17
640   |
641LL |         x_i64 > x_isize;
642   |         -----   ^^^^^^^ expected `i64`, found `isize`
643   |         |
644   |         expected because this is `i64`
645   |
646help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
647   |
648LL |         x_i64 > x_isize.try_into().unwrap();
649   |                        ++++++++++++++++++++
650
651error[E0308]: mismatched types
652  --> $DIR/numeric-cast-binop.rs:136:18
653   |
654LL |         x_i128 > x_i8;
655   |         ------   ^^^^ expected `i128`, found `i8`
656   |         |
657   |         expected because this is `i128`
658   |
659help: you can convert an `i8` to an `i128`
660   |
661LL |         x_i128 > x_i8.into();
662   |                      +++++++
663
664error[E0308]: mismatched types
665  --> $DIR/numeric-cast-binop.rs:138:18
666   |
667LL |         x_i128 > x_i16;
668   |         ------   ^^^^^ expected `i128`, found `i16`
669   |         |
670   |         expected because this is `i128`
671   |
672help: you can convert an `i16` to an `i128`
673   |
674LL |         x_i128 > x_i16.into();
675   |                       +++++++
676
677error[E0308]: mismatched types
678  --> $DIR/numeric-cast-binop.rs:140:18
679   |
680LL |         x_i128 > x_i32;
681   |         ------   ^^^^^ expected `i128`, found `i32`
682   |         |
683   |         expected because this is `i128`
684   |
685help: you can convert an `i32` to an `i128`
686   |
687LL |         x_i128 > x_i32.into();
688   |                       +++++++
689
690error[E0308]: mismatched types
691  --> $DIR/numeric-cast-binop.rs:142:18
692   |
693LL |         x_i128 > x_i64;
694   |         ------   ^^^^^ expected `i128`, found `i64`
695   |         |
696   |         expected because this is `i128`
697   |
698help: you can convert an `i64` to an `i128`
699   |
700LL |         x_i128 > x_i64.into();
701   |                       +++++++
702
703error[E0308]: mismatched types
704  --> $DIR/numeric-cast-binop.rs:144:18
705   |
706LL |         x_i128 > x_isize;
707   |         ------   ^^^^^^^ expected `i128`, found `isize`
708   |         |
709   |         expected because this is `i128`
710   |
711help: you can convert an `isize` to an `i128` and panic if the converted value doesn't fit
712   |
713LL |         x_i128 > x_isize.try_into().unwrap();
714   |                         ++++++++++++++++++++
715
716error[E0308]: mismatched types
717  --> $DIR/numeric-cast-binop.rs:147:19
718   |
719LL |         x_isize > x_i8;
720   |         -------   ^^^^ expected `isize`, found `i8`
721   |         |
722   |         expected because this is `isize`
723   |
724help: you can convert an `i8` to an `isize`
725   |
726LL |         x_isize > x_i8.into();
727   |                       +++++++
728
729error[E0308]: mismatched types
730  --> $DIR/numeric-cast-binop.rs:149:19
731   |
732LL |         x_isize > x_i16;
733   |         -------   ^^^^^ expected `isize`, found `i16`
734   |         |
735   |         expected because this is `isize`
736   |
737help: you can convert an `i16` to an `isize`
738   |
739LL |         x_isize > x_i16.into();
740   |                        +++++++
741
742error[E0308]: mismatched types
743  --> $DIR/numeric-cast-binop.rs:151:19
744   |
745LL |         x_isize > x_i32;
746   |         -------   ^^^^^ expected `isize`, found `i32`
747   |         |
748   |         expected because this is `isize`
749   |
750help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
751   |
752LL |         x_isize > x_i32.try_into().unwrap();
753   |                        ++++++++++++++++++++
754
755error[E0308]: mismatched types
756  --> $DIR/numeric-cast-binop.rs:153:19
757   |
758LL |         x_isize > x_i64;
759   |         -------   ^^^^^ expected `isize`, found `i64`
760   |         |
761   |         expected because this is `isize`
762   |
763help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
764   |
765LL |         x_isize > x_i64.try_into().unwrap();
766   |                        ++++++++++++++++++++
767
768error[E0308]: mismatched types
769  --> $DIR/numeric-cast-binop.rs:155:19
770   |
771LL |         x_isize > x_i128;
772   |         -------   ^^^^^^ expected `isize`, found `i128`
773   |         |
774   |         expected because this is `isize`
775   |
776help: you can convert an `i128` to an `isize` and panic if the converted value doesn't fit
777   |
778LL |         x_isize > x_i128.try_into().unwrap();
779   |                         ++++++++++++++++++++
780
781error[E0308]: mismatched types
782  --> $DIR/numeric-cast-binop.rs:161:16
783   |
784LL |         x_u8 > x_i8;
785   |         ----   ^^^^ expected `u8`, found `i8`
786   |         |
787   |         expected because this is `u8`
788   |
789help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit
790   |
791LL |         x_u8 > x_i8.try_into().unwrap();
792   |                    ++++++++++++++++++++
793
794error[E0308]: mismatched types
795  --> $DIR/numeric-cast-binop.rs:163:16
796   |
797LL |         x_u8 > x_i16;
798   |         ----   ^^^^^ expected `u8`, found `i16`
799   |         |
800   |         expected because this is `u8`
801   |
802help: you can convert `x_u8` from `u8` to `i16`, matching the type of `x_i16`
803   |
804LL |         i16::from(x_u8) > x_i16;
805   |         ++++++++++    +
806
807error[E0308]: mismatched types
808  --> $DIR/numeric-cast-binop.rs:165:16
809   |
810LL |         x_u8 > x_i32;
811   |         ----   ^^^^^ expected `u8`, found `i32`
812   |         |
813   |         expected because this is `u8`
814   |
815help: you can convert `x_u8` from `u8` to `i32`, matching the type of `x_i32`
816   |
817LL |         i32::from(x_u8) > x_i32;
818   |         ++++++++++    +
819
820error[E0308]: mismatched types
821  --> $DIR/numeric-cast-binop.rs:167:16
822   |
823LL |         x_u8 > x_i64;
824   |         ----   ^^^^^ expected `u8`, found `i64`
825   |         |
826   |         expected because this is `u8`
827   |
828help: you can convert `x_u8` from `u8` to `i64`, matching the type of `x_i64`
829   |
830LL |         i64::from(x_u8) > x_i64;
831   |         ++++++++++    +
832
833error[E0308]: mismatched types
834  --> $DIR/numeric-cast-binop.rs:169:16
835   |
836LL |         x_u8 > x_i128;
837   |         ----   ^^^^^^ expected `u8`, found `i128`
838   |         |
839   |         expected because this is `u8`
840   |
841help: you can convert `x_u8` from `u8` to `i128`, matching the type of `x_i128`
842   |
843LL |         i128::from(x_u8) > x_i128;
844   |         +++++++++++    +
845
846error[E0308]: mismatched types
847  --> $DIR/numeric-cast-binop.rs:171:16
848   |
849LL |         x_u8 > x_isize;
850   |         ----   ^^^^^^^ expected `u8`, found `isize`
851   |         |
852   |         expected because this is `u8`
853   |
854help: you can convert `x_u8` from `u8` to `isize`, matching the type of `x_isize`
855   |
856LL |         isize::from(x_u8) > x_isize;
857   |         ++++++++++++    +
858
859error[E0308]: mismatched types
860  --> $DIR/numeric-cast-binop.rs:174:17
861   |
862LL |         x_u16 > x_i8;
863   |         -----   ^^^^ expected `u16`, found `i8`
864   |         |
865   |         expected because this is `u16`
866   |
867help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit
868   |
869LL |         x_u16 > x_i8.try_into().unwrap();
870   |                     ++++++++++++++++++++
871
872error[E0308]: mismatched types
873  --> $DIR/numeric-cast-binop.rs:176:17
874   |
875LL |         x_u16 > x_i16;
876   |         -----   ^^^^^ expected `u16`, found `i16`
877   |         |
878   |         expected because this is `u16`
879   |
880help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit
881   |
882LL |         x_u16 > x_i16.try_into().unwrap();
883   |                      ++++++++++++++++++++
884
885error[E0308]: mismatched types
886  --> $DIR/numeric-cast-binop.rs:178:17
887   |
888LL |         x_u16 > x_i32;
889   |         -----   ^^^^^ expected `u16`, found `i32`
890   |         |
891   |         expected because this is `u16`
892   |
893help: you can convert `x_u16` from `u16` to `i32`, matching the type of `x_i32`
894   |
895LL |         i32::from(x_u16) > x_i32;
896   |         ++++++++++     +
897
898error[E0308]: mismatched types
899  --> $DIR/numeric-cast-binop.rs:180:17
900   |
901LL |         x_u16 > x_i64;
902   |         -----   ^^^^^ expected `u16`, found `i64`
903   |         |
904   |         expected because this is `u16`
905   |
906help: you can convert `x_u16` from `u16` to `i64`, matching the type of `x_i64`
907   |
908LL |         i64::from(x_u16) > x_i64;
909   |         ++++++++++     +
910
911error[E0308]: mismatched types
912  --> $DIR/numeric-cast-binop.rs:182:17
913   |
914LL |         x_u16 > x_i128;
915   |         -----   ^^^^^^ expected `u16`, found `i128`
916   |         |
917   |         expected because this is `u16`
918   |
919help: you can convert `x_u16` from `u16` to `i128`, matching the type of `x_i128`
920   |
921LL |         i128::from(x_u16) > x_i128;
922   |         +++++++++++     +
923
924error[E0308]: mismatched types
925  --> $DIR/numeric-cast-binop.rs:184:17
926   |
927LL |         x_u16 > x_isize;
928   |         -----   ^^^^^^^ expected `u16`, found `isize`
929   |         |
930   |         expected because this is `u16`
931   |
932help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit
933   |
934LL |         x_u16 > x_isize.try_into().unwrap();
935   |                        ++++++++++++++++++++
936
937error[E0308]: mismatched types
938  --> $DIR/numeric-cast-binop.rs:187:17
939   |
940LL |         x_u32 > x_i8;
941   |         -----   ^^^^ expected `u32`, found `i8`
942   |         |
943   |         expected because this is `u32`
944   |
945help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit
946   |
947LL |         x_u32 > x_i8.try_into().unwrap();
948   |                     ++++++++++++++++++++
949
950error[E0308]: mismatched types
951  --> $DIR/numeric-cast-binop.rs:189:17
952   |
953LL |         x_u32 > x_i16;
954   |         -----   ^^^^^ expected `u32`, found `i16`
955   |         |
956   |         expected because this is `u32`
957   |
958help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit
959   |
960LL |         x_u32 > x_i16.try_into().unwrap();
961   |                      ++++++++++++++++++++
962
963error[E0308]: mismatched types
964  --> $DIR/numeric-cast-binop.rs:191:17
965   |
966LL |         x_u32 > x_i32;
967   |         -----   ^^^^^ expected `u32`, found `i32`
968   |         |
969   |         expected because this is `u32`
970   |
971help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit
972   |
973LL |         x_u32 > x_i32.try_into().unwrap();
974   |                      ++++++++++++++++++++
975
976error[E0308]: mismatched types
977  --> $DIR/numeric-cast-binop.rs:193:17
978   |
979LL |         x_u32 > x_i64;
980   |         -----   ^^^^^ expected `u32`, found `i64`
981   |         |
982   |         expected because this is `u32`
983   |
984help: you can convert `x_u32` from `u32` to `i64`, matching the type of `x_i64`
985   |
986LL |         i64::from(x_u32) > x_i64;
987   |         ++++++++++     +
988
989error[E0308]: mismatched types
990  --> $DIR/numeric-cast-binop.rs:195:17
991   |
992LL |         x_u32 > x_i128;
993   |         -----   ^^^^^^ expected `u32`, found `i128`
994   |         |
995   |         expected because this is `u32`
996   |
997help: you can convert `x_u32` from `u32` to `i128`, matching the type of `x_i128`
998   |
999LL |         i128::from(x_u32) > x_i128;
1000   |         +++++++++++     +
1001
1002error[E0308]: mismatched types
1003  --> $DIR/numeric-cast-binop.rs:197:17
1004   |
1005LL |         x_u32 > x_isize;
1006   |         -----   ^^^^^^^ expected `u32`, found `isize`
1007   |         |
1008   |         expected because this is `u32`
1009   |
1010help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit
1011   |
1012LL |         x_u32 > x_isize.try_into().unwrap();
1013   |                        ++++++++++++++++++++
1014
1015error[E0308]: mismatched types
1016  --> $DIR/numeric-cast-binop.rs:200:17
1017   |
1018LL |         x_u64 > x_i8;
1019   |         -----   ^^^^ expected `u64`, found `i8`
1020   |         |
1021   |         expected because this is `u64`
1022   |
1023help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit
1024   |
1025LL |         x_u64 > x_i8.try_into().unwrap();
1026   |                     ++++++++++++++++++++
1027
1028error[E0308]: mismatched types
1029  --> $DIR/numeric-cast-binop.rs:202:17
1030   |
1031LL |         x_u64 > x_i16;
1032   |         -----   ^^^^^ expected `u64`, found `i16`
1033   |         |
1034   |         expected because this is `u64`
1035   |
1036help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit
1037   |
1038LL |         x_u64 > x_i16.try_into().unwrap();
1039   |                      ++++++++++++++++++++
1040
1041error[E0308]: mismatched types
1042  --> $DIR/numeric-cast-binop.rs:204:17
1043   |
1044LL |         x_u64 > x_i32;
1045   |         -----   ^^^^^ expected `u64`, found `i32`
1046   |         |
1047   |         expected because this is `u64`
1048   |
1049help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit
1050   |
1051LL |         x_u64 > x_i32.try_into().unwrap();
1052   |                      ++++++++++++++++++++
1053
1054error[E0308]: mismatched types
1055  --> $DIR/numeric-cast-binop.rs:206:17
1056   |
1057LL |         x_u64 > x_i64;
1058   |         -----   ^^^^^ expected `u64`, found `i64`
1059   |         |
1060   |         expected because this is `u64`
1061   |
1062help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit
1063   |
1064LL |         x_u64 > x_i64.try_into().unwrap();
1065   |                      ++++++++++++++++++++
1066
1067error[E0308]: mismatched types
1068  --> $DIR/numeric-cast-binop.rs:208:17
1069   |
1070LL |         x_u64 > x_i128;
1071   |         -----   ^^^^^^ expected `u64`, found `i128`
1072   |         |
1073   |         expected because this is `u64`
1074   |
1075help: you can convert `x_u64` from `u64` to `i128`, matching the type of `x_i128`
1076   |
1077LL |         i128::from(x_u64) > x_i128;
1078   |         +++++++++++     +
1079
1080error[E0308]: mismatched types
1081  --> $DIR/numeric-cast-binop.rs:210:17
1082   |
1083LL |         x_u64 > x_isize;
1084   |         -----   ^^^^^^^ expected `u64`, found `isize`
1085   |         |
1086   |         expected because this is `u64`
1087   |
1088help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit
1089   |
1090LL |         x_u64 > x_isize.try_into().unwrap();
1091   |                        ++++++++++++++++++++
1092
1093error[E0308]: mismatched types
1094  --> $DIR/numeric-cast-binop.rs:213:18
1095   |
1096LL |         x_u128 > x_i8;
1097   |         ------   ^^^^ expected `u128`, found `i8`
1098   |         |
1099   |         expected because this is `u128`
1100   |
1101help: you can convert an `i8` to a `u128` and panic if the converted value doesn't fit
1102   |
1103LL |         x_u128 > x_i8.try_into().unwrap();
1104   |                      ++++++++++++++++++++
1105
1106error[E0308]: mismatched types
1107  --> $DIR/numeric-cast-binop.rs:215:18
1108   |
1109LL |         x_u128 > x_i16;
1110   |         ------   ^^^^^ expected `u128`, found `i16`
1111   |         |
1112   |         expected because this is `u128`
1113   |
1114help: you can convert an `i16` to a `u128` and panic if the converted value doesn't fit
1115   |
1116LL |         x_u128 > x_i16.try_into().unwrap();
1117   |                       ++++++++++++++++++++
1118
1119error[E0308]: mismatched types
1120  --> $DIR/numeric-cast-binop.rs:217:18
1121   |
1122LL |         x_u128 > x_i32;
1123   |         ------   ^^^^^ expected `u128`, found `i32`
1124   |         |
1125   |         expected because this is `u128`
1126   |
1127help: you can convert an `i32` to a `u128` and panic if the converted value doesn't fit
1128   |
1129LL |         x_u128 > x_i32.try_into().unwrap();
1130   |                       ++++++++++++++++++++
1131
1132error[E0308]: mismatched types
1133  --> $DIR/numeric-cast-binop.rs:219:18
1134   |
1135LL |         x_u128 > x_i64;
1136   |         ------   ^^^^^ expected `u128`, found `i64`
1137   |         |
1138   |         expected because this is `u128`
1139   |
1140help: you can convert an `i64` to a `u128` and panic if the converted value doesn't fit
1141   |
1142LL |         x_u128 > x_i64.try_into().unwrap();
1143   |                       ++++++++++++++++++++
1144
1145error[E0308]: mismatched types
1146  --> $DIR/numeric-cast-binop.rs:221:18
1147   |
1148LL |         x_u128 > x_i128;
1149   |         ------   ^^^^^^ expected `u128`, found `i128`
1150   |         |
1151   |         expected because this is `u128`
1152   |
1153help: you can convert an `i128` to a `u128` and panic if the converted value doesn't fit
1154   |
1155LL |         x_u128 > x_i128.try_into().unwrap();
1156   |                        ++++++++++++++++++++
1157
1158error[E0308]: mismatched types
1159  --> $DIR/numeric-cast-binop.rs:223:18
1160   |
1161LL |         x_u128 > x_isize;
1162   |         ------   ^^^^^^^ expected `u128`, found `isize`
1163   |         |
1164   |         expected because this is `u128`
1165   |
1166help: you can convert an `isize` to a `u128` and panic if the converted value doesn't fit
1167   |
1168LL |         x_u128 > x_isize.try_into().unwrap();
1169   |                         ++++++++++++++++++++
1170
1171error[E0308]: mismatched types
1172  --> $DIR/numeric-cast-binop.rs:226:19
1173   |
1174LL |         x_usize > x_i8;
1175   |         -------   ^^^^ expected `usize`, found `i8`
1176   |         |
1177   |         expected because this is `usize`
1178   |
1179help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit
1180   |
1181LL |         x_usize > x_i8.try_into().unwrap();
1182   |                       ++++++++++++++++++++
1183
1184error[E0308]: mismatched types
1185  --> $DIR/numeric-cast-binop.rs:228:19
1186   |
1187LL |         x_usize > x_i16;
1188   |         -------   ^^^^^ expected `usize`, found `i16`
1189   |         |
1190   |         expected because this is `usize`
1191   |
1192help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit
1193   |
1194LL |         x_usize > x_i16.try_into().unwrap();
1195   |                        ++++++++++++++++++++
1196
1197error[E0308]: mismatched types
1198  --> $DIR/numeric-cast-binop.rs:230:19
1199   |
1200LL |         x_usize > x_i32;
1201   |         -------   ^^^^^ expected `usize`, found `i32`
1202   |         |
1203   |         expected because this is `usize`
1204   |
1205help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit
1206   |
1207LL |         x_usize > x_i32.try_into().unwrap();
1208   |                        ++++++++++++++++++++
1209
1210error[E0308]: mismatched types
1211  --> $DIR/numeric-cast-binop.rs:232:19
1212   |
1213LL |         x_usize > x_i64;
1214   |         -------   ^^^^^ expected `usize`, found `i64`
1215   |         |
1216   |         expected because this is `usize`
1217   |
1218help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit
1219   |
1220LL |         x_usize > x_i64.try_into().unwrap();
1221   |                        ++++++++++++++++++++
1222
1223error[E0308]: mismatched types
1224  --> $DIR/numeric-cast-binop.rs:234:19
1225   |
1226LL |         x_usize > x_i128;
1227   |         -------   ^^^^^^ expected `usize`, found `i128`
1228   |         |
1229   |         expected because this is `usize`
1230   |
1231help: you can convert an `i128` to a `usize` and panic if the converted value doesn't fit
1232   |
1233LL |         x_usize > x_i128.try_into().unwrap();
1234   |                         ++++++++++++++++++++
1235
1236error[E0308]: mismatched types
1237  --> $DIR/numeric-cast-binop.rs:236:19
1238   |
1239LL |         x_usize > x_isize;
1240   |         -------   ^^^^^^^ expected `usize`, found `isize`
1241   |         |
1242   |         expected because this is `usize`
1243   |
1244help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit
1245   |
1246LL |         x_usize > x_isize.try_into().unwrap();
1247   |                          ++++++++++++++++++++
1248
1249error[E0308]: mismatched types
1250  --> $DIR/numeric-cast-binop.rs:242:16
1251   |
1252LL |         x_i8 > x_u8;
1253   |         ----   ^^^^ expected `i8`, found `u8`
1254   |         |
1255   |         expected because this is `i8`
1256   |
1257help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit
1258   |
1259LL |         x_i8 > x_u8.try_into().unwrap();
1260   |                    ++++++++++++++++++++
1261
1262error[E0308]: mismatched types
1263  --> $DIR/numeric-cast-binop.rs:244:16
1264   |
1265LL |         x_i8 > x_u16;
1266   |         ----   ^^^^^ expected `i8`, found `u16`
1267   |         |
1268   |         expected because this is `i8`
1269   |
1270help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit
1271   |
1272LL |         x_i8 > x_u16.try_into().unwrap();
1273   |                     ++++++++++++++++++++
1274
1275error[E0308]: mismatched types
1276  --> $DIR/numeric-cast-binop.rs:246:16
1277   |
1278LL |         x_i8 > x_u32;
1279   |         ----   ^^^^^ expected `i8`, found `u32`
1280   |         |
1281   |         expected because this is `i8`
1282   |
1283help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit
1284   |
1285LL |         x_i8 > x_u32.try_into().unwrap();
1286   |                     ++++++++++++++++++++
1287
1288error[E0308]: mismatched types
1289  --> $DIR/numeric-cast-binop.rs:248:16
1290   |
1291LL |         x_i8 > x_u64;
1292   |         ----   ^^^^^ expected `i8`, found `u64`
1293   |         |
1294   |         expected because this is `i8`
1295   |
1296help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit
1297   |
1298LL |         x_i8 > x_u64.try_into().unwrap();
1299   |                     ++++++++++++++++++++
1300
1301error[E0308]: mismatched types
1302  --> $DIR/numeric-cast-binop.rs:250:16
1303   |
1304LL |         x_i8 > x_u128;
1305   |         ----   ^^^^^^ expected `i8`, found `u128`
1306   |         |
1307   |         expected because this is `i8`
1308   |
1309help: you can convert a `u128` to an `i8` and panic if the converted value doesn't fit
1310   |
1311LL |         x_i8 > x_u128.try_into().unwrap();
1312   |                      ++++++++++++++++++++
1313
1314error[E0308]: mismatched types
1315  --> $DIR/numeric-cast-binop.rs:252:16
1316   |
1317LL |         x_i8 > x_usize;
1318   |         ----   ^^^^^^^ expected `i8`, found `usize`
1319   |         |
1320   |         expected because this is `i8`
1321   |
1322help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit
1323   |
1324LL |         x_i8 > x_usize.try_into().unwrap();
1325   |                       ++++++++++++++++++++
1326
1327error[E0308]: mismatched types
1328  --> $DIR/numeric-cast-binop.rs:255:17
1329   |
1330LL |         x_i16 > x_u8;
1331   |         -----   ^^^^ expected `i16`, found `u8`
1332   |         |
1333   |         expected because this is `i16`
1334   |
1335help: you can convert a `u8` to an `i16`
1336   |
1337LL |         x_i16 > x_u8.into();
1338   |                     +++++++
1339
1340error[E0308]: mismatched types
1341  --> $DIR/numeric-cast-binop.rs:257:17
1342   |
1343LL |         x_i16 > x_u16;
1344   |         -----   ^^^^^ expected `i16`, found `u16`
1345   |         |
1346   |         expected because this is `i16`
1347   |
1348help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit
1349   |
1350LL |         x_i16 > x_u16.try_into().unwrap();
1351   |                      ++++++++++++++++++++
1352
1353error[E0308]: mismatched types
1354  --> $DIR/numeric-cast-binop.rs:259:17
1355   |
1356LL |         x_i16 > x_u32;
1357   |         -----   ^^^^^ expected `i16`, found `u32`
1358   |         |
1359   |         expected because this is `i16`
1360   |
1361help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit
1362   |
1363LL |         x_i16 > x_u32.try_into().unwrap();
1364   |                      ++++++++++++++++++++
1365
1366error[E0308]: mismatched types
1367  --> $DIR/numeric-cast-binop.rs:261:17
1368   |
1369LL |         x_i16 > x_u64;
1370   |         -----   ^^^^^ expected `i16`, found `u64`
1371   |         |
1372   |         expected because this is `i16`
1373   |
1374help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit
1375   |
1376LL |         x_i16 > x_u64.try_into().unwrap();
1377   |                      ++++++++++++++++++++
1378
1379error[E0308]: mismatched types
1380  --> $DIR/numeric-cast-binop.rs:263:17
1381   |
1382LL |         x_i16 > x_u128;
1383   |         -----   ^^^^^^ expected `i16`, found `u128`
1384   |         |
1385   |         expected because this is `i16`
1386   |
1387help: you can convert a `u128` to an `i16` and panic if the converted value doesn't fit
1388   |
1389LL |         x_i16 > x_u128.try_into().unwrap();
1390   |                       ++++++++++++++++++++
1391
1392error[E0308]: mismatched types
1393  --> $DIR/numeric-cast-binop.rs:265:17
1394   |
1395LL |         x_i16 > x_usize;
1396   |         -----   ^^^^^^^ expected `i16`, found `usize`
1397   |         |
1398   |         expected because this is `i16`
1399   |
1400help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit
1401   |
1402LL |         x_i16 > x_usize.try_into().unwrap();
1403   |                        ++++++++++++++++++++
1404
1405error[E0308]: mismatched types
1406  --> $DIR/numeric-cast-binop.rs:268:17
1407   |
1408LL |         x_i32 > x_u8;
1409   |         -----   ^^^^ expected `i32`, found `u8`
1410   |         |
1411   |         expected because this is `i32`
1412   |
1413help: you can convert a `u8` to an `i32`
1414   |
1415LL |         x_i32 > x_u8.into();
1416   |                     +++++++
1417
1418error[E0308]: mismatched types
1419  --> $DIR/numeric-cast-binop.rs:270:17
1420   |
1421LL |         x_i32 > x_u16;
1422   |         -----   ^^^^^ expected `i32`, found `u16`
1423   |         |
1424   |         expected because this is `i32`
1425   |
1426help: you can convert a `u16` to an `i32`
1427   |
1428LL |         x_i32 > x_u16.into();
1429   |                      +++++++
1430
1431error[E0308]: mismatched types
1432  --> $DIR/numeric-cast-binop.rs:272:17
1433   |
1434LL |         x_i32 > x_u32;
1435   |         -----   ^^^^^ expected `i32`, found `u32`
1436   |         |
1437   |         expected because this is `i32`
1438   |
1439help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit
1440   |
1441LL |         x_i32 > x_u32.try_into().unwrap();
1442   |                      ++++++++++++++++++++
1443
1444error[E0308]: mismatched types
1445  --> $DIR/numeric-cast-binop.rs:274:17
1446   |
1447LL |         x_i32 > x_u64;
1448   |         -----   ^^^^^ expected `i32`, found `u64`
1449   |         |
1450   |         expected because this is `i32`
1451   |
1452help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit
1453   |
1454LL |         x_i32 > x_u64.try_into().unwrap();
1455   |                      ++++++++++++++++++++
1456
1457error[E0308]: mismatched types
1458  --> $DIR/numeric-cast-binop.rs:276:17
1459   |
1460LL |         x_i32 > x_u128;
1461   |         -----   ^^^^^^ expected `i32`, found `u128`
1462   |         |
1463   |         expected because this is `i32`
1464   |
1465help: you can convert a `u128` to an `i32` and panic if the converted value doesn't fit
1466   |
1467LL |         x_i32 > x_u128.try_into().unwrap();
1468   |                       ++++++++++++++++++++
1469
1470error[E0308]: mismatched types
1471  --> $DIR/numeric-cast-binop.rs:278:17
1472   |
1473LL |         x_i32 > x_usize;
1474   |         -----   ^^^^^^^ expected `i32`, found `usize`
1475   |         |
1476   |         expected because this is `i32`
1477   |
1478help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit
1479   |
1480LL |         x_i32 > x_usize.try_into().unwrap();
1481   |                        ++++++++++++++++++++
1482
1483error[E0308]: mismatched types
1484  --> $DIR/numeric-cast-binop.rs:281:17
1485   |
1486LL |         x_i64 > x_u8;
1487   |         -----   ^^^^ expected `i64`, found `u8`
1488   |         |
1489   |         expected because this is `i64`
1490   |
1491help: you can convert a `u8` to an `i64`
1492   |
1493LL |         x_i64 > x_u8.into();
1494   |                     +++++++
1495
1496error[E0308]: mismatched types
1497  --> $DIR/numeric-cast-binop.rs:283:17
1498   |
1499LL |         x_i64 > x_u16;
1500   |         -----   ^^^^^ expected `i64`, found `u16`
1501   |         |
1502   |         expected because this is `i64`
1503   |
1504help: you can convert a `u16` to an `i64`
1505   |
1506LL |         x_i64 > x_u16.into();
1507   |                      +++++++
1508
1509error[E0308]: mismatched types
1510  --> $DIR/numeric-cast-binop.rs:285:17
1511   |
1512LL |         x_i64 > x_u32;
1513   |         -----   ^^^^^ expected `i64`, found `u32`
1514   |         |
1515   |         expected because this is `i64`
1516   |
1517help: you can convert a `u32` to an `i64`
1518   |
1519LL |         x_i64 > x_u32.into();
1520   |                      +++++++
1521
1522error[E0308]: mismatched types
1523  --> $DIR/numeric-cast-binop.rs:287:17
1524   |
1525LL |         x_i64 > x_u64;
1526   |         -----   ^^^^^ expected `i64`, found `u64`
1527   |         |
1528   |         expected because this is `i64`
1529   |
1530help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit
1531   |
1532LL |         x_i64 > x_u64.try_into().unwrap();
1533   |                      ++++++++++++++++++++
1534
1535error[E0308]: mismatched types
1536  --> $DIR/numeric-cast-binop.rs:289:17
1537   |
1538LL |         x_i64 > x_u128;
1539   |         -----   ^^^^^^ expected `i64`, found `u128`
1540   |         |
1541   |         expected because this is `i64`
1542   |
1543help: you can convert a `u128` to an `i64` and panic if the converted value doesn't fit
1544   |
1545LL |         x_i64 > x_u128.try_into().unwrap();
1546   |                       ++++++++++++++++++++
1547
1548error[E0308]: mismatched types
1549  --> $DIR/numeric-cast-binop.rs:291:17
1550   |
1551LL |         x_i64 > x_usize;
1552   |         -----   ^^^^^^^ expected `i64`, found `usize`
1553   |         |
1554   |         expected because this is `i64`
1555   |
1556help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit
1557   |
1558LL |         x_i64 > x_usize.try_into().unwrap();
1559   |                        ++++++++++++++++++++
1560
1561error[E0308]: mismatched types
1562  --> $DIR/numeric-cast-binop.rs:294:18
1563   |
1564LL |         x_i128 > x_u8;
1565   |         ------   ^^^^ expected `i128`, found `u8`
1566   |         |
1567   |         expected because this is `i128`
1568   |
1569help: you can convert a `u8` to an `i128`
1570   |
1571LL |         x_i128 > x_u8.into();
1572   |                      +++++++
1573
1574error[E0308]: mismatched types
1575  --> $DIR/numeric-cast-binop.rs:296:18
1576   |
1577LL |         x_i128 > x_u16;
1578   |         ------   ^^^^^ expected `i128`, found `u16`
1579   |         |
1580   |         expected because this is `i128`
1581   |
1582help: you can convert a `u16` to an `i128`
1583   |
1584LL |         x_i128 > x_u16.into();
1585   |                       +++++++
1586
1587error[E0308]: mismatched types
1588  --> $DIR/numeric-cast-binop.rs:298:18
1589   |
1590LL |         x_i128 > x_u32;
1591   |         ------   ^^^^^ expected `i128`, found `u32`
1592   |         |
1593   |         expected because this is `i128`
1594   |
1595help: you can convert a `u32` to an `i128`
1596   |
1597LL |         x_i128 > x_u32.into();
1598   |                       +++++++
1599
1600error[E0308]: mismatched types
1601  --> $DIR/numeric-cast-binop.rs:300:18
1602   |
1603LL |         x_i128 > x_u64;
1604   |         ------   ^^^^^ expected `i128`, found `u64`
1605   |         |
1606   |         expected because this is `i128`
1607   |
1608help: you can convert a `u64` to an `i128`
1609   |
1610LL |         x_i128 > x_u64.into();
1611   |                       +++++++
1612
1613error[E0308]: mismatched types
1614  --> $DIR/numeric-cast-binop.rs:302:18
1615   |
1616LL |         x_i128 > x_u128;
1617   |         ------   ^^^^^^ expected `i128`, found `u128`
1618   |         |
1619   |         expected because this is `i128`
1620   |
1621help: you can convert a `u128` to an `i128` and panic if the converted value doesn't fit
1622   |
1623LL |         x_i128 > x_u128.try_into().unwrap();
1624   |                        ++++++++++++++++++++
1625
1626error[E0308]: mismatched types
1627  --> $DIR/numeric-cast-binop.rs:304:18
1628   |
1629LL |         x_i128 > x_usize;
1630   |         ------   ^^^^^^^ expected `i128`, found `usize`
1631   |         |
1632   |         expected because this is `i128`
1633   |
1634help: you can convert a `usize` to an `i128` and panic if the converted value doesn't fit
1635   |
1636LL |         x_i128 > x_usize.try_into().unwrap();
1637   |                         ++++++++++++++++++++
1638
1639error[E0308]: mismatched types
1640  --> $DIR/numeric-cast-binop.rs:307:19
1641   |
1642LL |         x_isize > x_u8;
1643   |         -------   ^^^^ expected `isize`, found `u8`
1644   |         |
1645   |         expected because this is `isize`
1646   |
1647help: you can convert a `u8` to an `isize`
1648   |
1649LL |         x_isize > x_u8.into();
1650   |                       +++++++
1651
1652error[E0308]: mismatched types
1653  --> $DIR/numeric-cast-binop.rs:309:19
1654   |
1655LL |         x_isize > x_u16;
1656   |         -------   ^^^^^ expected `isize`, found `u16`
1657   |         |
1658   |         expected because this is `isize`
1659   |
1660help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit
1661   |
1662LL |         x_isize > x_u16.try_into().unwrap();
1663   |                        ++++++++++++++++++++
1664
1665error[E0308]: mismatched types
1666  --> $DIR/numeric-cast-binop.rs:311:19
1667   |
1668LL |         x_isize > x_u32;
1669   |         -------   ^^^^^ expected `isize`, found `u32`
1670   |         |
1671   |         expected because this is `isize`
1672   |
1673help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit
1674   |
1675LL |         x_isize > x_u32.try_into().unwrap();
1676   |                        ++++++++++++++++++++
1677
1678error[E0308]: mismatched types
1679  --> $DIR/numeric-cast-binop.rs:313:19
1680   |
1681LL |         x_isize > x_u64;
1682   |         -------   ^^^^^ expected `isize`, found `u64`
1683   |         |
1684   |         expected because this is `isize`
1685   |
1686help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit
1687   |
1688LL |         x_isize > x_u64.try_into().unwrap();
1689   |                        ++++++++++++++++++++
1690
1691error[E0308]: mismatched types
1692  --> $DIR/numeric-cast-binop.rs:315:19
1693   |
1694LL |         x_isize > x_u128;
1695   |         -------   ^^^^^^ expected `isize`, found `u128`
1696   |         |
1697   |         expected because this is `isize`
1698   |
1699help: you can convert a `u128` to an `isize` and panic if the converted value doesn't fit
1700   |
1701LL |         x_isize > x_u128.try_into().unwrap();
1702   |                         ++++++++++++++++++++
1703
1704error[E0308]: mismatched types
1705  --> $DIR/numeric-cast-binop.rs:317:19
1706   |
1707LL |         x_isize > x_usize;
1708   |         -------   ^^^^^^^ expected `isize`, found `usize`
1709   |         |
1710   |         expected because this is `isize`
1711   |
1712help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
1713   |
1714LL |         x_isize > x_usize.try_into().unwrap();
1715   |                          ++++++++++++++++++++
1716
1717error: aborting due to 132 previous errors
1718
1719For more information about this error, try `rustc --explain E0308`.