Add error-annotations in tests for unnecessary_fallible_conversions

roife · roife · commit 1cce757672d9 · 2024-01-02T01:29:20.000+08:00
diff --git a/tests/ui/unnecessary_fallible_conversions.fixed b/tests/ui/unnecessary_fallible_conversions.fixed
@@ -1,18 +1,43 @@
 #![warn(clippy::unnecessary_fallible_conversions)]
 
 fn main() {
+    // --- TryFromMethod `T::try_from(u)` ---
+
     let _: i64 = 0i32.into();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _: i64 = 0i32.into();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryFromFunction `T::try_from(U)` ---
 
     let _ = i64::from(0i32);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _ = i64::from(0i32);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryIntoFunction `U::try_into(t)` ---
 
     let _: i64 = i32::into(0);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _: i64 = i32::into(0i32);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryFromFunction `<T as TryFrom<U>>::try_from(U)` ---
 
     let _ = <i64 as From<i32>>::from(0);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _ = <i64 as From<i32>>::from(0);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryIntoFunction `<U as TryInto<_>>::try_into(U)` ---
 
     let _: i64 = <i32 as Into<_>>::into(0);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _: i64 = <i32 as Into<_>>::into(0);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
 }
diff --git a/tests/ui/unnecessary_fallible_conversions.rs b/tests/ui/unnecessary_fallible_conversions.rs
@@ -1,18 +1,43 @@
 #![warn(clippy::unnecessary_fallible_conversions)]
 
 fn main() {
+    // --- TryFromMethod `T::try_from(u)` ---
+
     let _: i64 = 0i32.try_into().unwrap();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _: i64 = 0i32.try_into().expect("can't happen");
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryFromFunction `T::try_from(U)` ---
 
     let _ = i64::try_from(0i32).unwrap();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _ = i64::try_from(0i32).expect("can't happen");
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryIntoFunction `U::try_into(t)` ---
 
     let _: i64 = i32::try_into(0).unwrap();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _: i64 = i32::try_into(0i32).expect("can't happen");
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryFromFunction `<T as TryFrom<U>>::try_from(U)` ---
 
     let _ = <i64 as TryFrom<i32>>::try_from(0).unwrap();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _ = <i64 as TryFrom<i32>>::try_from(0).expect("can't happen");
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // --- TryIntoFunction `<U as TryInto<_>>::try_into(U)` ---
 
     let _: i64 = <i32 as TryInto<_>>::try_into(0).unwrap();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
     let _: i64 = <i32 as TryInto<_>>::try_into(0).expect("can't happen");
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
 }
diff --git a/tests/ui/unnecessary_fallible_conversions.stderr b/tests/ui/unnecessary_fallible_conversions.stderr
@@ -1,5 +1,5 @@
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:4:23
+  --> $DIR/unnecessary_fallible_conversions.rs:6:23
    |
 LL |     let _: i64 = 0i32.try_into().unwrap();
    |                       ^^^^^^^^^^^^^^^^^^^
@@ -14,7 +14,7 @@ LL +     let _: i64 = 0i32.into();
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:5:23
+  --> $DIR/unnecessary_fallible_conversions.rs:9:23
    |
 LL |     let _: i64 = 0i32.try_into().expect("can't happen");
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -27,7 +27,7 @@ LL +     let _: i64 = 0i32.into();
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:7:13
+  --> $DIR/unnecessary_fallible_conversions.rs:14:13
    |
 LL |     let _ = i64::try_from(0i32).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL +     let _ = i64::from(0i32);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:8:13
+  --> $DIR/unnecessary_fallible_conversions.rs:17:13
    |
 LL |     let _ = i64::try_from(0i32).expect("can't happen");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,7 +53,7 @@ LL +     let _ = i64::from(0i32);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:10:18
+  --> $DIR/unnecessary_fallible_conversions.rs:22:18
    |
 LL |     let _: i64 = i32::try_into(0).unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL +     let _: i64 = i32::into(0);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:11:18
+  --> $DIR/unnecessary_fallible_conversions.rs:25:18
    |
 LL |     let _: i64 = i32::try_into(0i32).expect("can't happen");
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ LL +     let _: i64 = i32::into(0i32);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:13:13
+  --> $DIR/unnecessary_fallible_conversions.rs:30:13
    |
 LL |     let _ = <i64 as TryFrom<i32>>::try_from(0).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL +     let _ = <i64 as From<i32>>::from(0);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:14:13
+  --> $DIR/unnecessary_fallible_conversions.rs:33:13
    |
 LL |     let _ = <i64 as TryFrom<i32>>::try_from(0).expect("can't happen");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL +     let _ = <i64 as From<i32>>::from(0);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:16:18
+  --> $DIR/unnecessary_fallible_conversions.rs:38:18
    |
 LL |     let _: i64 = <i32 as TryInto<_>>::try_into(0).unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL +     let _: i64 = <i32 as Into<_>>::into(0);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:17:18
+  --> $DIR/unnecessary_fallible_conversions.rs:41:18
    |
 LL |     let _: i64 = <i32 as TryInto<_>>::try_into(0).expect("can't happen");
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`error: use of a fallible conversion when an infallible one could be used`
`2`		`- --> $DIR/unnecessary_fallible_conversions.rs:4:23`
	`2`	`+ --> $DIR/unnecessary_fallible_conversions.rs:6:23`
