Use libtest errors check to better enforce UI testing

GuillaumeGomez · GuillaumeGomez · commit 04b710b5695a · 2023-07-25T18:43:58.000+02:00
diff --git a/tests/ui/needless_pass_by_ref_mut.rs b/tests/ui/needless_pass_by_ref_mut.rs
@@ -3,8 +3,8 @@
 
 use std::ptr::NonNull;
 
-// Should only warn for `s`.
 fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     *x += *b + s.len() as u32;
 }
 
@@ -28,8 +28,8 @@ fn foo5(s: &mut Vec<u32>) {
     foo2(s);
 }
 
-// Should warn.
 fn foo6(s: &mut Vec<u32>) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     non_mut_ref(s);
 }
 
@@ -41,13 +41,13 @@ impl Bar {
     // Should not warn on `&mut self`.
     fn bar(&mut self) {}
 
-    // Should warn about `vec`
     fn mushroom(&self, vec: &mut Vec<i32>) -> usize {
+        //~^ ERROR: this argument is a mutable reference, but not used mutably
         vec.len()
     }
 
-    // Should warn about `vec` (and not `self`).
     fn badger(&mut self, vec: &mut Vec<i32>) -> usize {
+        //~^ ERROR: this argument is a mutable reference, but not used mutably
         vec.len()
     }
 }
@@ -123,36 +123,36 @@ async fn f7(x: &mut i32, y: i32, z: &mut i32, a: i32) {
     *z += 1;
 }
 
-// Should warn.
 async fn a1(x: &mut i32) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", x);
 }
-// Should warn.
 async fn a2(x: &mut i32, y: String) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", x);
 }
-// Should warn.
 async fn a3(x: &mut i32, y: String, z: String) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", x);
 }
-// Should warn.
 async fn a4(x: &mut i32, y: i32) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", x);
 }
-// Should warn.
 async fn a5(x: i32, y: &mut i32) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", x);
 }
-// Should warn.
 async fn a6(x: i32, y: &mut i32) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", x);
 }
-// Should warn.
 async fn a7(x: i32, y: i32, z: &mut i32) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", z);
 }
-// Should warn.
 async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
     println!("{:?}", z);
 }
 
@@ -185,13 +185,15 @@ fn used_as_path(s: &mut u32) {}
 fn lint_attr(s: &mut u32) {}
 
 #[cfg(not(feature = "a"))]
-// Should warn with note.
 fn cfg_warn(s: &mut u32) {}
