From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- .../integer-literal-suffix-inference.stderr | 939 +++++++++++++++++++++ 1 file changed, 939 insertions(+) create mode 100644 src/test/ui/numeric/integer-literal-suffix-inference.stderr (limited to 'src/test/ui/numeric/integer-literal-suffix-inference.stderr') diff --git a/src/test/ui/numeric/integer-literal-suffix-inference.stderr b/src/test/ui/numeric/integer-literal-suffix-inference.stderr new file mode 100644 index 000000000..5045f584c --- /dev/null +++ b/src/test/ui/numeric/integer-literal-suffix-inference.stderr @@ -0,0 +1,939 @@ +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`. -- cgit v1.2.3