Skip to content

Fix infinite loop in cast_sign_loss when peeling unwrap method calls #12508

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 22, 2024
+118 −89
Merged

Fix infinite loop in cast_sign_loss when peeling unwrap method calls #12508

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 3 additions & 2 deletions clippy_lints/src/casts/cast_sign_loss.rs
View file
Original file line number Diff line number Diff line change
@@ -118,7 +118,7 @@ enum Sign {
Uncertain,
}

fn expr_sign<'cx>(cx: &LateContext<'cx>, expr: &Expr<'_>, ty: impl Into<Option<Ty<'cx>>>) -> Sign {
fn expr_sign<'cx, 'tcx>(cx: &LateContext<'cx>, mut expr: &'tcx Expr<'tcx>, ty: impl Into<Option<Ty<'cx>>>) -> Sign {
// Try evaluate this expr first to see if it's positive
if let Some(val) = get_const_signed_int_eval(cx, expr, ty) {
return if val >= 0 { Sign::ZeroOrPositive } else { Sign::Negative };
@@ -134,11 +134,12 @@ fn expr_sign<'cx>(cx: &LateContext<'cx>, expr: &Expr<'_>, ty: impl Into<Option<T
// Peel unwrap(), expect(), etc.
while let Some(&found_name) = METHODS_UNWRAP.iter().find(|&name| &method_name == name)
&& let Some(arglist) = method_chain_args(expr, &[found_name])
Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

actually now that I'm taking a closer look at the lint code, this method_chain_args call seems redundant? It doesn't really seem to do anything in this context, except for returning the expression back that was passed in, as far as I can tell.
The line right above it already checks that it's a call to one of the unwrap family of methods.

I removed it locally and the tests are still passing, would be good to have someone else look over this before I actually remove it tho, maybe it's relevant for something else

Copy link
Contributor

@llogiq llogiq Mar 20, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The only additional check it does is whether the method path or any of the rags come from a macro/expansion. If so, the call will return None.

I don't think that should matter in the context of this lint.

Copy link
Member Author

@y21 y21 Mar 20, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

do you mean that we should just keep it then? I guess we can. this just seemed odd to me because the function is generally useful for finding method chains, but is being used for a very different purpose here and doesn't actually look for any chains the way it's used (perhaps confusingly, since the loop is what ends up looking for chains) and does a bunch of unnecessary work like building a vec

&& let ExprKind::MethodCall(inner_path, ..) = &arglist[0].0.kind
&& let ExprKind::MethodCall(inner_path, recv, ..) = &arglist[0].0.kind
{
// The original type has changed, but we can't use `ty` here anyway, because it has been
// moved.
method_name = inner_path.ident.name.as_str();
expr = recv;
}

if METHODS_POW.iter().any(|&name| method_name == name)
12 changes: 11 additions & 1 deletion tests/ui/cast.rs
View file
Original file line number Diff line number Diff line change
@@ -9,7 +9,12 @@
clippy::cast_sign_loss,
clippy::cast_possible_wrap
)]
#![allow(clippy::cast_abs_to_unsigned, clippy::no_effect, clippy::unnecessary_operation)]
#![allow(
clippy::cast_abs_to_unsigned,
clippy::no_effect,
clippy::unnecessary_operation,
clippy::unnecessary_literal_unwrap
)]

fn main() {
// Test clippy::cast_precision_loss
@@ -457,3 +462,8 @@ fn issue11642() {
//~^ ERROR: casting `i32` to `u32` may lose the sign of the value
}
}

fn issue12506() -> usize {
let bar: Result<Option<i64>, u32> = Ok(Some(10));
bar.unwrap().unwrap() as usize
}
190 changes: 104 additions & 86 deletions tests/ui/cast.stderr
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
error: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:17:5
--> tests/ui/cast.rs:22:5
|
LL | x0 as f32;
| ^^^^^^^^^
@@ -8,37 +8,37 @@ LL | x0 as f32;
= help: to override `-D warnings` add `#[allow(clippy::cast_precision_loss)]`

