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