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

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

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