diff options
Diffstat (limited to 'src/test/ui/numeric/numeric-cast.stderr')
| -rw-r--r-- | src/test/ui/numeric/numeric-cast.stderr | 2037 |
1 files changed, 2037 insertions, 0 deletions
diff --git a/src/test/ui/numeric/numeric-cast.stderr b/src/test/ui/numeric/numeric-cast.stderr new file mode 100644 index 000000000..d347875d5 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast.stderr @@ -0,0 +1,2037 @@ +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:23:18 + | +LL | foo::<usize>(x_u64); + | ------------ ^^^^^ expected `usize`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:25:18 + | +LL | foo::<usize>(x_u32); + | ------------ ^^^^^ expected `usize`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:27:18 + | +LL | foo::<usize>(x_u16); + | ------------ ^^^^^ expected `usize`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `usize` + | +LL | foo::<usize>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:29:18 + | +LL | foo::<usize>(x_u8); + | ------------ ^^^^ expected `usize`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `usize` + | +LL | foo::<usize>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:31:18 + | +LL | foo::<usize>(x_isize); + | ------------ ^^^^^^^ expected `usize`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:33:18 + | +LL | foo::<usize>(x_i64); + | ------------ ^^^^^ expected `usize`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:35:18 + | +LL | foo::<usize>(x_i32); + | ------------ ^^^^^ expected `usize`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:37:18 + | +LL | foo::<usize>(x_i16); + | ------------ ^^^^^ expected `usize`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:39:18 + | +LL | foo::<usize>(x_i8); + | ------------ ^^^^ expected `usize`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:44:18 + | +LL | foo::<isize>(x_usize); + | ------------ ^^^^^^^ expected `isize`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:46:18 + | +LL | foo::<isize>(x_u64); + | ------------ ^^^^^ expected `isize`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:48:18 + | +LL | foo::<isize>(x_u32); + | ------------ ^^^^^ expected `isize`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:50:18 + | +LL | foo::<isize>(x_u16); + | ------------ ^^^^^ expected `isize`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:52:18 + | +LL | foo::<isize>(x_u8); + | ------------ ^^^^ expected `isize`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `isize` + | +LL | foo::<isize>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:55:18 + | +LL | foo::<isize>(x_i64); + | ------------ ^^^^^ expected `isize`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:57:18 + | +LL | foo::<isize>(x_i32); + | ------------ ^^^^^ expected `isize`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:59:18 + | +LL | foo::<isize>(x_i16); + | ------------ ^^^^^ expected `isize`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `isize` + | +LL | foo::<isize>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:61:18 + | +LL | foo::<isize>(x_i8); + | ------------ ^^^^ expected `isize`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `isize` + | +LL | foo::<isize>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:66:16 + | +LL | foo::<u64>(x_usize); + | ---------- ^^^^^^^ expected `u64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:69:16 + | +LL | foo::<u64>(x_u32); + | ---------- ^^^^^ expected `u64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `u64` + | +LL | foo::<u64>(x_u32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:71:16 + | +LL | foo::<u64>(x_u16); + | ---------- ^^^^^ expected `u64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u64` + | +LL | foo::<u64>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:73:16 + | +LL | foo::<u64>(x_u8); + | ---------- ^^^^ expected `u64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `u64` + | +LL | foo::<u64>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:75:16 + | +LL | foo::<u64>(x_isize); + | ---------- ^^^^^^^ expected `u64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:77:16 + | +LL | foo::<u64>(x_i64); + | ---------- ^^^^^ expected `u64`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:79:16 + | +LL | foo::<u64>(x_i32); + | ---------- ^^^^^ expected `u64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:81:16 + | +LL | foo::<u64>(x_i16); + | ---------- ^^^^^ expected `u64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:83:16 + | +LL | foo::<u64>(x_i8); + | ---------- ^^^^ expected `u64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:88:16 + | +LL | foo::<i64>(x_usize); + | ---------- ^^^^^^^ expected `i64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit + | +LL | foo::<i64>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:90:16 + | +LL | foo::<i64>(x_u64); + | ---------- ^^^^^ expected `i64`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit + | +LL | foo::<i64>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:92:16 + | +LL | foo::<i64>(x_u32); + | ---------- ^^^^^ expected `i64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i64` + | +LL | foo::<i64>(x_u32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:94:16 + | +LL | foo::<i64>(x_u16); + | ---------- ^^^^^ expected `i64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i64` + | +LL | foo::<i64>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:96:16 + | +LL | foo::<i64>(x_u8); + | ---------- ^^^^ expected `i64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i64` + | +LL | foo::<i64>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:98:16 + | +LL | foo::<i64>(x_isize); + | ---------- ^^^^^^^ expected `i64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit + | +LL | foo::<i64>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:101:16 + | +LL | foo::<i64>(x_i32); + | ---------- ^^^^^ expected `i64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `i64` + | +LL | foo::<i64>(x_i32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:103:16 + | +LL | foo::<i64>(x_i16); + | ---------- ^^^^^ expected `i64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `i64` + | +LL | foo::<i64>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:105:16 + | +LL | foo::<i64>(x_i8); + | ---------- ^^^^ expected `i64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i64` + | +LL | foo::<i64>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:110:16 + | +LL | foo::<u32>(x_usize); + | ---------- ^^^^^^^ expected `u32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:112:16 + | +LL | foo::<u32>(x_u64); + | ---------- ^^^^^ expected `u32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:115:16 + | +LL | foo::<u32>(x_u16); + | ---------- ^^^^^ expected `u32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u32` + | +LL | foo::<u32>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:117:16 + | +LL | foo::<u32>(x_u8); + | ---------- ^^^^ expected `u32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `u32` + | +LL | foo::<u32>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:119:16 + | +LL | foo::<u32>(x_isize); + | ---------- ^^^^^^^ expected `u32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:121:16 + | +LL | foo::<u32>(x_i64); + | ---------- ^^^^^ expected `u32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:123:16 + | +LL | foo::<u32>(x_i32); + | ---------- ^^^^^ expected `u32`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:125:16 + | +LL | foo::<u32>(x_i16); + | ---------- ^^^^^ expected `u32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:127:16 + | +LL | foo::<u32>(x_i8); + | ---------- ^^^^ expected `u32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:132:16 + | +LL | foo::<i32>(x_usize); + | ---------- ^^^^^^^ expected `i32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:134:16 + | +LL | foo::<i32>(x_u64); + | ---------- ^^^^^ expected `i32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:136:16 + | +LL | foo::<i32>(x_u32); + | ---------- ^^^^^ expected `i32`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:138:16 + | +LL | foo::<i32>(x_u16); + | ---------- ^^^^^ expected `i32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i32` + | +LL | foo::<i32>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:140:16 + | +LL | foo::<i32>(x_u8); + | ---------- ^^^^ expected `i32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i32` + | +LL | foo::<i32>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:142:16 + | +LL | foo::<i32>(x_isize); + | ---------- ^^^^^^^ expected `i32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:144:16 + | +LL | foo::<i32>(x_i64); + | ---------- ^^^^^ expected `i32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:147:16 + | +LL | foo::<i32>(x_i16); + | ---------- ^^^^^ expected `i32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `i32` + | +LL | foo::<i32>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:149:16 + | +LL | foo::<i32>(x_i8); + | ---------- ^^^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i32` + | +LL | foo::<i32>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:154:16 + | +LL | foo::<u16>(x_usize); + | ---------- ^^^^^^^ expected `u16`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:156:16 + | +LL | foo::<u16>(x_u64); + | ---------- ^^^^^ expected `u16`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:158:16 + | +LL | foo::<u16>(x_u32); + | ---------- ^^^^^ expected `u16`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:161:16 + | +LL | foo::<u16>(x_u8); + | ---------- ^^^^ expected `u16`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `u16` + | +LL | foo::<u16>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:163:16 + | +LL | foo::<u16>(x_isize); + | ---------- ^^^^^^^ expected `u16`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:165:16 + | +LL | foo::<u16>(x_i64); + | ---------- ^^^^^ expected `u16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:167:16 + | +LL | foo::<u16>(x_i32); + | ---------- ^^^^^ expected `u16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:169:16 + | +LL | foo::<u16>(x_i16); + | ---------- ^^^^^ expected `u16`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:171:16 + | +LL | foo::<u16>(x_i8); + | ---------- ^^^^ expected `u16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:176:16 + | +LL | foo::<i16>(x_usize); + | ---------- ^^^^^^^ expected `i16`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:178:16 + | +LL | foo::<i16>(x_u64); + | ---------- ^^^^^ expected `i16`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:180:16 + | +LL | foo::<i16>(x_u32); + | ---------- ^^^^^ expected `i16`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:182:16 + | +LL | foo::<i16>(x_u16); + | ---------- ^^^^^ expected `i16`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:184:16 + | +LL | foo::<i16>(x_u8); + | ---------- ^^^^ expected `i16`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i16` + | +LL | foo::<i16>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:186:16 + | +LL | foo::<i16>(x_isize); + | ---------- ^^^^^^^ expected `i16`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:188:16 + | +LL | foo::<i16>(x_i64); + | ---------- ^^^^^ expected `i16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:190:16 + | +LL | foo::<i16>(x_i32); + | ---------- ^^^^^ expected `i16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:193:16 + | +LL | foo::<i16>(x_i8); + | ---------- ^^^^ expected `i16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i16` + | +LL | foo::<i16>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:198:15 + | +LL | foo::<u8>(x_usize); + | --------- ^^^^^^^ expected `u8`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:200:15 + | +LL | foo::<u8>(x_u64); + | --------- ^^^^^ expected `u8`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:202:15 + | +LL | foo::<u8>(x_u32); + | --------- ^^^^^ expected `u8`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:204:15 + | +LL | foo::<u8>(x_u16); + | --------- ^^^^^ expected `u8`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:207:15 + | +LL | foo::<u8>(x_isize); + | --------- ^^^^^^^ expected `u8`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:209:15 + | +LL | foo::<u8>(x_i64); + | --------- ^^^^^ expected `u8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:211:15 + | +LL | foo::<u8>(x_i32); + | --------- ^^^^^ expected `u8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:213:15 + | +LL | foo::<u8>(x_i16); + | --------- ^^^^^ expected `u8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:215:15 + | +LL | foo::<u8>(x_i8); + | --------- ^^^^ expected `u8`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:220:15 + | +LL | foo::<i8>(x_usize); + | --------- ^^^^^^^ expected `i8`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:222:15 + | +LL | foo::<i8>(x_u64); + | --------- ^^^^^ expected `i8`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:224:15 + | +LL | foo::<i8>(x_u32); + | --------- ^^^^^ expected `i8`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:226:15 + | +LL | foo::<i8>(x_u16); + | --------- ^^^^^ expected `i8`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:228:15 + | +LL | foo::<i8>(x_u8); + | --------- ^^^^ expected `i8`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:230:15 + | +LL | foo::<i8>(x_isize); + | --------- ^^^^^^^ expected `i8`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:232:15 + | +LL | foo::<i8>(x_i64); + | --------- ^^^^^ expected `i8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:234:15 + | +LL | foo::<i8>(x_i32); + | --------- ^^^^^ expected `i8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:236:15 + | +LL | foo::<i8>(x_i16); + | --------- ^^^^^ expected `i8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:242:16 + | +LL | foo::<f64>(x_usize); + | ---------- ^^^^^^^ expected `f64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `usize` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_usize as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:244:16 + | +LL | foo::<f64>(x_u64); + | ---------- ^^^^^ expected `f64`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `u64` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_u64 as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:246:16 + | +LL | foo::<f64>(x_u32); + | ---------- ^^^^^ expected `f64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_u32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:248:16 + | +LL | foo::<f64>(x_u16); + | ---------- ^^^^^ expected `f64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:250:16 + | +LL | foo::<f64>(x_u8); + | ---------- ^^^^ expected `f64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:252:16 + | +LL | foo::<f64>(x_isize); + | ---------- ^^^^^^^ expected `f64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_isize as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:254:16 + | +LL | foo::<f64>(x_i64); + | ---------- ^^^^^ expected `f64`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_i64 as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:256:16 + | +LL | foo::<f64>(x_i32); + | ---------- ^^^^^ expected `f64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_i32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:258:16 + | +LL | foo::<f64>(x_i16); + | ---------- ^^^^^ expected `f64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:260:16 + | +LL | foo::<f64>(x_i8); + | ---------- ^^^^ expected `f64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:263:16 + | +LL | foo::<f64>(x_f32); + | ---------- ^^^^^ expected `f64`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `f32` to an `f64` + | +LL | foo::<f64>(x_f32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:266:16 + | +LL | foo::<f32>(x_usize); + | ---------- ^^^^^^^ expected `f32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `usize` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_usize as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:268:16 + | +LL | foo::<f32>(x_u64); + | ---------- ^^^^^ expected `f32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `u64` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_u64 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:270:16 + | +LL | foo::<f32>(x_u32); + | ---------- ^^^^^ expected `f32`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `u32` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_u32 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:272:16 + | +LL | foo::<f32>(x_u16); + | ---------- ^^^^^ expected `f32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:274:16 + | +LL | foo::<f32>(x_u8); + | ---------- ^^^^ expected `f32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:276:16 + | +LL | foo::<f32>(x_isize); + | ---------- ^^^^^^^ expected `f32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_isize as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:278:16 + | +LL | foo::<f32>(x_i64); + | ---------- ^^^^^ expected `f32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_i64 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:280:16 + | +LL | foo::<f32>(x_i32); + | ---------- ^^^^^ expected `f32`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_i32 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:282:16 + | +LL | foo::<f32>(x_i16); + | ---------- ^^^^^ expected `f32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:284:16 + | +LL | foo::<f32>(x_i8); + | ---------- ^^^^ expected `f32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:289:16 + | +LL | foo::<u32>(x_u8 as u16); + | ---------- ^^^^^^^^^^^ expected `u32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u32` + | +LL | foo::<u32>((x_u8 as u16).into()); + | + ++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:291:16 + | +LL | foo::<i32>(-x_i8); + | ---------- ^^^^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i32` + | +LL | foo::<i32>((-x_i8).into()); + | + ++++++++ + +error: aborting due to 113 previous errors + +For more information about this error, try `rustc --explain E0308`. |