error notations added

3 files changed, 54 insertions, 22 deletions

diff --git a/tests/ui/non_zero_suggestions.fixed b/tests/ui/non_zero_suggestions.fixed
index b33de1ef03f..d7e6b19edc1 100644
--- a/tests/ui/non_zero_suggestions.fixed
+++ b/tests/ui/non_zero_suggestions.fixed
@@ -3,40 +3,45 @@
 use std::num::{NonZeroI16, NonZeroI8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};
 
 fn main() {
-    // Positive test cases (lint should trigger)
-
+    /// Positive test cases (lint should trigger)
     // U32 -> U64
     let x: u64 = 100;
     let y = NonZeroU32::new(10).unwrap();
     let r1 = x / NonZeroU64::from(y);
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+
     let r2 = x % NonZeroU64::from(y);
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
     // U16 -> U32
     let a: u32 = 50;
     let b = NonZeroU16::new(5).unwrap();
     let r3 = a / NonZeroU32::from(b);
+    //~^ ERROR: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
 
     // I8 -> I16
     let c: i16 = 25;
     let d = NonZeroI8::new(3).unwrap();
     let r4 = NonZeroI16::from(d);
+    //~^ ERROR: consider using `NonZeroI16::from()` for more efficient and type-safe conversion
 
     // Different operations
     let m: u64 = 400;
     let n = NonZeroU32::new(20).unwrap();
     let r5 = m / NonZeroU64::from(n);
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
-    // Edge cases
-
+    /// Edge cases
     // Using the max value of a type
     let max_u32 = NonZeroU32::new(u32::MAX).unwrap();
     let r6 = NonZeroU64::from(max_u32);
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
     // Chained method calls
     let _ = NonZeroU64::from(NonZeroU32::new(10).unwrap());
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
-    // Negative test cases (lint should not trigger)
-
+    /// Negative test cases (lint should not trigger)
     // Same size types
     let e: u32 = 200;
     let f = NonZeroU32::new(20).unwrap();
@@ -56,8 +61,16 @@ fn main() {
 // Additional function to test the lint in a different context
 fn divide_numbers(x: u64, y: NonZeroU32) -> u64 {
     x / NonZeroU64::from(y)
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 }
 
+fn no_bin_exp(x: u64, y: NonZeroU32) -> u64 {
+    NonZeroU64::from(y)
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+}
+
+fn some_fn_that_only_takes_u64(_: u64) {}
+
 struct Calculator {
     value: u64,
 }
diff --git a/tests/ui/non_zero_suggestions.rs b/tests/ui/non_zero_suggestions.rs
index 27089eaf86e..8f256dabcb8 100644
--- a/tests/ui/non_zero_suggestions.rs
+++ b/tests/ui/non_zero_suggestions.rs
@@ -3,40 +3,45 @@
 use std::num::{NonZeroI16, NonZeroI8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};
 
 fn main() {
-    // Positive test cases (lint should trigger)
-
+    /// Positive test cases (lint should trigger)
     // U32 -> U64
     let x: u64 = 100;
     let y = NonZeroU32::new(10).unwrap();
     let r1 = x / u64::from(y.get());
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+
     let r2 = x % u64::from(y.get());
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
     // U16 -> U32
     let a: u32 = 50;
     let b = NonZeroU16::new(5).unwrap();
     let r3 = a / u32::from(b.get());
+    //~^ ERROR: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
 
     // I8 -> I16
     let c: i16 = 25;
     let d = NonZeroI8::new(3).unwrap();
     let r4 = i16::from(d.get());
+    //~^ ERROR: consider using `NonZeroI16::from()` for more efficient and type-safe conversion
 
     // Different operations
     let m: u64 = 400;
     let n = NonZeroU32::new(20).unwrap();
     let r5 = m / u64::from(n.get());
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
-    // Edge cases
-
+    /// Edge cases
     // Using the max value of a type
     let max_u32 = NonZeroU32::new(u32::MAX).unwrap();
     let r6 = u64::from(max_u32.get());
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
     // Chained method calls
     let _ = u64::from(NonZeroU32::new(10).unwrap().get());
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 
-    // Negative test cases (lint should not trigger)
-
+    /// Negative test cases (lint should not trigger)
     // Same size types
     let e: u32 = 200;
     let f = NonZeroU32::new(20).unwrap();
@@ -56,8 +61,16 @@ fn main() {
 // Additional function to test the lint in a different context
 fn divide_numbers(x: u64, y: NonZeroU32) -> u64 {
     x / u64::from(y.get())
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
 }
 
+fn no_bin_exp(x: u64, y: NonZeroU32) -> u64 {
+    u64::from(y.get())
+    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+}
+
+fn some_fn_that_only_takes_u64(_: u64) {}
+
 struct Calculator {
     value: u64,
 }
diff --git a/tests/ui/non_zero_suggestions.stderr b/tests/ui/non_zero_suggestions.stderr
index 4c86720c308..b231c8d216e 100644
--- a/tests/ui/non_zero_suggestions.stderr
+++ b/tests/ui/non_zero_suggestions.stderr
@@ -1,5 +1,5 @@
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:11:18
+  --> tests/ui/non_zero_suggestions.rs:10:18
    |
 LL |     let r1 = x / u64::from(y.get());
    |                  ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
@@ -8,52 +8,58 @@ LL |     let r1 = x / u64::from(y.get());
    = help: to override `-D warnings` add `#[allow(clippy::non_zero_suggestions)]`
 
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:12:18
+  --> tests/ui/non_zero_suggestions.rs:13:18
    |
 LL |     let r2 = x % u64::from(y.get());
    |                  ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
 
 error: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:17:18
+  --> tests/ui/non_zero_suggestions.rs:19:18
    |
 LL |     let r3 = a / u32::from(b.get());
    |                  ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU32::from(b)`
 
 error: consider using `NonZeroI16::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:22:14
+  --> tests/ui/non_zero_suggestions.rs:25:14
    |
 LL |     let r4 = i16::from(d.get());
    |              ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroI16::from(d)`
 
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:27:18
+  --> tests/ui/non_zero_suggestions.rs:31:18
    |
 LL |     let r5 = m / u64::from(n.get());
    |                  ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(n)`
 
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:33:14
+  --> tests/ui/non_zero_suggestions.rs:37:14
    |
 LL |     let r6 = u64::from(max_u32.get());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(max_u32)`
 
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:36:13
+  --> tests/ui/non_zero_suggestions.rs:41:13
    |
 LL |     let _ = u64::from(NonZeroU32::new(10).unwrap().get());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(NonZeroU32::new(10).unwrap())`
 
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:58:9
+  --> tests/ui/non_zero_suggestions.rs:63:9
    |
 LL |     x / u64::from(y.get())
    |         ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
 
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions.rs:67:22
+  --> tests/ui/non_zero_suggestions.rs:68:5
+   |
+LL |     u64::from(y.get())
+   |     ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
+
+error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+  --> tests/ui/non_zero_suggestions.rs:80:22
    |
 LL |         self.value / u64::from(divisor.get())
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(divisor)`
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors