Merging upstream version 1.68.2+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 0 insertions, 939 deletions

diff --git a/src/test/ui/numeric/integer-literal-suffix-inference.stderr b/src/test/ui/numeric/integer-literal-suffix-inference.stderr
deleted file mode 100644
index 5045f584c..000000000
--- a/src/test/ui/numeric/integer-literal-suffix-inference.stderr
+++ /dev/null
@@ -1,939 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:38:11
-   |
-LL |     id_i8(a16);
-   |     ----- ^^^ expected `i8`, found `i16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:15:8
-   |
-LL |     fn id_i8(n: i8) -> i8 { n }
-   |        ^^^^^ -----
-help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
-   |
-LL |     id_i8(a16.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:41:11
-   |
-LL |     id_i8(a32);
-   |     ----- ^^^ expected `i8`, found `i32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:15:8
-   |
-LL |     fn id_i8(n: i8) -> i8 { n }
-   |        ^^^^^ -----
-help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
-   |
-LL |     id_i8(a32.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:44:11
-   |
-LL |     id_i8(a64);
-   |     ----- ^^^ expected `i8`, found `i64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:15:8
-   |
-LL |     fn id_i8(n: i8) -> i8 { n }
-   |        ^^^^^ -----
-help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
-   |
-LL |     id_i8(a64.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:47:11
-   |
-LL |     id_i8(asize);
-   |     ----- ^^^^^ expected `i8`, found `isize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:15:8
-   |
-LL |     fn id_i8(n: i8) -> i8 { n }
-   |        ^^^^^ -----
-help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit
-   |
-LL |     id_i8(asize.try_into().unwrap());
-   |                ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:51:12
-   |
-LL |     id_i16(a8);
-   |     ------ ^^ expected `i16`, found `i8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:16:8
-   |
-LL |     fn id_i16(n: i16) -> i16 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i8` to an `i16`
-   |
-LL |     id_i16(a8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:55:12
-   |
-LL |     id_i16(a32);
-   |     ------ ^^^ expected `i16`, found `i32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:16:8
-   |
-LL |     fn id_i16(n: i16) -> i16 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
-   |
-LL |     id_i16(a32.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:58:12
-   |
-LL |     id_i16(a64);
-   |     ------ ^^^ expected `i16`, found `i64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:16:8
-   |
-LL |     fn id_i16(n: i16) -> i16 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
-   |
-LL |     id_i16(a64.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:61:12
-   |
-LL |     id_i16(asize);
-   |     ------ ^^^^^ expected `i16`, found `isize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:16:8
-   |
-LL |     fn id_i16(n: i16) -> i16 { n }
-   |        ^^^^^^ ------
-help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
-   |
-LL |     id_i16(asize.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:65:12
-   |
-LL |     id_i32(a8);
-   |     ------ ^^ expected `i32`, found `i8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:17:8
-   |
-LL |     fn id_i32(n: i32) -> i32 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i8` to an `i32`
-   |
-LL |     id_i32(a8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:68:12
-   |
-LL |     id_i32(a16);
-   |     ------ ^^^ expected `i32`, found `i16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:17:8
-   |
-LL |     fn id_i32(n: i32) -> i32 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i16` to an `i32`
-   |
-LL |     id_i32(a16.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:72:12
-   |
-LL |     id_i32(a64);
-   |     ------ ^^^ expected `i32`, found `i64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:17:8
-   |
-LL |     fn id_i32(n: i32) -> i32 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
-   |
-LL |     id_i32(a64.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:75:12
-   |
-LL |     id_i32(asize);
-   |     ------ ^^^^^ expected `i32`, found `isize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:17:8
-   |
-LL |     fn id_i32(n: i32) -> i32 { n }
-   |        ^^^^^^ ------
-help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
-   |
-LL |     id_i32(asize.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:79:12
-   |
-LL |     id_i64(a8);
-   |     ------ ^^ expected `i64`, found `i8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:18:8
-   |
-LL |     fn id_i64(n: i64) -> i64 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i8` to an `i64`
-   |
-LL |     id_i64(a8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:82:12
-   |
-LL |     id_i64(a16);
-   |     ------ ^^^ expected `i64`, found `i16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:18:8
-   |
-LL |     fn id_i64(n: i64) -> i64 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i16` to an `i64`
-   |
-LL |     id_i64(a16.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:85:12
-   |
-LL |     id_i64(a32);
-   |     ------ ^^^ expected `i64`, found `i32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:18:8
-   |
-LL |     fn id_i64(n: i64) -> i64 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i32` to an `i64`
-   |
-LL |     id_i64(a32.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:89:12
-   |
-LL |     id_i64(asize);
-   |     ------ ^^^^^ expected `i64`, found `isize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:18:8
-   |
-LL |     fn id_i64(n: i64) -> i64 { n }
-   |        ^^^^^^ ------
-help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
-   |
-LL |     id_i64(asize.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:93:14
-   |
-LL |     id_isize(a8);
-   |     -------- ^^ expected `isize`, found `i8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:19:8
-   |
-LL |     fn id_isize(n: isize) -> isize { n }
-   |        ^^^^^^^^ --------
-help: you can convert an `i8` to an `isize`
-   |
-LL |     id_isize(a8.into());
-   |                +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:96:14
-   |
-LL |     id_isize(a16);
-   |     -------- ^^^ expected `isize`, found `i16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:19:8
-   |
-LL |     fn id_isize(n: isize) -> isize { n }
-   |        ^^^^^^^^ --------
-help: you can convert an `i16` to an `isize`
-   |
-LL |     id_isize(a16.into());
-   |                 +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:99:14
-   |
-LL |     id_isize(a32);
-   |     -------- ^^^ expected `isize`, found `i32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:19:8
-   |
-LL |     fn id_isize(n: isize) -> isize { n }
-   |        ^^^^^^^^ --------
-help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
-   |
-LL |     id_isize(a32.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:102:14
-   |
-LL |     id_isize(a64);
-   |     -------- ^^^ expected `isize`, found `i64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:19:8
-   |
-LL |     fn id_isize(n: isize) -> isize { n }
-   |        ^^^^^^^^ --------
-help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
-   |
-LL |     id_isize(a64.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:108:11
-   |
-LL |     id_i8(c16);
-   |     ----- ^^^ expected `i8`, found `i16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:15:8
-   |
-LL |     fn id_i8(n: i8) -> i8 { n }
-   |        ^^^^^ -----
-help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
-   |
-LL |     id_i8(c16.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:111:11
-   |
-LL |     id_i8(c32);
-   |     ----- ^^^ expected `i8`, found `i32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:15:8
-   |
-LL |     fn id_i8(n: i8) -> i8 { n }
-   |        ^^^^^ -----
-help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
-   |
-LL |     id_i8(c32.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:114:11
-   |
-LL |     id_i8(c64);
-   |     ----- ^^^ expected `i8`, found `i64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:15:8
-   |
-LL |     fn id_i8(n: i8) -> i8 { n }
-   |        ^^^^^ -----
-help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
-   |
-LL |     id_i8(c64.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:118:12
-   |
-LL |     id_i16(c8);
-   |     ------ ^^ expected `i16`, found `i8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:16:8
-   |
-LL |     fn id_i16(n: i16) -> i16 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i8` to an `i16`
-   |
-LL |     id_i16(c8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:122:12
-   |
-LL |     id_i16(c32);
-   |     ------ ^^^ expected `i16`, found `i32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:16:8
-   |
-LL |     fn id_i16(n: i16) -> i16 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
-   |
-LL |     id_i16(c32.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:125:12
-   |
-LL |     id_i16(c64);
-   |     ------ ^^^ expected `i16`, found `i64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:16:8
-   |
-LL |     fn id_i16(n: i16) -> i16 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
-   |
-LL |     id_i16(c64.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:129:12
-   |
-LL |     id_i32(c8);
-   |     ------ ^^ expected `i32`, found `i8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:17:8
-   |
-LL |     fn id_i32(n: i32) -> i32 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i8` to an `i32`
-   |
-LL |     id_i32(c8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:132:12
-   |
-LL |     id_i32(c16);
-   |     ------ ^^^ expected `i32`, found `i16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:17:8
-   |
-LL |     fn id_i32(n: i32) -> i32 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i16` to an `i32`
-   |
-LL |     id_i32(c16.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:136:12
-   |
-LL |     id_i32(c64);
-   |     ------ ^^^ expected `i32`, found `i64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:17:8
-   |
-LL |     fn id_i32(n: i32) -> i32 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
-   |
-LL |     id_i32(c64.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:140:12
-   |
-LL |     id_i64(a8);
-   |     ------ ^^ expected `i64`, found `i8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:18:8
-   |
-LL |     fn id_i64(n: i64) -> i64 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i8` to an `i64`
-   |
-LL |     id_i64(a8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:143:12
-   |
-LL |     id_i64(a16);
-   |     ------ ^^^ expected `i64`, found `i16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:18:8
-   |
-LL |     fn id_i64(n: i64) -> i64 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i16` to an `i64`
-   |
-LL |     id_i64(a16.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:146:12
-   |
-LL |     id_i64(a32);
-   |     ------ ^^^ expected `i64`, found `i32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:18:8
-   |
-LL |     fn id_i64(n: i64) -> i64 { n }
-   |        ^^^^^^ ------
-help: you can convert an `i32` to an `i64`
-   |
-LL |     id_i64(a32.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:152:11
-   |
-LL |     id_u8(b16);
-   |     ----- ^^^ expected `u8`, found `u16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:27:8
-   |
-LL |     fn id_u8(n: u8) -> u8 { n }
-   |        ^^^^^ -----
-help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit
-   |
-LL |     id_u8(b16.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:155:11
-   |
-LL |     id_u8(b32);
-   |     ----- ^^^ expected `u8`, found `u32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:27:8
-   |
-LL |     fn id_u8(n: u8) -> u8 { n }
-   |        ^^^^^ -----
-help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit
-   |
-LL |     id_u8(b32.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:158:11
-   |
-LL |     id_u8(b64);
-   |     ----- ^^^ expected `u8`, found `u64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:27:8
-   |
-LL |     fn id_u8(n: u8) -> u8 { n }
-   |        ^^^^^ -----
-help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit
-   |
-LL |     id_u8(b64.try_into().unwrap());
-   |              ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:161:11
-   |
-LL |     id_u8(bsize);
-   |     ----- ^^^^^ expected `u8`, found `usize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:27:8
-   |
-LL |     fn id_u8(n: u8) -> u8 { n }
-   |        ^^^^^ -----
-help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit
-   |
-LL |     id_u8(bsize.try_into().unwrap());
-   |                ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:165:12
-   |
-LL |     id_u16(b8);
-   |     ------ ^^ expected `u16`, found `u8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:28:8
-   |
-LL |     fn id_u16(n: u16) -> u16 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u8` to a `u16`
-   |
-LL |     id_u16(b8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:169:12
-   |
-LL |     id_u16(b32);
-   |     ------ ^^^ expected `u16`, found `u32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:28:8
-   |
-LL |     fn id_u16(n: u16) -> u16 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit
-   |
-LL |     id_u16(b32.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:172:12
-   |
-LL |     id_u16(b64);
-   |     ------ ^^^ expected `u16`, found `u64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:28:8
-   |
-LL |     fn id_u16(n: u16) -> u16 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit
-   |
-LL |     id_u16(b64.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:175:12
-   |
-LL |     id_u16(bsize);
-   |     ------ ^^^^^ expected `u16`, found `usize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:28:8
-   |
-LL |     fn id_u16(n: u16) -> u16 { n }
-   |        ^^^^^^ ------
-help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit
-   |
-LL |     id_u16(bsize.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:179:12
-   |
-LL |     id_u32(b8);
-   |     ------ ^^ expected `u32`, found `u8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:29:8
-   |
-LL |     fn id_u32(n: u32) -> u32 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u8` to a `u32`
-   |
-LL |     id_u32(b8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:182:12
-   |
-LL |     id_u32(b16);
-   |     ------ ^^^ expected `u32`, found `u16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:29:8
-   |
-LL |     fn id_u32(n: u32) -> u32 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u16` to a `u32`
-   |
-LL |     id_u32(b16.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:186:12
-   |
-LL |     id_u32(b64);
-   |     ------ ^^^ expected `u32`, found `u64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:29:8
-   |
-LL |     fn id_u32(n: u32) -> u32 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
-   |
-LL |     id_u32(b64.try_into().unwrap());
-   |               ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:189:12
-   |
-LL |     id_u32(bsize);
-   |     ------ ^^^^^ expected `u32`, found `usize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:29:8
-   |
-LL |     fn id_u32(n: u32) -> u32 { n }
-   |        ^^^^^^ ------
-help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
-   |
-LL |     id_u32(bsize.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:193:12
-   |
-LL |     id_u64(b8);
-   |     ------ ^^ expected `u64`, found `u8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:30:8
-   |
-LL |     fn id_u64(n: u64) -> u64 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u8` to a `u64`
-   |
-LL |     id_u64(b8.into());
-   |              +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:196:12
-   |
-LL |     id_u64(b16);
-   |     ------ ^^^ expected `u64`, found `u16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:30:8
-   |
-LL |     fn id_u64(n: u64) -> u64 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u16` to a `u64`
-   |
-LL |     id_u64(b16.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:199:12
-   |
-LL |     id_u64(b32);
-   |     ------ ^^^ expected `u64`, found `u32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:30:8
-   |
-LL |     fn id_u64(n: u64) -> u64 { n }
-   |        ^^^^^^ ------
-help: you can convert a `u32` to a `u64`
-   |
-LL |     id_u64(b32.into());
-   |               +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:203:12
-   |
-LL |     id_u64(bsize);
-   |     ------ ^^^^^ expected `u64`, found `usize`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:30:8
-   |
-LL |     fn id_u64(n: u64) -> u64 { n }
-   |        ^^^^^^ ------
-help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
-   |
-LL |     id_u64(bsize.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:207:14
-   |
-LL |     id_usize(b8);
-   |     -------- ^^ expected `usize`, found `u8`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:31:8
-   |
-LL |     fn id_usize(n: usize) -> usize { n }
-   |        ^^^^^^^^ --------
-help: you can convert a `u8` to a `usize`
-   |
-LL |     id_usize(b8.into());
-   |                +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:210:14
-   |
-LL |     id_usize(b16);
-   |     -------- ^^^ expected `usize`, found `u16`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:31:8
-   |
-LL |     fn id_usize(n: usize) -> usize { n }
-   |        ^^^^^^^^ --------
-help: you can convert a `u16` to a `usize`
-   |
-LL |     id_usize(b16.into());
-   |                 +++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:213:14
-   |
-LL |     id_usize(b32);
-   |     -------- ^^^ expected `usize`, found `u32`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:31:8
-   |
-LL |     fn id_usize(n: usize) -> usize { n }
-   |        ^^^^^^^^ --------
-help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
-   |
-LL |     id_usize(b32.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error[E0308]: mismatched types
-  --> $DIR/integer-literal-suffix-inference.rs:216:14
-   |
-LL |     id_usize(b64);
-   |     -------- ^^^ expected `usize`, found `u64`
-   |     |
-   |     arguments to this function are incorrect
-   |
-note: function defined here
-  --> $DIR/integer-literal-suffix-inference.rs:31:8
-   |
-LL |     fn id_usize(n: usize) -> usize { n }
-   |        ^^^^^^^^ --------
-help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
-   |
-LL |     id_usize(b64.try_into().unwrap());
-   |                 ++++++++++++++++++++
-
-error: aborting due to 52 previous errors
-
-For more information about this error, try `rustc --explain E0308`.