blob: 4573896ecd6738e27e4a79cf0ed77653c070cc34 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
#![warn(clippy::non_zero_suggestions)]
use std::num::{NonZeroI8, NonZeroI16, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroUsize};
fn main() {
/// Positive test cases (lint should trigger)
// U32 -> U64
let x: u64 = 100;
let y = NonZeroU32::new(10).unwrap();
let r1 = x / NonZeroU64::from(y);
//~^ non_zero_suggestions
let r2 = x % NonZeroU64::from(y);
//~^ non_zero_suggestions
// U16 -> U32
let a: u32 = 50;
let b = NonZeroU16::new(5).unwrap();
let r3 = a / NonZeroU32::from(b);
//~^ non_zero_suggestions
let x = NonZeroU64::from(NonZeroU32::new(5).unwrap());
//~^ non_zero_suggestions
/// Negative test cases (lint should not trigger)
// Left hand side expressions should not be triggered
let c: u32 = 50;
let d = NonZeroU16::new(5).unwrap();
let r4 = u32::from(b.get()) / a;
// Should not trigger for any other operand other than `/` and `%`
let r5 = a + u32::from(b.get());
let r6 = a - u32::from(b.get());
// Same size types
let e: u32 = 200;
let f = NonZeroU32::new(20).unwrap();
let r7 = e / f.get();
// Smaller to larger, but not NonZero
let g: u64 = 1000;
let h: u32 = 50;
let r8 = g / u64::from(h);
// Using From correctly
let k: u64 = 300;
let l = NonZeroU32::new(15).unwrap();
let r9 = k / NonZeroU64::from(l);
}
// Additional function to test the lint in a different context
fn divide_numbers(x: u64, y: NonZeroU32) -> u64 {
x / NonZeroU64::from(y)
//~^ non_zero_suggestions
}
struct Calculator {
value: u64,
}
impl Calculator {
fn divide(&self, divisor: NonZeroU32) -> u64 {
self.value / NonZeroU64::from(divisor)
//~^ non_zero_suggestions
}
}
|
