src/test/ui/numeric/numeric-cast-binop.stderr

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