+//~^ ERROR: this argument is a mutable reference, but not used mutably
+//~| NOTE: this is cfg-gated and may require further changes
 
 #[cfg(not(feature = "a"))]
 mod foo {
-    // Should warn with note.
     fn cfg_warn(s: &mut u32) {}
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~| NOTE: this is cfg-gated and may require further changes
 }
 
 fn main() {
diff --git a/tests/ui/needless_pass_by_ref_mut.stderr b/tests/ui/needless_pass_by_ref_mut.stderr
@@ -1,85 +1,85 @@
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:7:11
+  --> $DIR/needless_pass_by_ref_mut.rs:6:11
    |
 LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    |           ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
    |
    = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:32:12
+  --> $DIR/needless_pass_by_ref_mut.rs:31:12
    |
 LL | fn foo6(s: &mut Vec<u32>) {
    |            ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:45:29
+  --> $DIR/needless_pass_by_ref_mut.rs:44:29
    |
 LL |     fn mushroom(&self, vec: &mut Vec<i32>) -> usize {
    |                             ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:50:31
+  --> $DIR/needless_pass_by_ref_mut.rs:49:31
    |
 LL |     fn badger(&mut self, vec: &mut Vec<i32>) -> usize {
    |                               ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:127:16
+  --> $DIR/needless_pass_by_ref_mut.rs:126:16
    |
 LL | async fn a1(x: &mut i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:131:16
+  --> $DIR/needless_pass_by_ref_mut.rs:130:16
    |
 LL | async fn a2(x: &mut i32, y: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:135:16
+  --> $DIR/needless_pass_by_ref_mut.rs:134:16
    |
 LL | async fn a3(x: &mut i32, y: String, z: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:139:16
+  --> $DIR/needless_pass_by_ref_mut.rs:138:16
    |
 LL | async fn a4(x: &mut i32, y: i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:143:24
+  --> $DIR/needless_pass_by_ref_mut.rs:142:24
    |
 LL | async fn a5(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:147:24
+  --> $DIR/needless_pass_by_ref_mut.rs:146:24
    |
 LL | async fn a6(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:151:32
+  --> $DIR/needless_pass_by_ref_mut.rs:150:32
    |
 LL | async fn a7(x: i32, y: i32, z: &mut i32) {
    |                                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:155:24
+  --> $DIR/needless_pass_by_ref_mut.rs:154:24
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:155:45
+  --> $DIR/needless_pass_by_ref_mut.rs:154:45
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                                             ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:189:16
+  --> $DIR/needless_pass_by_ref_mut.rs:188:16
    |
 LL | fn cfg_warn(s: &mut u32) {}
    |                ^^^^^^^^ help: consider changing to: `&u32`

Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,8 @@`
`3`	`3`
`4`	`4`	`use std::ptr::NonNull;`
`5`	`5`
`6`		-// Should only warn for `s`.
`7`	`6`	`fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {`
	`7`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`8`	`8`	`x += b + s.len() as u32;`
`9`	`9`	`}`
`10`	`10`
`@@ -28,8 +28,8 @@ fn foo5(s: &mut Vec<u32>) {`
`28`	`28`	`foo2(s);`
`29`	`29`	`}`
`30`	`30`
`31`		`-// Should warn.`
`32`	`31`	`fn foo6(s: &mut Vec<u32>) {`
	`32`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`33`	`33`	`non_mut_ref(s);`
`34`	`34`	`}`
`35`	`35`
`@@ -41,13 +41,13 @@ impl Bar {`
`41`	`41`	// Should not warn on `&mut self`.
`42`	`42`	`fn bar(&mut self) {}`
`43`	`43`
`44`		- // Should warn about `vec`
`45`	`44`	`fn mushroom(&self, vec: &mut Vec<i32>) -> usize {`
	`45`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`46`	`46`	`vec.len()`
`47`	`47`	`}`
`48`	`48`
`49`		- // Should warn about `vec` (and not `self`).
`50`	`49`	`fn badger(&mut self, vec: &mut Vec<i32>) -> usize {`
	`50`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`51`	`51`	`vec.len()`
`52`	`52`	`}`
`53`	`53`	`}`
`@@ -123,36 +123,36 @@ async fn f7(x: &mut i32, y: i32, z: &mut i32, a: i32) {`
`123`	`123`	`*z += 1;`
`124`	`124`	`}`
`125`	`125`
`126`		`-// Should warn.`
`127`	`126`	`async fn a1(x: &mut i32) {`
	`127`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`128`	`128`	`println!("{:?}", x);`
`129`	`129`	`}`
`130`		`-// Should warn.`
`131`	`130`	`async fn a2(x: &mut i32, y: String) {`
	`131`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`132`	`132`	`println!("{:?}", x);`
`133`	`133`	`}`
`134`		`-// Should warn.`
`135`	`134`	`async fn a3(x: &mut i32, y: String, z: String) {`
	`135`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`136`	`136`	`println!("{:?}", x);`
`137`	`137`	`}`
`138`		`-// Should warn.`
`139`	`138`	`async fn a4(x: &mut i32, y: i32) {`
	`139`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`140`	`140`	`println!("{:?}", x);`
`141`	`141`	`}`
`142`		`-// Should warn.`
`143`	`142`	`async fn a5(x: i32, y: &mut i32) {`
	`143`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`144`	`144`	`println!("{:?}", x);`
`145`	`145`	`}`
`146`		`-// Should warn.`
`147`	`146`	`async fn a6(x: i32, y: &mut i32) {`
	`147`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`148`	`148`	`println!("{:?}", x);`
`149`	`149`	`}`
`150`		`-// Should warn.`
`151`	`150`	`async fn a7(x: i32, y: i32, z: &mut i32) {`
	`151`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`152`	`152`	`println!("{:?}", z);`
`153`	`153`	`}`
`154`		`-// Should warn.`
`155`	`154`	`async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {`
	`155`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
`156`	`156`	`println!("{:?}", z);`
`157`	`157`	`}`
`158`	`158`
`@@ -185,13 +185,15 @@ fn used_as_path(s: &mut u32) {}`
`185`	`185`	`fn lint_attr(s: &mut u32) {}`
`186`	`186`
`187`	`187`	`#[cfg(not(feature = "a"))]`
`188`		`-// Should warn with note.`
`189`	`188`	`fn cfg_warn(s: &mut u32) {}`
	`189`	`+//~^ ERROR: this argument is a mutable reference, but not used mutably`
	`190`	`+//~\| NOTE: this is cfg-gated and may require further changes`
`190`	`191`
`191`	`192`	`#[cfg(not(feature = "a"))]`
`192`	`193`	`mod foo {`
`193`		`- // Should warn with note.`
`194`	`194`	`fn cfg_warn(s: &mut u32) {}`
	`195`	`+ //~^ ERROR: this argument is a mutable reference, but not used mutably`
	`196`	`+ //~\| NOTE: this is cfg-gated and may require further changes`
`195`	`197`	`}`
`196`	`198`
`197`	`199`	`fn main() {`