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

5 files changed, 132 insertions, 132 deletions

diff --git a/src/test/ui/numeric/const-scope.stderr b/src/test/ui/numeric/const-scope.stderr
index 94ff4623c60..5a275d5d089 100644
--- a/src/test/ui/numeric/const-scope.stderr
+++ b/src/test/ui/numeric/const-scope.stderr
@@ -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();
    |                 ^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/numeric/len.stderr b/src/test/ui/numeric/len.stderr
index 946a4de4245..79b38b06986 100644
--- a/src/test/ui/numeric/len.stderr
+++ b/src/test/ui/numeric/len.stderr
@@ -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());
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/numeric/numeric-cast-2.stderr b/src/test/ui/numeric/numeric-cast-2.stderr
index 9409ce1ed0e..858990fe59b 100644
--- a/src/test/ui/numeric/numeric-cast-2.stderr
+++ b/src/test/ui/numeric/numeric-cast-2.stderr
@@ -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();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/numeric/numeric-cast-binop.stderr b/src/test/ui/numeric/numeric-cast-binop.stderr
index c0f784309b9..cb051aa1230 100644
--- a/src/test/ui/numeric/numeric-cast-binop.stderr
+++ b/src/test/ui/numeric/numeric-cast-binop.stderr
@@ -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();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/numeric/numeric-cast.stderr b/src/test/ui/numeric/numeric-cast.stderr
index ea2f87232ad..ffd6368bac1 100644
--- a/src/test/ui/numeric/numeric-cast.stderr
+++ b/src/test/ui/numeric/numeric-cast.stderr
@@ -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());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^