error: casting `i64` to `f32` causes a loss of precision (`i64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:21:5
--> tests/ui/cast.rs:26:5
|
LL | x1 as f32;
| ^^^^^^^^^

error: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
--> tests/ui/cast.rs:23:5
--> tests/ui/cast.rs:28:5
|
LL | x1 as f64;
| ^^^^^^^^^

error: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:26:5
--> tests/ui/cast.rs:31:5
|
LL | x2 as f32;
| ^^^^^^^^^

error: casting `u64` to `f32` causes a loss of precision (`u64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:29:5
--> tests/ui/cast.rs:34:5
|
LL | x3 as f32;
| ^^^^^^^^^

error: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
--> tests/ui/cast.rs:31:5
--> tests/ui/cast.rs:36:5
|
LL | x3 as f64;
| ^^^^^^^^^

error: casting `f32` to `i32` may truncate the value
--> tests/ui/cast.rs:34:5
--> tests/ui/cast.rs:39:5
|
LL | 1f32 as i32;
| ^^^^^^^^^^^
@@ -48,15 +48,15 @@ LL | 1f32 as i32;
= help: to override `-D warnings` add `#[allow(clippy::cast_possible_truncation)]`

error: casting `f32` to `u32` may truncate the value
--> tests/ui/cast.rs:36:5
--> tests/ui/cast.rs:41:5
|
LL | 1f32 as u32;
| ^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `f32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:36:5
--> tests/ui/cast.rs:41:5
|
LL | 1f32 as u32;
| ^^^^^^^^^^^
@@ -65,15 +65,15 @@ LL | 1f32 as u32;
= help: to override `-D warnings` add `#[allow(clippy::cast_sign_loss)]`

error: casting `f64` to `f32` may truncate the value
--> tests/ui/cast.rs:40:5
--> tests/ui/cast.rs:45:5
|
LL | 1f64 as f32;
| ^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `i32` to `i8` may truncate the value
--> tests/ui/cast.rs:42:5
--> tests/ui/cast.rs:47:5
|
LL | 1i32 as i8;
| ^^^^^^^^^^
@@ -85,7 +85,7 @@ LL | i8::try_from(1i32);
| ~~~~~~~~~~~~~~~~~~

error: casting `i32` to `u8` may truncate the value
--> tests/ui/cast.rs:44:5
--> tests/ui/cast.rs:49:5
|
LL | 1i32 as u8;
| ^^^^^^^^^^
@@ -97,29 +97,29 @@ LL | u8::try_from(1i32);
| ~~~~~~~~~~~~~~~~~~

error: casting `f64` to `isize` may truncate the value
--> tests/ui/cast.rs:46:5
--> tests/ui/cast.rs:51:5
|
LL | 1f64 as isize;
| ^^^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `f64` to `usize` may truncate the value
--> tests/ui/cast.rs:48:5
--> tests/ui/cast.rs:53:5
|
LL | 1f64 as usize;
| ^^^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `f64` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:48:5
--> tests/ui/cast.rs:53:5
|
LL | 1f64 as usize;
| ^^^^^^^^^^^^^

error: casting `u32` to `u16` may truncate the value
--> tests/ui/cast.rs:51:5
--> tests/ui/cast.rs:56:5
|
LL | 1f32 as u32 as u16;
| ^^^^^^^^^^^^^^^^^^
@@ -131,21 +131,21 @@ LL | u16::try_from(1f32 as u32);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~

error: casting `f32` to `u32` may truncate the value
--> tests/ui/cast.rs:51:5
--> tests/ui/cast.rs:56:5
|
LL | 1f32 as u32 as u16;
| ^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `f32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:51:5
--> tests/ui/cast.rs:56:5
|
LL | 1f32 as u32 as u16;
| ^^^^^^^^^^^

error: casting `i32` to `i8` may truncate the value
--> tests/ui/cast.rs:56:22
--> tests/ui/cast.rs:61:22
|
LL | let _x: i8 = 1i32 as _;
| ^^^^^^^^^
@@ -157,37 +157,37 @@ LL | let _x: i8 = 1i32.try_into();
| ~~~~~~~~~~~~~~~

error: casting `f32` to `i32` may truncate the value
--> tests/ui/cast.rs:58:9
--> tests/ui/cast.rs:63:9
|
LL | 1f32 as i32;
| ^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `f64` to `i32` may truncate the value
--> tests/ui/cast.rs:60:9
--> tests/ui/cast.rs:65:9
|
LL | 1f64 as i32;
| ^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `f32` to `u8` may truncate the value
--> tests/ui/cast.rs:62:9
--> tests/ui/cast.rs:67:9
|
LL | 1f32 as u8;
| ^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...

error: casting `f32` to `u8` may lose the sign of the value
--> tests/ui/cast.rs:62:9
--> tests/ui/cast.rs:67:9
|
LL | 1f32 as u8;
| ^^^^^^^^^^

error: casting `u8` to `i8` may wrap around the value
--> tests/ui/cast.rs:67:5
--> tests/ui/cast.rs:72:5
|
LL | 1u8 as i8;
| ^^^^^^^^^
@@ -196,31 +196,31 @@ LL | 1u8 as i8;
= help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`

error: casting `u16` to `i16` may wrap around the value
--> tests/ui/cast.rs:70:5
--> tests/ui/cast.rs:75:5
|
LL | 1u16 as i16;
| ^^^^^^^^^^^

error: casting `u32` to `i32` may wrap around the value
--> tests/ui/cast.rs:72:5
--> tests/ui/cast.rs:77:5
|
LL | 1u32 as i32;
| ^^^^^^^^^^^

error: casting `u64` to `i64` may wrap around the value
--> tests/ui/cast.rs:74:5
--> tests/ui/cast.rs:79:5
|
LL | 1u64 as i64;
| ^^^^^^^^^^^

error: casting `usize` to `isize` may wrap around the value
--> tests/ui/cast.rs:76:5
--> tests/ui/cast.rs:81:5
|
LL | 1usize as isize;
| ^^^^^^^^^^^^^^^

error: casting `usize` to `i8` may truncate the value
--> tests/ui/cast.rs:79:5
--> tests/ui/cast.rs:84:5
|
LL | 1usize as i8;
| ^^^^^^^^^^^^
@@ -232,7 +232,7 @@ LL | i8::try_from(1usize);
| ~~~~~~~~~~~~~~~~~~~~

error: casting `usize` to `i16` may truncate the value
--> tests/ui/cast.rs:82:5
--> tests/ui/cast.rs:87:5
|
LL | 1usize as i16;
| ^^^^^^^^^^^^^
@@ -244,7 +244,7 @@ LL | i16::try_from(1usize);
| ~~~~~~~~~~~~~~~~~~~~~

error: casting `usize` to `i16` may wrap around the value on targets with 16-bit wide pointers
--> tests/ui/cast.rs:82:5
--> tests/ui/cast.rs:87:5
|
LL | 1usize as i16;
| ^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL | 1usize as i16;
= note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types

error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
--> tests/ui/cast.rs:87:5
--> tests/ui/cast.rs:92:5
|
LL | 1usize as i32;
| ^^^^^^^^^^^^^
@@ -265,19 +265,19 @@ LL | i32::try_from(1usize);
| ~~~~~~~~~~~~~~~~~~~~~

error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:87:5
--> tests/ui/cast.rs:92:5
|
LL | 1usize as i32;
| ^^^^^^^^^^^^^

error: casting `usize` to `i64` may wrap around the value on targets with 64-bit wide pointers
--> tests/ui/cast.rs:91:5
--> tests/ui/cast.rs:96:5
|
LL | 1usize as i64;
| ^^^^^^^^^^^^^

error: casting `u16` to `isize` may wrap around the value on targets with 16-bit wide pointers
--> tests/ui/cast.rs:96:5
--> tests/ui/cast.rs:101:5
|
LL | 1u16 as isize;
| ^^^^^^^^^^^^^
@@ -286,13 +286,13 @@ LL | 1u16 as isize;
= note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types

error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:100:5
--> tests/ui/cast.rs:105:5
|
LL | 1u32 as isize;
| ^^^^^^^^^^^^^

error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:103:5
--> tests/ui/cast.rs:108:5
|
LL | 1u64 as isize;
| ^^^^^^^^^^^^^
@@ -304,55 +304,55 @@ LL | isize::try_from(1u64);
| ~~~~~~~~~~~~~~~~~~~~~

error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
--> tests/ui/cast.rs:103:5
--> tests/ui/cast.rs:108:5
|
LL | 1u64 as isize;
| ^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:108:5
--> tests/ui/cast.rs:113:5
|
LL | -1i32 as u32;
| ^^^^^^^^^^^^

error: casting `isize` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:111:5
--> tests/ui/cast.rs:116:5
|
LL | -1isize as usize;
| ^^^^^^^^^^^^^^^^

error: casting `i8` to `u8` may lose the sign of the value
--> tests/ui/cast.rs:122:5
--> tests/ui/cast.rs:127:5
|
LL | (i8::MIN).abs() as u8;
| ^^^^^^^^^^^^^^^^^^^^^

error: casting `i64` to `u64` may lose the sign of the value
--> tests/ui/cast.rs:126:5
--> tests/ui/cast.rs:131:5
|
LL | (-1i64).abs() as u64;
| ^^^^^^^^^^^^^^^^^^^^

error: casting `isize` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:127:5
--> tests/ui/cast.rs:132:5
|
LL | (-1isize).abs() as usize;
| ^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i64` to `u64` may lose the sign of the value
--> tests/ui/cast.rs:134:5
--> tests/ui/cast.rs:139:5
|
LL | (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i64` to `u64` may lose the sign of the value
--> tests/ui/cast.rs:149:5
--> tests/ui/cast.rs:154:5
|
LL | (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i64` to `i8` may truncate the value
--> tests/ui/cast.rs:200:5
--> tests/ui/cast.rs:205:5
|
LL | (-99999999999i64).min(1) as i8;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -364,7 +364,7 @@ LL | i8::try_from((-99999999999i64).min(1));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

error: casting `u64` to `u8` may truncate the value
--> tests/ui/cast.rs:214:5
--> tests/ui/cast.rs:219:5
|
LL | 999999u64.clamp(0, 256) as u8;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -376,7 +376,7 @@ LL | u8::try_from(999999u64.clamp(0, 256));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

error: casting `main::E2` to `u8` may truncate the value
--> tests/ui/cast.rs:237:21
--> tests/ui/cast.rs:242:21
|
LL | let _ = self as u8;
| ^^^^^^^^^^
@@ -388,7 +388,7 @@ LL | let _ = u8::try_from(self);
| ~~~~~~~~~~~~~~~~~~

error: casting `main::E2::B` to `u8` will truncate the value
--> tests/ui/cast.rs:239:21
--> tests/ui/cast.rs:244:21
|
LL | let _ = Self::B as u8;
| ^^^^^^^^^^^^^
@@ -397,7 +397,7 @@ LL | let _ = Self::B as u8;
= help: to override `-D warnings` add `#[allow(clippy::cast_enum_truncation)]`

error: casting `main::E5` to `i8` may truncate the value
--> tests/ui/cast.rs:281:21
--> tests/ui/cast.rs:286:21
|
LL | let _ = self as i8;
| ^^^^^^^^^^
@@ -409,13 +409,13 @@ LL | let _ = i8::try_from(self);
| ~~~~~~~~~~~~~~~~~~

error: casting `main::E5::A` to `i8` will truncate the value
--> tests/ui/cast.rs:283:21
--> tests/ui/cast.rs:288:21
|
LL | let _ = Self::A as i8;
| ^^^^^^^^^^^^^

error: casting `main::E6` to `i16` may truncate the value
--> tests/ui/cast.rs:300:21
--> tests/ui/cast.rs:305:21
|
LL | let _ = self as i16;
| ^^^^^^^^^^^
@@ -427,7 +427,7 @@ LL | let _ = i16::try_from(self);
| ~~~~~~~~~~~~~~~~~~~

error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:319:21
--> tests/ui/cast.rs:324:21
|
LL | let _ = self as usize;
| ^^^^^^^^^^^^^
@@ -439,7 +439,7 @@ LL | let _ = usize::try_from(self);
| ~~~~~~~~~~~~~~~~~~~~~

error: casting `main::E10` to `u16` may truncate the value
--> tests/ui/cast.rs:366:21
--> tests/ui/cast.rs:371:21
|
LL | let _ = self as u16;
| ^^^^^^^^^^^
@@ -451,7 +451,7 @@ LL | let _ = u16::try_from(self);
| ~~~~~~~~~~~~~~~~~~~

error: casting `u32` to `u8` may truncate the value
--> tests/ui/cast.rs:377:13
--> tests/ui/cast.rs:382:13
|
LL | let c = (q >> 16) as u8;
| ^^^^^^^^^^^^^^^
@@ -463,7 +463,7 @@ LL | let c = u8::try_from(q >> 16);
| ~~~~~~~~~~~~~~~~~~~~~

error: casting `u32` to `u8` may truncate the value
--> tests/ui/cast.rs:381:13
--> tests/ui/cast.rs:386:13
|
LL | let c = (q / 1000) as u8;
| ^^^^^^^^^^^^^^^^
@@ -475,180 +475,198 @@ LL | let c = u8::try_from(q / 1000);
| ~~~~~~~~~~~~~~~~~~~~~~

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:393:9
--> tests/ui/cast.rs:398:9
|
LL | (x * x) as u32;
| ^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:398:32
--> tests/ui/cast.rs:403:32
|
LL | let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
| ^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:400:5
--> tests/ui/cast.rs:405:5
|
LL | (2_i32).checked_pow(3).unwrap() as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:401:5
--> tests/ui/cast.rs:406:5
|
LL | (-2_i32).pow(3) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:406:5
--> tests/ui/cast.rs:411:5
|
LL | (-5_i32 % 2) as u32;
| ^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:408:5
--> tests/ui/cast.rs:413:5
|
LL | (-5_i32 % -2) as u32;
| ^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:411:5
--> tests/ui/cast.rs:416:5
|
LL | (-2_i32 >> 1) as u32;
| ^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:415:5
--> tests/ui/cast.rs:420:5
|
LL | (x * x) as u32;
| ^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:416:5
--> tests/ui/cast.rs:421:5
|
LL | (x * x * x) as u32;
| ^^^^^^^^^^^^^^^^^^

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:420:5
--> tests/ui/cast.rs:425:5
|
LL | (y * y * y * y * -2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:422:5
--> tests/ui/cast.rs:427:5
|
LL | (y * y * y / y * 2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:423:5
--> tests/ui/cast.rs:428:5
|
LL | (y * y / y * 2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:425:5
--> tests/ui/cast.rs:430:5
|
LL | (y / y * y * -2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^

error: equal expressions as operands to `/`
--> tests/ui/cast.rs:425:6
--> tests/ui/cast.rs:430:6
|
LL | (y / y * y * -2) as u16;
| ^^^^^
|
= note: `#[deny(clippy::eq_op)]` on by default

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:428:5
--> tests/ui/cast.rs:433:5
|
LL | (y + y + y + -2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:430:5
--> tests/ui/cast.rs:435:5
|
LL | (y + y + y + 2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:434:5
--> tests/ui/cast.rs:439:5
|
LL | (z + -2) as u16;
| ^^^^^^^^^^^^^^^

error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:436:5
--> tests/ui/cast.rs:441:5
|
LL | (z + z + 2) as u16;
| ^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:439:9
--> tests/ui/cast.rs:444:9
|
LL | (a * a * b * b * c * c) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:440:9
--> tests/ui/cast.rs:445:9
|
LL | (a * b * c) as u32;
| ^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:442:9
--> tests/ui/cast.rs:447:9
|
LL | (a * -b * c) as u32;
| ^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:444:9
--> tests/ui/cast.rs:449:9
|
LL | (a * b * c * c) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:445:9
--> tests/ui/cast.rs:450:9
|
LL | (a * -2) as u32;
| ^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:447:9
--> tests/ui/cast.rs:452:9
|
LL | (a * b * c * -2) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:449:9
--> tests/ui/cast.rs:454:9
|
LL | (a / b) as u32;
| ^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:450:9
--> tests/ui/cast.rs:455:9
|
LL | (a / b * c) as u32;
| ^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:452:9
--> tests/ui/cast.rs:457:9
|
LL | (a / b + b * c) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:454:9
--> tests/ui/cast.rs:459:9
|
LL | a.saturating_pow(3) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^

error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:456:9
--> tests/ui/cast.rs:461:9
|
LL | (a.abs() * b.pow(2) / c.abs()) as u32
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to 85 previous errors
error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:468:5
|
LL | bar.unwrap().unwrap() as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
help: ... or use `try_from` and handle the error accordingly
|
LL | usize::try_from(bar.unwrap().unwrap())
|

error: casting `i64` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:468:5
|
LL | bar.unwrap().unwrap() as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to 87 previous errors