`3`	`3`	`\|`
`4`	`4`	`LL \| let _: i64 = 0i32.try_into().unwrap();`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^`
`@@ -14,7 +14,7 @@ LL + let _: i64 = 0i32.into();`
`14`	`14`	`\|`
`15`	`15`
`16`	`16`	`error: use of a fallible conversion when an infallible one could be used`
`17`		`- --> $DIR/unnecessary_fallible_conversions.rs:5:23`
	`17`	`+ --> $DIR/unnecessary_fallible_conversions.rs:9:23`
`18`	`18`	`\|`
`19`	`19`	`LL \| let _: i64 = 0i32.try_into().expect("can't happen");`
`20`	`20`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -27,7 +27,7 @@ LL + let _: i64 = 0i32.into();`
`27`	`27`	`\|`
`28`	`28`
`29`	`29`	`error: use of a fallible conversion when an infallible one could be used`
`30`		`- --> $DIR/unnecessary_fallible_conversions.rs:7:13`
	`30`	`+ --> $DIR/unnecessary_fallible_conversions.rs:14:13`
`31`	`31`	`\|`
`32`	`32`	`LL \| let _ = i64::try_from(0i32).unwrap();`
`33`	`33`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -40,7 +40,7 @@ LL + let _ = i64::from(0i32);`
`40`	`40`	`\|`
`41`	`41`
`42`	`42`	`error: use of a fallible conversion when an infallible one could be used`
`43`		`- --> $DIR/unnecessary_fallible_conversions.rs:8:13`
	`43`	`+ --> $DIR/unnecessary_fallible_conversions.rs:17:13`
`44`	`44`	`\|`
`45`	`45`	`LL \| let _ = i64::try_from(0i32).expect("can't happen");`
`46`	`46`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -53,7 +53,7 @@ LL + let _ = i64::from(0i32);`
`53`	`53`	`\|`
`54`	`54`
`55`	`55`	`error: use of a fallible conversion when an infallible one could be used`
`56`		`- --> $DIR/unnecessary_fallible_conversions.rs:10:18`
	`56`	`+ --> $DIR/unnecessary_fallible_conversions.rs:22:18`
`57`	`57`	`\|`
`58`	`58`	`LL \| let _: i64 = i32::try_into(0).unwrap();`
`59`	`59`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -66,7 +66,7 @@ LL + let _: i64 = i32::into(0);`
`66`	`66`	`\|`
`67`	`67`
`68`	`68`	`error: use of a fallible conversion when an infallible one could be used`
`69`		`- --> $DIR/unnecessary_fallible_conversions.rs:11:18`
	`69`	`+ --> $DIR/unnecessary_fallible_conversions.rs:25:18`
`70`	`70`	`\|`
`71`	`71`	`LL \| let _: i64 = i32::try_into(0i32).expect("can't happen");`
`72`	`72`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -79,7 +79,7 @@ LL + let _: i64 = i32::into(0i32);`
`79`	`79`	`\|`
`80`	`80`
`81`	`81`	`error: use of a fallible conversion when an infallible one could be used`
`82`		`- --> $DIR/unnecessary_fallible_conversions.rs:13:13`
	`82`	`+ --> $DIR/unnecessary_fallible_conversions.rs:30:13`
`83`	`83`	`\|`
`84`	`84`	`LL \| let _ = <i64 as TryFrom<i32>>::try_from(0).unwrap();`
`85`	`85`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -92,7 +92,7 @@ LL + let _ = <i64 as From<i32>>::from(0);`
`92`	`92`	`\|`
`93`	`93`
`94`	`94`	`error: use of a fallible conversion when an infallible one could be used`
`95`		`- --> $DIR/unnecessary_fallible_conversions.rs:14:13`
	`95`	`+ --> $DIR/unnecessary_fallible_conversions.rs:33:13`
`96`	`96`	`\|`
`97`	`97`	`LL \| let _ = <i64 as TryFrom<i32>>::try_from(0).expect("can't happen");`
`98`	`98`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -105,7 +105,7 @@ LL + let _ = <i64 as From<i32>>::from(0);`
`105`	`105`	`\|`
`106`	`106`
`107`	`107`	`error: use of a fallible conversion when an infallible one could be used`
`108`		`- --> $DIR/unnecessary_fallible_conversions.rs:16:18`
	`108`	`+ --> $DIR/unnecessary_fallible_conversions.rs:38:18`
`109`	`109`	`\|`
`110`	`110`	`LL \| let _: i64 = <i32 as TryInto<_>>::try_into(0).unwrap();`
`111`	`111`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -118,7 +118,7 @@ LL + let _: i64 = <i32 as Into<_>>::into(0);`
`118`	`118`	`\|`
`119`	`119`
`120`	`120`	`error: use of a fallible conversion when an infallible one could be used`
`121`		`- --> $DIR/unnecessary_fallible_conversions.rs:17:18`
	`121`	`+ --> $DIR/unnecessary_fallible_conversions.rs:41:18`
`122`	`122`	`\|`
`123`	`123`	`LL \| let _: i64 = <i32 as TryInto<_>>::try_into(0).expect("can't happen");`
`124`	`124`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`