mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1f0fcf13f5
rust/tests/ui/numeric/numeric-cast-binop.stderr

1720 lines
50 KiB
Plaintext
Raw Normal View History

Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:23:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `u8`, found `u16`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `u16`, matching the type of `x_u16`
|
LL | u16::from(x_u8) > x_u16;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:25:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `u8`, found `u32`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `u32`, matching the type of `x_u32`
|
LL | u32::from(x_u8) > x_u32;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:27:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `u8`, found `u64`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `u64`, matching the type of `x_u64`
|
LL | u64::from(x_u8) > x_u64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:29:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^ expected `u8`, found `u128`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u8) > x_u128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:31:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^^ expected `u8`, found `usize`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `usize`, matching the type of `x_usize`
|
LL | usize::from(x_u8) > x_usize;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:34:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `u16`, found `u8`
| |
| expected because this is `u16`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to a `u16`
|
LL | x_u16 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:36:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u16`, found `u32`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u16` from `u16` to `u32`, matching the type of `x_u32`
|
LL | u32::from(x_u16) > x_u32;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:38:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u16`, found `u64`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u16` from `u16` to `u64`, matching the type of `x_u64`
|
LL | u64::from(x_u16) > x_u64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:40:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `u16`, found `u128`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u16` from `u16` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u16) > x_u128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:42:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `u16`, found `usize`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u16` from `u16` to `usize`, matching the type of `x_usize`
|
LL | usize::from(x_u16) > x_usize;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:45:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `u32`, found `u8`
| |
| expected because this is `u32`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to a `u32`
|
LL | x_u32 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:47:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u32`, found `u16`
| |
| expected because this is `u32`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u16` to a `u32`
|
LL | x_u32 > x_u16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:49:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u32`, found `u64`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u32` from `u32` to `u64`, matching the type of `x_u64`
|
LL | u64::from(x_u32) > x_u64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:51:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `u32`, found `u128`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u32` from `u32` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u32) > x_u128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:53:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `u32`, found `usize`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:56:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `u64`, found `u8`
| |
| expected because this is `u64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to a `u64`
|
LL | x_u64 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:58:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u64`, found `u16`
| |
| expected because this is `u64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u16` to a `u64`
|
LL | x_u64 > x_u16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:60:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u64`, found `u32`
| |
| expected because this is `u64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u32` to a `u64`
|
LL | x_u64 > x_u32.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:62:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `u64`, found `u128`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u64` from `u64` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u64) > x_u128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:64:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `u64`, found `usize`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:67:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^ expected `u128`, found `u8`
| |
| expected because this is `u128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to a `u128`
|
LL | x_u128 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:69:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `u128`, found `u16`
| |
| expected because this is `u128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u16` to a `u128`
|
LL | x_u128 > x_u16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:71:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `u128`, found `u32`
| |
| expected because this is `u128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u32` to a `u128`
|
LL | x_u128 > x_u32.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:73:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `u128`, found `u64`
| |
| expected because this is `u128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u64` to a `u128`
|
LL | x_u128 > x_u64.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:75:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^^^ expected `u128`, found `usize`
| |
| expected because this is `u128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to a `u128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:78:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^ expected `usize`, found `u8`
| |
| expected because this is `usize`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to a `usize`
|
LL | x_usize > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:80:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `usize`, found `u16`
| |
| expected because this is `usize`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u16` to a `usize`
|
LL | x_usize > x_u16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:82:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `usize`, found `u32`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:84:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `usize`, found `u64`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:86:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^^ expected `usize`, found `u128`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u128` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_u128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:92:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `i8`, found `i16`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i8` from `i8` to `i16`, matching the type of `x_i16`
|
LL | i16::from(x_i8) > x_i16;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:94:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `i8`, found `i32`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i8` from `i8` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_i8) > x_i32;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:96:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `i8`, found `i64`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i8` from `i8` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_i8) > x_i64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:98:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^ expected `i8`, found `i128`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i8` from `i8` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i8) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:100:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^^ expected `i8`, found `isize`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i8` from `i8` to `isize`, matching the type of `x_isize`
|
LL | isize::from(x_i8) > x_isize;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:103:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `i16`, found `i8`
| |
| expected because this is `i16`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i8` to an `i16`
|
LL | x_i16 > x_i8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:105:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i16`, found `i32`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i16` from `i16` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_i16) > x_i32;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:107:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i16`, found `i64`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i16` from `i16` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_i16) > x_i64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:109:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `i16`, found `i128`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i16` from `i16` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i16) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:111:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `i16`, found `isize`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i16` from `i16` to `isize`, matching the type of `x_isize`
|
LL | isize::from(x_i16) > x_isize;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:114:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `i32`, found `i8`
| |
| expected because this is `i32`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i8` to an `i32`
|
LL | x_i32 > x_i8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:116:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i32`, found `i16`
| |
| expected because this is `i32`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i16` to an `i32`
|
LL | x_i32 > x_i16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:118:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i32`, found `i64`
| |
| expected because this is `i32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i32` from `i32` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_i32) > x_i64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:120:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `i32`, found `i128`
| |
| expected because this is `i32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i32` from `i32` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i32) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:122:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `i32`, found `isize`
| |
| expected because this is `i32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:125:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `i64`, found `i8`
| |
| expected because this is `i64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i8` to an `i64`
|
LL | x_i64 > x_i8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:127:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i64`, found `i16`
| |
| expected because this is `i64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i16` to an `i64`
|
LL | x_i64 > x_i16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:129:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i64`, found `i32`
| |
| expected because this is `i64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i32` to an `i64`
|
LL | x_i64 > x_i32.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:131:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `i64`, found `i128`
| |
| expected because this is `i64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_i64` from `i64` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i64) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:133:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `i64`, found `isize`
| |
| expected because this is `i64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:136:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^ expected `i128`, found `i8`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i8` to an `i128`
|
LL | x_i128 > x_i8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:138:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `i128`, found `i16`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i16` to an `i128`
|
LL | x_i128 > x_i16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:140:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `i128`, found `i32`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i32` to an `i128`
|
LL | x_i128 > x_i32.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:142:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `i128`, found `i64`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i64` to an `i128`
|
LL | x_i128 > x_i64.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:144:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^^^ expected `i128`, found `isize`
| |
| expected because this is `i128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to an `i128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:147:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^ expected `isize`, found `i8`
| |
| expected because this is `isize`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i8` to an `isize`
|
LL | x_isize > x_i8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:149:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `isize`, found `i16`
| |
| expected because this is `isize`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert an `i16` to an `isize`
|
LL | x_isize > x_i16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:151:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `isize`, found `i32`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:153:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `isize`, found `i64`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:155:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^^ expected `isize`, found `i128`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i128` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_i128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:161:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^ expected `u8`, found `i8`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_i8.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:163:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `u8`, found `i16`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `i16`, matching the type of `x_i16`
|
LL | i16::from(x_u8) > x_i16;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:165:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `u8`, found `i32`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_u8) > x_i32;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:167:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `u8`, found `i64`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_u8) > x_i64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:169:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^ expected `u8`, found `i128`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u8) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:171:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u8 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^^ expected `u8`, found `isize`
| |
| expected because this is `u8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u8` from `u8` to `isize`, matching the type of `x_isize`
|
LL | isize::from(x_u8) > x_isize;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:174:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `u16`, found `i8`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_i8.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:176:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u16`, found `i16`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_i16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:178:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u16`, found `i32`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u16` from `u16` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_u16) > x_i32;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:180:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u16`, found `i64`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u16` from `u16` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_u16) > x_i64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:182:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `u16`, found `i128`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u16` from `u16` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u16) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:184:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `u16`, found `isize`
| |
| expected because this is `u16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u16 > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:187:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `u32`, found `i8`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i8.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:189:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u32`, found `i16`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:191:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u32`, found `i32`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:193:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u32`, found `i64`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u32` from `u32` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_u32) > x_i64;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:195:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `u32`, found `i128`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u32` from `u32` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u32) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:197:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `u32`, found `isize`
| |
| expected because this is `u32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u32 > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:200:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `u64`, found `i8`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i8.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:202:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u64`, found `i16`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:204:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u64`, found `i32`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:206:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `u64`, found `i64`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:208:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `u64`, found `i128`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
help: you can convert `x_u64` from `u64` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u64) > x_i128;
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| +++++++++++ +
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:210:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `u64`, found `isize`
| |
| expected because this is `u64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u64 > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:213:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^ expected `u128`, found `i8`
| |
| expected because this is `u128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i8` to a `u128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i8.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:215:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `u128`, found `i16`
| |
| expected because this is `u128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i16` to a `u128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:217:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `u128`, found `i32`
| |
| expected because this is `u128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i32` to a `u128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:219:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `u128`, found `i64`
| |
| expected because this is `u128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i64` to a `u128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:221:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^^ expected `u128`, found `i128`
| |
| expected because this is `u128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i128` to a `u128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_i128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:223:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^^^ expected `u128`, found `isize`
| |
| expected because this is `u128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to a `u128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_u128 > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:226:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^ expected `usize`, found `i8`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i8.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:228:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `usize`, found `i16`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:230:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `usize`, found `i32`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:232:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `usize`, found `i64`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:234:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^^ expected `usize`, found `i128`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `i128` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_i128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:236:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_isize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^^^ expected `usize`, found `isize`
| |
| expected because this is `usize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_usize > x_isize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:242:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^ expected `i8`, found `u8`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u8.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:244:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `i8`, found `u16`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:246:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `i8`, found `u32`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:248:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^ expected `i8`, found `u64`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:250:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^ expected `i8`, found `u128`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u128` to an `i8` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_u128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:252:16
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ---- ^^^^^^^ expected `i8`, found `usize`
| |
| expected because this is `i8`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i8 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:255:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `i16`, found `u8`
| |
| expected because this is `i16`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to an `i16`
|
LL | x_i16 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:257:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i16`, found `u16`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:259:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i16`, found `u32`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:261:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i16`, found `u64`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:263:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `i16`, found `u128`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u128` to an `i16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_u128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:265:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `i16`, found `usize`
| |
| expected because this is `i16`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i16 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:268:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `i32`, found `u8`
| |
| expected because this is `i32`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to an `i32`
|
LL | x_i32 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:270:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i32`, found `u16`
| |
| expected because this is `i32`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u16` to an `i32`
|
LL | x_i32 > x_u16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:272:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i32`, found `u32`
| |
| expected because this is `i32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:274:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i32`, found `u64`
| |
| expected because this is `i32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:276:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `i32`, found `u128`
| |
| expected because this is `i32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u128` to an `i32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_u128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:278:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `i32`, found `usize`
| |
| expected because this is `i32`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i32 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:281:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^ expected `i64`, found `u8`
| |
| expected because this is `i64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to an `i64`
|
LL | x_i64 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:283:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i64`, found `u16`
| |
| expected because this is `i64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u16` to an `i64`
|
LL | x_i64 > x_u16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:285:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i64`, found `u32`
| |
| expected because this is `i64`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u32` to an `i64`
|
LL | x_i64 > x_u32.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:287:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^ expected `i64`, found `u64`
| |
| expected because this is `i64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_u64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:289:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^ expected `i64`, found `u128`
| |
| expected because this is `i64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u128` to an `i64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_u128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:291:17
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ----- ^^^^^^^ expected `i64`, found `usize`
| |
| expected because this is `i64`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i64 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:294:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^ expected `i128`, found `u8`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to an `i128`
|
LL | x_i128 > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:296:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `i128`, found `u16`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u16` to an `i128`
|
LL | x_i128 > x_u16.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:298:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `i128`, found `u32`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u32` to an `i128`
|
LL | x_i128 > x_u32.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:300:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^ expected `i128`, found `u64`
| |
| expected because this is `i128`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u64` to an `i128`
|
LL | x_i128 > x_u64.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:302:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^^ expected `i128`, found `u128`
| |
| expected because this is `i128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u128` to an `i128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_u128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:304:18
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------ ^^^^^^^ expected `i128`, found `usize`
| |
| expected because this is `i128`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to an `i128` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_i128 > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:307:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u8;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^ expected `isize`, found `u8`
| |
| expected because this is `isize`
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
|
help: you can convert a `u8` to an `isize`
|
LL | x_isize > x_u8.into();
| +++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:309:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u16;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `isize`, found `u16`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u16.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:311:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u32;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `isize`, found `u32`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u32.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:313:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u64;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^ expected `isize`, found `u64`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u64.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:315:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u128;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^^ expected `isize`, found `u128`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `u128` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_u128.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error[E0308]: mismatched types
fixup! Provide suggestion to convert numeric op LHS rather than unwrapping RHS
2020-06-11 10:34:12 -05:00
--> $DIR/numeric-cast-binop.rs:317:19
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_usize;
Point at LHS on binop type err if relevant
2022-12-02 17:56:37 -06:00
| ------- ^^^^^^^ expected `isize`, found `usize`
| |
| expected because this is `isize`
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
Say "doesn't" instead of "wouldn't" in convert message
2020-09-29 21:27:58 -05:00
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
|
LL | x_isize > x_usize.try_into().unwrap();
Use smaller spans for some structured suggestions Use more accurate suggestion spans for * argument parse error * fully qualified path * missing code block type * numeric casts * E0212
2021-08-10 05:53:43 -05:00
| ++++++++++++++++++++
Provide suggestion to convert numeric op LHS rather than unwrapping RHS Given a code ```rust fn foo(x: u8, y: u32) -> bool { x > y } fn main() {} ``` it could be more helpful to provide a suggestion to do "u32::from(x)" rather than "y.try_into().unwrap()", since the latter may panic. We do this by passing the LHS of a binary expression up the stack into the coercion checker. Closes #73145
2020-06-09 13:45:40 -05:00
error: aborting due to 132 previous errors
For more information about this error, try `rustc --explain E0308`.
Reference in New Issue Copy Permalink