| error[E0308]: mismatched types |
| --> $DIR/integer-literal-suffix-inference.rs:40: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:17: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:43: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:17: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:46: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:17: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:49: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:17: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:53: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:18: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:57: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:18: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:60: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:18: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:63: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:18: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:67: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:19: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:70: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:19: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:74: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:19: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:77: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:19: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:81: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:20: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:84: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:20: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:87: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:20: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:91: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:20: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:95: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:21: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:98: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:21: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:101: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:21: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:104: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:21: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:110: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:17: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:113: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:17: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:116: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:17: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:120: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:18: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:124: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:18: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:127: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:18: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:131: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:19: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:134: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:19: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:138: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:19: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:142: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:20: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:145: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:20: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:148: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:20: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:154: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:29: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:157: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:29: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:160: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:29: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:163: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:29: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:167: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:30: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:171: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:30: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:174: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:30: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:177: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:30: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:181: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:31: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:184: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:31: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:188: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:31: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:191: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:31: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:195: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:32: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:198: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:32: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:201: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:32: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:205: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:32: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:209: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:33: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:212: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:33: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:215: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:33: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:218: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:33: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`. |
