mirror of
https://github.com/rust-lang/rust.git
synced 2025-10-31 13:04:42 +00:00
2038 lines
55 KiB
Plaintext
2038 lines
55 KiB
Plaintext
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`.
|