Skip to content

Commit c6c7408

Browse files
Samarth1696Samarth1696
committed
error notations added
1 parent bed4441 commit c6c7408

File tree

3 files changed

+54
-22
lines changed

3 files changed

+54
-22
lines changed

‎tests/ui/non_zero_suggestions.fixed‎

Lines changed: 19 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3,40 +3,45 @@
33
use std::num::{NonZeroI16, NonZeroI8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};
44

55
fn main() {
6-
// Positive test cases (lint should trigger)
7-
6+
/// Positive test cases (lint should trigger)
87
// U32 -> U64
98
let x: u64 = 100;
109
let y = NonZeroU32::new(10).unwrap();
1110
let r1 = x / NonZeroU64::from(y);
11+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
12+
1213
let r2 = x % NonZeroU64::from(y);
14+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
1315

1416
// U16 -> U32
1517
let a: u32 = 50;
1618
let b = NonZeroU16::new(5).unwrap();
1719
let r3 = a / NonZeroU32::from(b);
20+
//~^ ERROR: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
1821

1922
// I8 -> I16
2023
let c: i16 = 25;
2124
let d = NonZeroI8::new(3).unwrap();
2225
let r4 = NonZeroI16::from(d);
26+
//~^ ERROR: consider using `NonZeroI16::from()` for more efficient and type-safe conversion
2327

2428
// Different operations
2529
let m: u64 = 400;
2630
let n = NonZeroU32::new(20).unwrap();
2731
let r5 = m / NonZeroU64::from(n);
32+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
2833

29-
// Edge cases
30-
34+
/// Edge cases
3135
// Using the max value of a type
3236
let max_u32 = NonZeroU32::new(u32::MAX).unwrap();
3337
let r6 = NonZeroU64::from(max_u32);
38+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
3439

3540
// Chained method calls
3641
let _ = NonZeroU64::from(NonZeroU32::new(10).unwrap());
42+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
3743

38-
// Negative test cases (lint should not trigger)
39-
44+
/// Negative test cases (lint should not trigger)
4045
// Same size types
4146
let e: u32 = 200;
4247
let f = NonZeroU32::new(20).unwrap();
@@ -56,8 +61,16 @@ fn main() {
5661
// Additional function to test the lint in a different context
5762
fn divide_numbers(x: u64, y: NonZeroU32) -> u64 {
5863
x / NonZeroU64::from(y)
64+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
5965
}
6066

67+
fn no_bin_exp(x: u64, y: NonZeroU32) -> u64 {
68+
NonZeroU64::from(y)
69+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
70+
}
71+
72+
fn some_fn_that_only_takes_u64(_: u64) {}
73+
6174
struct Calculator {
6275
value: u64,
6376
}

‎tests/ui/non_zero_suggestions.rs‎

Lines changed: 19 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3,40 +3,45 @@
33
use std::num::{NonZeroI16, NonZeroI8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};
44

55
fn main() {
6-
// Positive test cases (lint should trigger)
7-
6+
/// Positive test cases (lint should trigger)
87
// U32 -> U64
98
let x: u64 = 100;
109
let y = NonZeroU32::new(10).unwrap();
1110
let r1 = x / u64::from(y.get());
11+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
12+
1213
let r2 = x % u64::from(y.get());
14+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
1315

1416
// U16 -> U32
1517
let a: u32 = 50;
1618
let b = NonZeroU16::new(5).unwrap();
1719
let r3 = a / u32::from(b.get());
20+
//~^ ERROR: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
1821

1922
// I8 -> I16
2023
let c: i16 = 25;
2124
let d = NonZeroI8::new(3).unwrap();
2225
let r4 = i16::from(d.get());
26+
//~^ ERROR: consider using `NonZeroI16::from()` for more efficient and type-safe conversion
2327

2428
// Different operations
2529
let m: u64 = 400;
2630
let n = NonZeroU32::new(20).unwrap();
2731
let r5 = m / u64::from(n.get());
32+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
2833

29-
// Edge cases
30-
34+
/// Edge cases
3135
// Using the max value of a type
3236
let max_u32 = NonZeroU32::new(u32::MAX).unwrap();
3337
let r6 = u64::from(max_u32.get());
38+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
3439

3540
// Chained method calls
3641
let _ = u64::from(NonZeroU32::new(10).unwrap().get());
42+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
3743

38-
// Negative test cases (lint should not trigger)
39-
44+
/// Negative test cases (lint should not trigger)
4045
// Same size types
4146
let e: u32 = 200;
4247
let f = NonZeroU32::new(20).unwrap();
@@ -56,8 +61,16 @@ fn main() {
5661
// Additional function to test the lint in a different context
5762
fn divide_numbers(x: u64, y: NonZeroU32) -> u64 {
5863
x / u64::from(y.get())
64+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
5965
}
6066

67+
fn no_bin_exp(x: u64, y: NonZeroU32) -> u64 {
68+
u64::from(y.get())
69+
//~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
70+
}
71+
72+
fn some_fn_that_only_takes_u64(_: u64) {}
73+
6174
struct Calculator {
6275
value: u64,
6376
}

‎tests/ui/non_zero_suggestions.stderr‎

Lines changed: 16 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
2-
--> tests/ui/non_zero_suggestions.rs:11:18
2+
--> tests/ui/non_zero_suggestions.rs:10:18
33
|
44
LL | let r1 = x / u64::from(y.get());
55
| ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
@@ -8,52 +8,58 @@ LL | let r1 = x / u64::from(y.get());
88
= help: to override `-D warnings` add `#[allow(clippy::non_zero_suggestions)]`
99

1010
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
11-
--> tests/ui/non_zero_suggestions.rs:12:18
11+
--> tests/ui/non_zero_suggestions.rs:13:18
1212
|
1313
LL | let r2 = x % u64::from(y.get());
1414
| ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
1515

1616
error: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
17-
--> tests/ui/non_zero_suggestions.rs:17:18
17+
--> tests/ui/non_zero_suggestions.rs:19:18
1818
|
1919
LL | let r3 = a / u32::from(b.get());
2020
| ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU32::from(b)`
2121

2222
error: consider using `NonZeroI16::from()` for more efficient and type-safe conversion
23-
--> tests/ui/non_zero_suggestions.rs:22:14
23+
--> tests/ui/non_zero_suggestions.rs:25:14
2424
|
2525
LL | let r4 = i16::from(d.get());
2626
| ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroI16::from(d)`
2727

2828
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
29-
--> tests/ui/non_zero_suggestions.rs:27:18
29+
--> tests/ui/non_zero_suggestions.rs:31:18
3030
|
3131
LL | let r5 = m / u64::from(n.get());
3232
| ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(n)`
3333

3434
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
35-
--> tests/ui/non_zero_suggestions.rs:33:14
35+
--> tests/ui/non_zero_suggestions.rs:37:14
3636
|
3737
LL | let r6 = u64::from(max_u32.get());
3838
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(max_u32)`
3939

4040
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
41-
--> tests/ui/non_zero_suggestions.rs:36:13
41+
--> tests/ui/non_zero_suggestions.rs:41:13
4242
|
4343
LL | let _ = u64::from(NonZeroU32::new(10).unwrap().get());
4444
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(NonZeroU32::new(10).unwrap())`
4545

4646
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
47-
--> tests/ui/non_zero_suggestions.rs:58:9
47+
--> tests/ui/non_zero_suggestions.rs:63:9
4848
|
4949
LL | x / u64::from(y.get())
5050
| ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
5151

5252
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
53-
--> tests/ui/non_zero_suggestions.rs:67:22
53+
--> tests/ui/non_zero_suggestions.rs:68:5
54+
|
55+
LL | u64::from(y.get())
56+
| ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
57+
58+
error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
59+
--> tests/ui/non_zero_suggestions.rs:80:22
5460
|
5561
LL | self.value / u64::from(divisor.get())
5662
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(divisor)`
5763

58-
error: aborting due to 9 previous errors
64+
error: aborting due to 10 previous errors
5965

0 commit comments

Comments
 (0)