OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Say "doesn't" instead of "wouldn't" in convert message

This commit is contained in:
Camelid 2020-09-29 19:27:58 -07:00
parent 094f14c554
commit 8a6831a7fd
18 changed files with 176 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_typeck/src/check/demand.rs
View File

@ -827,7 +827,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let suggestion = format!("{}::from({})", checked_ty, lhs_src);
(lhs_expr.span, msg, suggestion)
} else {
let msg = format!("{} and panic if the converted value wouldn't fit", msg);
let msg = format!("{} and panic if the converted value doesn't fit", msg);
let suggestion =
format!("{}{}.try_into().unwrap()", prefix, with_opt_paren(&src));
(expr.span, msg, suggestion)

2
src/test/ui/associated-types/associated-types-path-2.stderr
View File

@ -47,7 +47,7 @@ LL | let _: i32 = f2(2i32);
| |
| expected due to this
|
help: you can convert a `u32` to an `i32` and panic if the converted value wouldn't fit
help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit
|
LL | let _: i32 = f2(2i32).try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/indexing-requires-a-uint.stderr
View File

@ -13,7 +13,7 @@ error[E0308]: mismatched types
LL | bar::<isize>(i); // i should not be re-coerced back to an isize
| ^ expected `isize`, found `usize`
|
help: you can convert a `usize` to an `isize` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
|
LL | bar::<isize>(i.try_into().unwrap()); // i should not be re-coerced back to an isize
| ^^^^^^^^^^^^^^^^^^^^^

60
src/test/ui/integer-literal-suffix-inference.stderr
View File

@ -4,7 +4,7 @@ error[E0308]: mismatched types
LL | id_i8(a16);
| ^^^ expected `i8`, found `i16`
|
help: you can convert an `i16` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(a16.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -15,7 +15,7 @@ error[E0308]: mismatched types
LL | id_i8(a32);
| ^^^ expected `i8`, found `i32`
|
help: you can convert an `i32` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(a32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -26,7 +26,7 @@ error[E0308]: mismatched types
LL | id_i8(a64);
| ^^^ expected `i8`, found `i64`
|
help: you can convert an `i64` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(a64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -37,7 +37,7 @@ error[E0308]: mismatched types
LL | id_i8(asize);
| ^^^^^ expected `i8`, found `isize`
|
help: you can convert an `isize` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(asize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -57,7 +57,7 @@ error[E0308]: mismatched types
LL | id_i16(a32);
| ^^^ expected `i16`, found `i32`
|
help: you can convert an `i32` to an `i16` and panic if the converted value wouldn't fit
help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(a32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -68,7 +68,7 @@ error[E0308]: mismatched types
LL | id_i16(a64);
| ^^^ expected `i16`, found `i64`
|
help: you can convert an `i64` to an `i16` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(a64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -79,7 +79,7 @@ error[E0308]: mismatched types
LL | id_i16(asize);
| ^^^^^ expected `i16`, found `isize`
|
help: you can convert an `isize` to an `i16` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(asize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -108,7 +108,7 @@ error[E0308]: mismatched types
LL | id_i32(a64);
| ^^^ expected `i32`, found `i64`
|
help: you can convert an `i64` to an `i32` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
|
LL | id_i32(a64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -119,7 +119,7 @@ error[E0308]: mismatched types
LL | id_i32(asize);
| ^^^^^ expected `i32`, found `isize`
|
help: you can convert an `isize` to an `i32` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
|
LL | id_i32(asize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -157,7 +157,7 @@ error[E0308]: mismatched types
LL | id_i64(asize);
| ^^^^^ expected `i64`, found `isize`
|
help: you can convert an `isize` to an `i64` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
|
LL | id_i64(asize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -186,7 +186,7 @@ error[E0308]: mismatched types
LL | id_isize(a32);
| ^^^ expected `isize`, found `i32`
|
help: you can convert an `i32` to an `isize` and panic if the converted value wouldn't fit
help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
|
LL | id_isize(a32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -197,7 +197,7 @@ error[E0308]: mismatched types
LL | id_isize(a64);
| ^^^ expected `isize`, found `i64`
|
help: you can convert an `i64` to an `isize` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
|
LL | id_isize(a64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -208,7 +208,7 @@ error[E0308]: mismatched types
LL | id_i8(c16);
| ^^^ expected `i8`, found `i16`
|
help: you can convert an `i16` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(c16.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -219,7 +219,7 @@ error[E0308]: mismatched types
LL | id_i8(c32);
| ^^^ expected `i8`, found `i32`
|
help: you can convert an `i32` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(c32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -230,7 +230,7 @@ error[E0308]: mismatched types
LL | id_i8(c64);
| ^^^ expected `i8`, found `i64`
|
help: you can convert an `i64` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(c64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -250,7 +250,7 @@ error[E0308]: mismatched types
LL | id_i16(c32);
| ^^^ expected `i16`, found `i32`
|
help: you can convert an `i32` to an `i16` and panic if the converted value wouldn't fit
help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(c32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -261,7 +261,7 @@ error[E0308]: mismatched types
LL | id_i16(c64);
| ^^^ expected `i16`, found `i64`
|
help: you can convert an `i64` to an `i16` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(c64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -290,7 +290,7 @@ error[E0308]: mismatched types
LL | id_i32(c64);
| ^^^ expected `i32`, found `i64`
|
help: you can convert an `i64` to an `i32` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
|
LL | id_i32(c64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -328,7 +328,7 @@ error[E0308]: mismatched types
LL | id_u8(b16);
| ^^^ expected `u8`, found `u16`
|
help: you can convert a `u16` to a `u8` and panic if the converted value wouldn't fit
help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(b16.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -339,7 +339,7 @@ error[E0308]: mismatched types
LL | id_u8(b32);
| ^^^ expected `u8`, found `u32`
|
help: you can convert a `u32` to a `u8` and panic if the converted value wouldn't fit
help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(b32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -350,7 +350,7 @@ error[E0308]: mismatched types
LL | id_u8(b64);
| ^^^ expected `u8`, found `u64`
|
help: you can convert a `u64` to a `u8` and panic if the converted value wouldn't fit
help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(b64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -361,7 +361,7 @@ error[E0308]: mismatched types
LL | id_u8(bsize);
| ^^^^^ expected `u8`, found `usize`
|
help: you can convert a `usize` to a `u8` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(bsize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -381,7 +381,7 @@ error[E0308]: mismatched types
LL | id_u16(b32);
| ^^^ expected `u16`, found `u32`
|
help: you can convert a `u32` to a `u16` and panic if the converted value wouldn't fit
help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit
|
LL | id_u16(b32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -392,7 +392,7 @@ error[E0308]: mismatched types
LL | id_u16(b64);
| ^^^ expected `u16`, found `u64`
|
help: you can convert a `u64` to a `u16` and panic if the converted value wouldn't fit
help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit
|
LL | id_u16(b64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -403,7 +403,7 @@ error[E0308]: mismatched types
LL | id_u16(bsize);
| ^^^^^ expected `u16`, found `usize`
|
help: you can convert a `usize` to a `u16` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit
|
LL | id_u16(bsize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -432,7 +432,7 @@ error[E0308]: mismatched types
LL | id_u32(b64);
| ^^^ expected `u32`, found `u64`
|
help: you can convert a `u64` to a `u32` and panic if the converted value wouldn't fit
help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
|
LL | id_u32(b64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -443,7 +443,7 @@ error[E0308]: mismatched types
LL | id_u32(bsize);
| ^^^^^ expected `u32`, found `usize`
|
help: you can convert a `usize` to a `u32` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | id_u32(bsize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -481,7 +481,7 @@ error[E0308]: mismatched types
LL | id_u64(bsize);
| ^^^^^ expected `u64`, found `usize`
|
help: you can convert a `usize` to a `u64` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
|
LL | id_u64(bsize.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -510,7 +510,7 @@ error[E0308]: mismatched types
LL | id_usize(b32);
| ^^^ expected `usize`, found `u32`
|
help: you can convert a `u32` to a `usize` and panic if the converted value wouldn't fit
help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
|
LL | id_usize(b32.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -521,7 +521,7 @@ error[E0308]: mismatched types
LL | id_usize(b64);
| ^^^ expected `usize`, found `u64`
|
help: you can convert a `u64` to a `usize` and panic if the converted value wouldn't fit
help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
|
LL | id_usize(b64.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^

4
src/test/ui/issues/issue-13359.stderr
View File

@ -4,7 +4,7 @@ error[E0308]: mismatched types
LL | foo(1*(1 as isize));
| ^^^^^^^^^^^^^^ expected `i16`, found `isize`
|
help: you can convert an `isize` to an `i16` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
|
LL | foo((1*(1 as isize)).try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -15,7 +15,7 @@ error[E0308]: mismatched types
LL | bar(1*(1 as usize));
| ^^^^^^^^^^^^^^ expected `u32`, found `usize`
|
help: you can convert a `usize` to a `u32` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | bar((1*(1 as usize)).try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/methods/method-ambig-one-trait-unknown-int-type.stderr
View File

@ -14,7 +14,7 @@ LL | let y: usize = x.foo();
| |
| expected due to this
|
help: you can convert an `isize` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit
|
LL | let y: usize = x.foo().try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/mismatched_types/issue-26480.stderr
View File

@ -8,7 +8,7 @@ LL | write!(hello);
| -------------- in this macro invocation
|
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
help: you can convert a `usize` to a `u64` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
|
LL | ($arr.len() * size_of($arr[0])).try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/numeric/const-scope.stderr
View File

@ -57,7 +57,7 @@ LL | let d: i8 = c;
| |
| expected due to this
|
help: you can convert an `i32` to an `i8` and panic if the converted value wouldn't fit
help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
|
LL | let d: i8 = c.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/numeric/len.stderr
View File

@ -4,7 +4,7 @@ error[E0308]: mismatched types
LL | test(array.len());
| ^^^^^^^^^^^ expected `u32`, found `usize`
|
help: you can convert a `usize` to a `u32` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | test(array.len().try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/numeric/numeric-cast-2.stderr
View File

@ -6,7 +6,7 @@ LL | let x: u16 = foo();
| |
| expected due to this
|
help: you can convert an `i32` to a `u16` and panic if the converted value wouldn't fit
help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit
|
LL | let x: u16 = foo().try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^

124
src/test/ui/numeric/numeric-cast-binop.stderr
View File

@ -152,7 +152,7 @@ error[E0308]: mismatched types
LL | x_u32 > x_usize;
| ^^^^^^^ expected `u32`, found `usize`
|
help: you can convert a `usize` to a `u32` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | x_u32 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -201,7 +201,7 @@ error[E0308]: mismatched types
LL | x_u64 > x_usize;
| ^^^^^^^ expected `u64`, found `usize`
|
help: you can convert a `usize` to a `u64` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
|
LL | x_u64 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -248,7 +248,7 @@ error[E0308]: mismatched types
LL | x_u128 > x_usize;
| ^^^^^^^ expected `u128`, found `usize`
|
help: you can convert a `usize` to a `u128` and panic if the converted value wouldn't fit
help: you can convert a `usize` to a `u128` and panic if the converted value doesn't fit
|
LL | x_u128 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -277,7 +277,7 @@ error[E0308]: mismatched types
LL | x_usize > x_u32;
| ^^^^^ expected `usize`, found `u32`
|
help: you can convert a `u32` to a `usize` and panic if the converted value wouldn't fit
help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -288,7 +288,7 @@ error[E0308]: mismatched types
LL | x_usize > x_u64;
| ^^^^^ expected `usize`, found `u64`
|
help: you can convert a `u64` to a `usize` and panic if the converted value wouldn't fit
help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -299,7 +299,7 @@ error[E0308]: mismatched types
LL | x_usize > x_u128;
| ^^^^^^ expected `usize`, found `u128`
|
help: you can convert a `u128` to a `usize` and panic if the converted value wouldn't fit
help: you can convert a `u128` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -458,7 +458,7 @@ error[E0308]: mismatched types
LL | x_i32 > x_isize;
| ^^^^^^^ expected `i32`, found `isize`
|
help: you can convert an `isize` to an `i32` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
|
LL | x_i32 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -507,7 +507,7 @@ error[E0308]: mismatched types
LL | x_i64 > x_isize;
| ^^^^^^^ expected `i64`, found `isize`
|
help: you can convert an `isize` to an `i64` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
|
LL | x_i64 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -554,7 +554,7 @@ error[E0308]: mismatched types
LL | x_i128 > x_isize;
| ^^^^^^^ expected `i128`, found `isize`
|
help: you can convert an `isize` to an `i128` and panic if the converted value wouldn't fit
help: you can convert an `isize` to an `i128` and panic if the converted value doesn't fit
|
LL | x_i128 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -583,7 +583,7 @@ error[E0308]: mismatched types
LL | x_isize > x_i32;
| ^^^^^ expected `isize`, found `i32`
|
help: you can convert an `i32` to an `isize` and panic if the converted value wouldn't fit
help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -594,7 +594,7 @@ error[E0308]: mismatched types
LL | x_isize > x_i64;
| ^^^^^ expected `isize`, found `i64`
|
help: you can convert an `i64` to an `isize` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -605,7 +605,7 @@ error[E0308]: mismatched types
LL | x_isize > x_i128;
| ^^^^^^ expected `isize`, found `i128`
|
help: you can convert an `i128` to an `isize` and panic if the converted value wouldn't fit
help: you can convert an `i128` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_i128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -616,7 +616,7 @@ error[E0308]: mismatched types
LL | x_u8 > x_i8;
| ^^^^ expected `u8`, found `i8`
|
help: you can convert an `i8` to a `u8` and panic if the converted value wouldn't fit
help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit
|
LL | x_u8 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -682,7 +682,7 @@ error[E0308]: mismatched types
LL | x_u16 > x_i8;
| ^^^^ expected `u16`, found `i8`
|
help: you can convert an `i8` to a `u16` and panic if the converted value wouldn't fit
help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit
|
LL | x_u16 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -693,7 +693,7 @@ error[E0308]: mismatched types
LL | x_u16 > x_i16;
| ^^^^^ expected `u16`, found `i16`
|
help: you can convert an `i16` to a `u16` and panic if the converted value wouldn't fit
help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit
|
LL | x_u16 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -737,7 +737,7 @@ error[E0308]: mismatched types
LL | x_u16 > x_isize;
| ^^^^^^^ expected `u16`, found `isize`
|
help: you can convert an `isize` to a `u16` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit
|
LL | x_u16 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -748,7 +748,7 @@ error[E0308]: mismatched types
LL | x_u32 > x_i8;
| ^^^^ expected `u32`, found `i8`
|
help: you can convert an `i8` to a `u32` and panic if the converted value wouldn't fit
help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit
|
LL | x_u32 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -759,7 +759,7 @@ error[E0308]: mismatched types
LL | x_u32 > x_i16;
| ^^^^^ expected `u32`, found `i16`
|
help: you can convert an `i16` to a `u32` and panic if the converted value wouldn't fit
help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit
|
LL | x_u32 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -770,7 +770,7 @@ error[E0308]: mismatched types
LL | x_u32 > x_i32;
| ^^^^^ expected `u32`, found `i32`
|
help: you can convert an `i32` to a `u32` and panic if the converted value wouldn't fit
help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit
|
LL | x_u32 > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -803,7 +803,7 @@ error[E0308]: mismatched types
LL | x_u32 > x_isize;
| ^^^^^^^ expected `u32`, found `isize`
|
help: you can convert an `isize` to a `u32` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit
|
LL | x_u32 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -814,7 +814,7 @@ error[E0308]: mismatched types
LL | x_u64 > x_i8;
| ^^^^ expected `u64`, found `i8`
|
help: you can convert an `i8` to a `u64` and panic if the converted value wouldn't fit
help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit
|
LL | x_u64 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -825,7 +825,7 @@ error[E0308]: mismatched types
LL | x_u64 > x_i16;
| ^^^^^ expected `u64`, found `i16`
|
help: you can convert an `i16` to a `u64` and panic if the converted value wouldn't fit
help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit
|
LL | x_u64 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -836,7 +836,7 @@ error[E0308]: mismatched types
LL | x_u64 > x_i32;
| ^^^^^ expected `u64`, found `i32`
|
help: you can convert an `i32` to a `u64` and panic if the converted value wouldn't fit
help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit
|
LL | x_u64 > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -847,7 +847,7 @@ error[E0308]: mismatched types
LL | x_u64 > x_i64;
| ^^^^^ expected `u64`, found `i64`
|
help: you can convert an `i64` to a `u64` and panic if the converted value wouldn't fit
help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit
|
LL | x_u64 > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -869,7 +869,7 @@ error[E0308]: mismatched types
LL | x_u64 > x_isize;
| ^^^^^^^ expected `u64`, found `isize`
|
help: you can convert an `isize` to a `u64` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit
|
LL | x_u64 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -880,7 +880,7 @@ error[E0308]: mismatched types
LL | x_u128 > x_i8;
| ^^^^ expected `u128`, found `i8`
|
help: you can convert an `i8` to a `u128` and panic if the converted value wouldn't fit
help: you can convert an `i8` to a `u128` and panic if the converted value doesn't fit
|
LL | x_u128 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -891,7 +891,7 @@ error[E0308]: mismatched types
LL | x_u128 > x_i16;
| ^^^^^ expected `u128`, found `i16`
|
help: you can convert an `i16` to a `u128` and panic if the converted value wouldn't fit
help: you can convert an `i16` to a `u128` and panic if the converted value doesn't fit
|
LL | x_u128 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -902,7 +902,7 @@ error[E0308]: mismatched types
LL | x_u128 > x_i32;
| ^^^^^ expected `u128`, found `i32`
|
help: you can convert an `i32` to a `u128` and panic if the converted value wouldn't fit
help: you can convert an `i32` to a `u128` and panic if the converted value doesn't fit
|
LL | x_u128 > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -913,7 +913,7 @@ error[E0308]: mismatched types
LL | x_u128 > x_i64;
| ^^^^^ expected `u128`, found `i64`
|
help: you can convert an `i64` to a `u128` and panic if the converted value wouldn't fit
help: you can convert an `i64` to a `u128` and panic if the converted value doesn't fit
|
LL | x_u128 > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -924,7 +924,7 @@ error[E0308]: mismatched types
LL | x_u128 > x_i128;
| ^^^^^^ expected `u128`, found `i128`
|
help: you can convert an `i128` to a `u128` and panic if the converted value wouldn't fit
help: you can convert an `i128` to a `u128` and panic if the converted value doesn't fit
|
LL | x_u128 > x_i128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -935,7 +935,7 @@ error[E0308]: mismatched types
LL | x_u128 > x_isize;
| ^^^^^^^ expected `u128`, found `isize`
|
help: you can convert an `isize` to a `u128` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `u128` and panic if the converted value doesn't fit
|
LL | x_u128 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -946,7 +946,7 @@ error[E0308]: mismatched types
LL | x_usize > x_i8;
| ^^^^ expected `usize`, found `i8`
|
help: you can convert an `i8` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -957,7 +957,7 @@ error[E0308]: mismatched types
LL | x_usize > x_i16;
| ^^^^^ expected `usize`, found `i16`
|
help: you can convert an `i16` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -968,7 +968,7 @@ error[E0308]: mismatched types
LL | x_usize > x_i32;
| ^^^^^ expected `usize`, found `i32`
|
help: you can convert an `i32` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -979,7 +979,7 @@ error[E0308]: mismatched types
LL | x_usize > x_i64;
| ^^^^^ expected `usize`, found `i64`
|
help: you can convert an `i64` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -990,7 +990,7 @@ error[E0308]: mismatched types
LL | x_usize > x_i128;
| ^^^^^^ expected `usize`, found `i128`
|
help: you can convert an `i128` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `i128` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_i128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1001,7 +1001,7 @@ error[E0308]: mismatched types
LL | x_usize > x_isize;
| ^^^^^^^ expected `usize`, found `isize`
|
help: you can convert an `isize` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit
|
LL | x_usize > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1012,7 +1012,7 @@ error[E0308]: mismatched types
LL | x_i8 > x_u8;
| ^^^^ expected `i8`, found `u8`
|
help: you can convert a `u8` to an `i8` and panic if the converted value wouldn't fit
help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit
|
LL | x_i8 > x_u8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -1023,7 +1023,7 @@ error[E0308]: mismatched types
LL | x_i8 > x_u16;
| ^^^^^ expected `i8`, found `u16`
|
help: you can convert a `u16` to an `i8` and panic if the converted value wouldn't fit
help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit
|
LL | x_i8 > x_u16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1034,7 +1034,7 @@ error[E0308]: mismatched types
LL | x_i8 > x_u32;
| ^^^^^ expected `i8`, found `u32`
|
help: you can convert a `u32` to an `i8` and panic if the converted value wouldn't fit
help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit
|
LL | x_i8 > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1045,7 +1045,7 @@ error[E0308]: mismatched types
LL | x_i8 > x_u64;
| ^^^^^ expected `i8`, found `u64`
|
help: you can convert a `u64` to an `i8` and panic if the converted value wouldn't fit
help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit
|
LL | x_i8 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1056,7 +1056,7 @@ error[E0308]: mismatched types
LL | x_i8 > x_u128;
| ^^^^^^ expected `i8`, found `u128`
|
help: you can convert a `u128` to an `i8` and panic if the converted value wouldn't fit
help: you can convert a `u128` to an `i8` and panic if the converted value doesn't fit
|
LL | x_i8 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1067,7 +1067,7 @@ error[E0308]: mismatched types
LL | x_i8 > x_usize;
| ^^^^^^^ expected `i8`, found `usize`
|
help: you can convert a `usize` to an `i8` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit
|
LL | x_i8 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1087,7 +1087,7 @@ error[E0308]: mismatched types
LL | x_i16 > x_u16;
| ^^^^^ expected `i16`, found `u16`
|
help: you can convert a `u16` to an `i16` and panic if the converted value wouldn't fit
help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit
|
LL | x_i16 > x_u16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1098,7 +1098,7 @@ error[E0308]: mismatched types
LL | x_i16 > x_u32;
| ^^^^^ expected `i16`, found `u32`
|
help: you can convert a `u32` to an `i16` and panic if the converted value wouldn't fit
help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit
|
LL | x_i16 > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1109,7 +1109,7 @@ error[E0308]: mismatched types
LL | x_i16 > x_u64;
| ^^^^^ expected `i16`, found `u64`
|
help: you can convert a `u64` to an `i16` and panic if the converted value wouldn't fit
help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit
|
LL | x_i16 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1120,7 +1120,7 @@ error[E0308]: mismatched types
LL | x_i16 > x_u128;
| ^^^^^^ expected `i16`, found `u128`
|
help: you can convert a `u128` to an `i16` and panic if the converted value wouldn't fit
help: you can convert a `u128` to an `i16` and panic if the converted value doesn't fit
|
LL | x_i16 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1131,7 +1131,7 @@ error[E0308]: mismatched types
LL | x_i16 > x_usize;
| ^^^^^^^ expected `i16`, found `usize`
|
help: you can convert a `usize` to an `i16` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit
|
LL | x_i16 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1160,7 +1160,7 @@ error[E0308]: mismatched types
LL | x_i32 > x_u32;
| ^^^^^ expected `i32`, found `u32`
|
help: you can convert a `u32` to an `i32` and panic if the converted value wouldn't fit
help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit
|
LL | x_i32 > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1171,7 +1171,7 @@ error[E0308]: mismatched types
LL | x_i32 > x_u64;
| ^^^^^ expected `i32`, found `u64`
|
help: you can convert a `u64` to an `i32` and panic if the converted value wouldn't fit
help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit
|
LL | x_i32 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1182,7 +1182,7 @@ error[E0308]: mismatched types
LL | x_i32 > x_u128;
| ^^^^^^ expected `i32`, found `u128`
|
help: you can convert a `u128` to an `i32` and panic if the converted value wouldn't fit
help: you can convert a `u128` to an `i32` and panic if the converted value doesn't fit
|
LL | x_i32 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1193,7 +1193,7 @@ error[E0308]: mismatched types
LL | x_i32 > x_usize;
| ^^^^^^^ expected `i32`, found `usize`
|
help: you can convert a `usize` to an `i32` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit
|
LL | x_i32 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1231,7 +1231,7 @@ error[E0308]: mismatched types
LL | x_i64 > x_u64;
| ^^^^^ expected `i64`, found `u64`
|
help: you can convert a `u64` to an `i64` and panic if the converted value wouldn't fit
help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit
|
LL | x_i64 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1242,7 +1242,7 @@ error[E0308]: mismatched types
LL | x_i64 > x_u128;
| ^^^^^^ expected `i64`, found `u128`
|
help: you can convert a `u128` to an `i64` and panic if the converted value wouldn't fit
help: you can convert a `u128` to an `i64` and panic if the converted value doesn't fit
|
LL | x_i64 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1253,7 +1253,7 @@ error[E0308]: mismatched types
LL | x_i64 > x_usize;
| ^^^^^^^ expected `i64`, found `usize`
|
help: you can convert a `usize` to an `i64` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit
|
LL | x_i64 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1300,7 +1300,7 @@ error[E0308]: mismatched types
LL | x_i128 > x_u128;
| ^^^^^^ expected `i128`, found `u128`
|
help: you can convert a `u128` to an `i128` and panic if the converted value wouldn't fit
help: you can convert a `u128` to an `i128` and panic if the converted value doesn't fit
|
LL | x_i128 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1311,7 +1311,7 @@ error[E0308]: mismatched types
LL | x_i128 > x_usize;
| ^^^^^^^ expected `i128`, found `usize`
|
help: you can convert a `usize` to an `i128` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `i128` and panic if the converted value doesn't fit
|
LL | x_i128 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1331,7 +1331,7 @@ error[E0308]: mismatched types
LL | x_isize > x_u16;
| ^^^^^ expected `isize`, found `u16`
|
help: you can convert a `u16` to an `isize` and panic if the converted value wouldn't fit
help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_u16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1342,7 +1342,7 @@ error[E0308]: mismatched types
LL | x_isize > x_u32;
| ^^^^^ expected `isize`, found `u32`
|
help: you can convert a `u32` to an `isize` and panic if the converted value wouldn't fit
help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1353,7 +1353,7 @@ error[E0308]: mismatched types
LL | x_isize > x_u64;
| ^^^^^ expected `isize`, found `u64`
|
help: you can convert a `u64` to an `isize` and panic if the converted value wouldn't fit
help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1364,7 +1364,7 @@ error[E0308]: mismatched types
LL | x_isize > x_u128;
| ^^^^^^ expected `isize`, found `u128`
|
help: you can convert a `u128` to an `isize` and panic if the converted value wouldn't fit
help: you can convert a `u128` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -1375,7 +1375,7 @@ error[E0308]: mismatched types
LL | x_isize > x_usize;
| ^^^^^^^ expected `isize`, found `usize`
|
help: you can convert a `usize` to an `isize` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
|
LL | x_isize > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^

134
src/test/ui/numeric/numeric-cast.stderr
View File

@ -4,7 +4,7 @@ error[E0308]: mismatched types
LL | foo::<usize>(x_u64);
| ^^^^^ expected `usize`, found `u64`
|
help: you can convert a `u64` to a `usize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -15,7 +15,7 @@ error[E0308]: mismatched types
LL | foo::<usize>(x_u32);
| ^^^^^ expected `usize`, found `u32`
|
help: you can convert a `u32` to a `usize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -44,7 +44,7 @@ error[E0308]: mismatched types
LL | foo::<usize>(x_isize);
| ^^^^^^^ expected `usize`, found `isize`
|
help: you can convert an `isize` to a `usize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -55,7 +55,7 @@ error[E0308]: mismatched types
LL | foo::<usize>(x_i64);
| ^^^^^ expected `usize`, found `i64`
|
help: you can convert an `i64` to a `usize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -66,7 +66,7 @@ error[E0308]: mismatched types
LL | foo::<usize>(x_i32);
| ^^^^^ expected `usize`, found `i32`
|
help: you can convert an `i32` to a `usize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -77,7 +77,7 @@ error[E0308]: mismatched types
LL | foo::<usize>(x_i16);
| ^^^^^ expected `usize`, found `i16`
|
help: you can convert an `i16` to a `usize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -88,7 +88,7 @@ error[E0308]: mismatched types
LL | foo::<usize>(x_i8);
| ^^^^ expected `usize`, found `i8`
|
help: you can convert an `i8` to a `usize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -99,7 +99,7 @@ error[E0308]: mismatched types
LL | foo::<isize>(x_usize);
| ^^^^^^^ expected `isize`, found `usize`
|
help: you can convert a `usize` to an `isize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -110,7 +110,7 @@ error[E0308]: mismatched types
LL | foo::<isize>(x_u64);
| ^^^^^ expected `isize`, found `u64`
|
help: you can convert a `u64` to an `isize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -121,7 +121,7 @@ error[E0308]: mismatched types
LL | foo::<isize>(x_u32);
| ^^^^^ expected `isize`, found `u32`
|
help: you can convert a `u32` to an `isize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -132,7 +132,7 @@ error[E0308]: mismatched types
LL | foo::<isize>(x_u16);
| ^^^^^ expected `isize`, found `u16`
|
help: you can convert a `u16` to an `isize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -152,7 +152,7 @@ error[E0308]: mismatched types
LL | foo::<isize>(x_i64);
| ^^^^^ expected `isize`, found `i64`
|
help: you can convert an `i64` to an `isize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -163,7 +163,7 @@ error[E0308]: mismatched types
LL | foo::<isize>(x_i32);
| ^^^^^ expected `isize`, found `i32`
|
help: you can convert an `i32` to an `isize` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -192,7 +192,7 @@ error[E0308]: mismatched types
LL | foo::<u64>(x_usize);
| ^^^^^^^ expected `u64`, found `usize`
|
help: you can convert a `usize` to a `u64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -230,7 +230,7 @@ error[E0308]: mismatched types
LL | foo::<u64>(x_isize);
| ^^^^^^^ expected `u64`, found `isize`
|
help: you can convert an `isize` to a `u64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -241,7 +241,7 @@ error[E0308]: mismatched types
LL | foo::<u64>(x_i64);
| ^^^^^ expected `u64`, found `i64`
|
help: you can convert an `i64` to a `u64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -252,7 +252,7 @@ error[E0308]: mismatched types
LL | foo::<u64>(x_i32);
| ^^^^^ expected `u64`, found `i32`
|
help: you can convert an `i32` to a `u64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -263,7 +263,7 @@ error[E0308]: mismatched types
LL | foo::<u64>(x_i16);
| ^^^^^ expected `u64`, found `i16`
|
help: you can convert an `i16` to a `u64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -274,7 +274,7 @@ error[E0308]: mismatched types
LL | foo::<u64>(x_i8);
| ^^^^ expected `u64`, found `i8`
|
help: you can convert an `i8` to a `u64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -285,7 +285,7 @@ error[E0308]: mismatched types
LL | foo::<i64>(x_usize);
| ^^^^^^^ expected `i64`, found `usize`
|
help: you can convert a `usize` to an `i64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -296,7 +296,7 @@ error[E0308]: mismatched types
LL | foo::<i64>(x_u64);
| ^^^^^ expected `i64`, found `u64`
|
help: you can convert a `u64` to an `i64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -334,7 +334,7 @@ error[E0308]: mismatched types
LL | foo::<i64>(x_isize);
| ^^^^^^^ expected `i64`, found `isize`
|
help: you can convert an `isize` to an `i64` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -372,7 +372,7 @@ error[E0308]: mismatched types
LL | foo::<u32>(x_usize);
| ^^^^^^^ expected `u32`, found `usize`
|
help: you can convert a `usize` to a `u32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -383,7 +383,7 @@ error[E0308]: mismatched types
LL | foo::<u32>(x_u64);
| ^^^^^ expected `u32`, found `u64`
|
help: you can convert a `u64` to a `u32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -412,7 +412,7 @@ error[E0308]: mismatched types
LL | foo::<u32>(x_isize);
| ^^^^^^^ expected `u32`, found `isize`
|
help: you can convert an `isize` to a `u32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -423,7 +423,7 @@ error[E0308]: mismatched types
LL | foo::<u32>(x_i64);
| ^^^^^ expected `u32`, found `i64`
|
help: you can convert an `i64` to a `u32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -434,7 +434,7 @@ error[E0308]: mismatched types
LL | foo::<u32>(x_i32);
| ^^^^^ expected `u32`, found `i32`
|
help: you can convert an `i32` to a `u32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -445,7 +445,7 @@ error[E0308]: mismatched types
LL | foo::<u32>(x_i16);
| ^^^^^ expected `u32`, found `i16`
|
help: you can convert an `i16` to a `u32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -456,7 +456,7 @@ error[E0308]: mismatched types
LL | foo::<u32>(x_i8);
| ^^^^ expected `u32`, found `i8`
|
help: you can convert an `i8` to a `u32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -467,7 +467,7 @@ error[E0308]: mismatched types
LL | foo::<i32>(x_usize);
| ^^^^^^^ expected `i32`, found `usize`
|
help: you can convert a `usize` to an `i32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -478,7 +478,7 @@ error[E0308]: mismatched types
LL | foo::<i32>(x_u64);
| ^^^^^ expected `i32`, found `u64`
|
help: you can convert a `u64` to an `i32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -489,7 +489,7 @@ error[E0308]: mismatched types
LL | foo::<i32>(x_u32);
| ^^^^^ expected `i32`, found `u32`
|
help: you can convert a `u32` to an `i32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -518,7 +518,7 @@ error[E0308]: mismatched types
LL | foo::<i32>(x_isize);
| ^^^^^^^ expected `i32`, found `isize`
|
help: you can convert an `isize` to an `i32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -529,7 +529,7 @@ error[E0308]: mismatched types
LL | foo::<i32>(x_i64);
| ^^^^^ expected `i32`, found `i64`
|
help: you can convert an `i64` to an `i32` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -558,7 +558,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_usize);
| ^^^^^^^ expected `u16`, found `usize`
|
help: you can convert a `usize` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -569,7 +569,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_u64);
| ^^^^^ expected `u16`, found `u64`
|
help: you can convert a `u64` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -580,7 +580,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_u32);
| ^^^^^ expected `u16`, found `u32`
|
help: you can convert a `u32` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -600,7 +600,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_isize);
| ^^^^^^^ expected `u16`, found `isize`
|
help: you can convert an `isize` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -611,7 +611,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_i64);
| ^^^^^ expected `u16`, found `i64`
|
help: you can convert an `i64` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -622,7 +622,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_i32);
| ^^^^^ expected `u16`, found `i32`
|
help: you can convert an `i32` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -633,7 +633,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_i16);
| ^^^^^ expected `u16`, found `i16`
|
help: you can convert an `i16` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -644,7 +644,7 @@ error[E0308]: mismatched types
LL | foo::<u16>(x_i8);
| ^^^^ expected `u16`, found `i8`
|
help: you can convert an `i8` to a `u16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -655,7 +655,7 @@ error[E0308]: mismatched types
LL | foo::<i16>(x_usize);
| ^^^^^^^ expected `i16`, found `usize`
|
help: you can convert a `usize` to an `i16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -666,7 +666,7 @@ error[E0308]: mismatched types
LL | foo::<i16>(x_u64);
| ^^^^^ expected `i16`, found `u64`
|
help: you can convert a `u64` to an `i16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -677,7 +677,7 @@ error[E0308]: mismatched types
LL | foo::<i16>(x_u32);
| ^^^^^ expected `i16`, found `u32`
|
help: you can convert a `u32` to an `i16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -688,7 +688,7 @@ error[E0308]: mismatched types
LL | foo::<i16>(x_u16);
| ^^^^^ expected `i16`, found `u16`
|
help: you can convert a `u16` to an `i16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -708,7 +708,7 @@ error[E0308]: mismatched types
LL | foo::<i16>(x_isize);
| ^^^^^^^ expected `i16`, found `isize`
|
help: you can convert an `isize` to an `i16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -719,7 +719,7 @@ error[E0308]: mismatched types
LL | foo::<i16>(x_i64);
| ^^^^^ expected `i16`, found `i64`
|
help: you can convert an `i64` to an `i16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -730,7 +730,7 @@ error[E0308]: mismatched types
LL | foo::<i16>(x_i32);
| ^^^^^ expected `i16`, found `i32`
|
help: you can convert an `i32` to an `i16` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -750,7 +750,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_usize);
| ^^^^^^^ expected `u8`, found `usize`
|
help: you can convert a `usize` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -761,7 +761,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_u64);
| ^^^^^ expected `u8`, found `u64`
|
help: you can convert a `u64` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -772,7 +772,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_u32);
| ^^^^^ expected `u8`, found `u32`
|
help: you can convert a `u32` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -783,7 +783,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_u16);
| ^^^^^ expected `u8`, found `u16`
|
help: you can convert a `u16` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -794,7 +794,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_isize);
| ^^^^^^^ expected `u8`, found `isize`
|
help: you can convert an `isize` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -805,7 +805,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_i64);
| ^^^^^ expected `u8`, found `i64`
|
help: you can convert an `i64` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -816,7 +816,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_i32);
| ^^^^^ expected `u8`, found `i32`
|
help: you can convert an `i32` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -827,7 +827,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_i16);
| ^^^^^ expected `u8`, found `i16`
|
help: you can convert an `i16` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -838,7 +838,7 @@ error[E0308]: mismatched types
LL | foo::<u8>(x_i8);
| ^^^^ expected `u8`, found `i8`
|
help: you can convert an `i8` to a `u8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -849,7 +849,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_usize);
| ^^^^^^^ expected `i8`, found `usize`
|
help: you can convert a `usize` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -860,7 +860,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_u64);
| ^^^^^ expected `i8`, found `u64`
|
help: you can convert a `u64` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -871,7 +871,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_u32);
| ^^^^^ expected `i8`, found `u32`
|
help: you can convert a `u32` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -882,7 +882,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_u16);
| ^^^^^ expected `i8`, found `u16`
|
help: you can convert a `u16` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -893,7 +893,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_u8);
| ^^^^ expected `i8`, found `u8`
|
help: you can convert a `u8` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^
@ -904,7 +904,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_isize);
| ^^^^^^^ expected `i8`, found `isize`
|
help: you can convert an `isize` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -915,7 +915,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_i64);
| ^^^^^ expected `i8`, found `i64`
|
help: you can convert an `i64` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -926,7 +926,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_i32);
| ^^^^^ expected `i8`, found `i32`
|
help: you can convert an `i32` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -937,7 +937,7 @@ error[E0308]: mismatched types
LL | foo::<i8>(x_i16);
| ^^^^^ expected `i8`, found `i16`
|
help: you can convert an `i16` to an `i8` and panic if the converted value wouldn't fit
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());
| ^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/proc-macro/span-preservation.stderr
View File

@ -15,7 +15,7 @@ LL | match x {
LL | Some(x) => { return x },
| ^ expected `usize`, found `isize`
|
help: you can convert an `isize` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit
|
LL | Some(x) => { return x.try_into().unwrap() },
| ^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/shift-various-bad-types.stderr
View File

@ -30,7 +30,7 @@ LL | let _: i32 = 22_i64 >> 1_i32;
| |
| expected due to this
|
help: you can convert an `i64` to an `i32` and panic if the converted value wouldn't fit
help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
|
LL | let _: i32 = (22_i64 >> 1_i32).try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/tail-typeck.stderr
View File

@ -6,7 +6,7 @@ LL | fn f() -> isize { return g(); }
| |
| expected `isize` because of return type
|
help: you can convert a `usize` to an `isize` and panic if the converted value wouldn't fit
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
|
LL | fn f() -> isize { return g().try_into().unwrap(); }
| ^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/trivial-bounds/trivial-bounds-inconsistent-projection-error.stderr
View File

@ -7,7 +7,7 @@ LL | fn global_bound_is_hidden() -> u8
LL | B::get_x()
| ^^^^^^^^^^ expected `u8`, found `i32`
|
help: you can convert an `i32` to a `u8` and panic if the converted value wouldn't fit
help: you can convert an `i32` to a `u8` and panic if the converted value doesn't fit
|
LL | B::get_x().try_into().unwrap()
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

4
src/test/ui/tutorial-suffix-inference-test.stderr
View File

@ -13,7 +13,7 @@ error[E0308]: mismatched types
LL | identity_u16(y);
| ^ expected `u16`, found `i32`
|
help: you can convert an `i32` to a `u16` and panic if the converted value wouldn't fit
help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit
|
LL | identity_u16(y.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^
@ -24,7 +24,7 @@ error[E0308]: mismatched types
LL | identity_u16(a);
| ^ expected `u16`, found `isize`
|
help: you can convert an `isize` to a `u16` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit
|
LL | identity_u16(a.try_into().unwrap());
| ^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/wrong-ret-type.stderr
View File

@ -6,7 +6,7 @@ LL | fn mk_int() -> usize { let i: isize = 3; return i; }
| |
| expected `usize` because of return type
|
help: you can convert an `isize` to a `usize` and panic if the converted value wouldn't fit
help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit
|
LL | fn mk_int() -> usize { let i: isize = 3; return i.try_into().unwrap(); }
| ^^^^^^^^^^^^^^^^^^^^^