Attributes cleanup in tests [19/20]

Author: samueltardieu

tests/ui/unnecessary_first_then_check.fixed

@@ -1,5 +1,6 @@
 #![warn(clippy::unnecessary_first_then_check)]
-#![allow(clippy::useless_vec, clippy::const_is_empty)]
+#![allow(clippy::const_is_empty)]
+#![expect(clippy::useless_vec)]
 
 fn main() {
     let s = [1, 2, 3];

tests/ui/unnecessary_first_then_check.rs

@@ -1,5 +1,6 @@
 #![warn(clippy::unnecessary_first_then_check)]
-#![allow(clippy::useless_vec, clippy::const_is_empty)]
+#![allow(clippy::const_is_empty)]
+#![expect(clippy::useless_vec)]
 
 fn main() {
     let s = [1, 2, 3];

tests/ui/unnecessary_first_then_check.stderr

@@ -1,5 +1,5 @@
 error: unnecessary use of `first().is_some()` to check if slice is not empty
-  --> tests/ui/unnecessary_first_then_check.rs:6:19
+  --> tests/ui/unnecessary_first_then_check.rs:7:19
    |
 LL |     let _: bool = s.first().is_some();
    |                   ^^^^^^^^^^^^^^^^^^^ help: replace this with: `!s.is_empty()`
@@ -8,37 +8,37 @@ LL |     let _: bool = s.first().is_some();
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_first_then_check)]`
 
 error: unnecessary use of `first().is_none()` to check if slice is empty
-  --> tests/ui/unnecessary_first_then_check.rs:8:21
+  --> tests/ui/unnecessary_first_then_check.rs:9:21
    |
 LL |     let _: bool = s.first().is_none();
    |                     ^^^^^^^^^^^^^^^^^ help: replace this with: `is_empty()`
 
 error: unnecessary use of `first().is_some()` to check if slice is not empty
-  --> tests/ui/unnecessary_first_then_check.rs:12:19
+  --> tests/ui/unnecessary_first_then_check.rs:13:19
    |
 LL |     let _: bool = v.first().is_some();
    |                   ^^^^^^^^^^^^^^^^^^^ help: replace this with: `!v.is_empty()`
 
 error: unnecessary use of `first().is_some()` to check if slice is not empty
-  --> tests/ui/unnecessary_first_then_check.rs:16:19
+  --> tests/ui/unnecessary_first_then_check.rs:17:19
    |
 LL |     let _: bool = n[0].first().is_some();
    |                   ^^^^^^^^^^^^^^^^^^^^^^ help: replace this with: `!n[0].is_empty()`
 
 error: unnecessary use of `first().is_none()` to check if slice is empty
-  --> tests/ui/unnecessary_first_then_check.rs:18:24
+  --> tests/ui/unnecessary_first_then_check.rs:19:24
    |
 LL |     let _: bool = n[0].first().is_none();
    |                        ^^^^^^^^^^^^^^^^^ help: replace this with: `is_empty()`
 
 error: unnecessary use of `first().is_some()` to check if slice is not empty
-  --> tests/ui/unnecessary_first_then_check.rs:25:19
+  --> tests/ui/unnecessary_first_then_check.rs:26:19
    |
 LL |     let _: bool = f[0].bar.first().is_some();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace this with: `!f[0].bar.is_empty()`
 
 error: unnecessary use of `first().is_none()` to check if slice is empty
-  --> tests/ui/unnecessary_first_then_check.rs:27:28
+  --> tests/ui/unnecessary_first_then_check.rs:28:28
    |
 LL |     let _: bool = f[0].bar.first().is_none();
    |                            ^^^^^^^^^^^^^^^^^ help: replace this with: `is_empty()`

tests/ui/unnecessary_fold.fixed

@@ -1,5 +1,4 @@
-#![allow(dead_code)]
-
+#![warn(clippy::unnecessary_fold)]
 fn is_any(acc: bool, x: usize) -> bool {
     acc || x > 2
 }

tests/ui/unnecessary_fold.rs

@@ -1,5 +1,4 @@
-#![allow(dead_code)]
-
+#![warn(clippy::unnecessary_fold)]
 fn is_any(acc: bool, x: usize) -> bool {
     acc || x > 2
 }

tests/ui/unnecessary_fold.stderr

@@ -1,5 +1,5 @@
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:12:20
+  --> tests/ui/unnecessary_fold.rs:11:20
    |
 LL |     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
@@ -9,7 +9,7 @@ LL |     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_fold)]`
 
 error: redundant closure
-  --> tests/ui/unnecessary_fold.rs:16:32
+  --> tests/ui/unnecessary_fold.rs:15:32
    |
 LL |     let _ = (0..3).fold(false, |acc, x| is_any(acc, x));
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `is_any`
@@ -18,245 +18,245 @@ LL |     let _ = (0..3).fold(false, |acc, x| is_any(acc, x));
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:20:20
+  --> tests/ui/unnecessary_fold.rs:19:20
    |
 LL |     let _ = (0..3).fold(true, |acc, x| acc && x > 2);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `all(|x| x > 2)`
    |
    = note: the `all` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:24:25
+  --> tests/ui/unnecessary_fold.rs:23:25
    |
 LL |     let _: i32 = (0..3).fold(0, |acc, x| acc + x);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:26:25
+  --> tests/ui/unnecessary_fold.rs:25:25
    |
 LL |     let _: i32 = (0..3).fold(0, Add::add);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:28:25
+  --> tests/ui/unnecessary_fold.rs:27:25
    |
 LL |     let _: i32 = (0..3).fold(0, i32::add);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:32:25
+  --> tests/ui/unnecessary_fold.rs:31:25
    |
 LL |     let _: i32 = (0..3).fold(1, |acc, x| acc * x);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:34:25
+  --> tests/ui/unnecessary_fold.rs:33:25
    |
 LL |     let _: i32 = (0..3).fold(1, Mul::mul);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:36:25
+  --> tests/ui/unnecessary_fold.rs:35:25
    |
 LL |     let _: i32 = (0..3).fold(1, i32::mul);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:42:41
+  --> tests/ui/unnecessary_fold.rs:41:41
    |
 LL |     let _: bool = (0..3).map(|x| 2 * x).fold(false, |acc, x| acc || x > 2);
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
    |
    = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:100:10
+  --> tests/ui/unnecessary_fold.rs:99:10
    |
 LL |         .fold(false, |acc, x| acc || x > 2);
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
    |
    = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:113:33
+  --> tests/ui/unnecessary_fold.rs:112:33
    |
 LL |         assert_eq!(map.values().fold(0, |x, y| x + y), 0);
    |                                 ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:117:30
+  --> tests/ui/unnecessary_fold.rs:116:30
    |
 LL |         let _ = map.values().fold(0, |x, y| x + y);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:119:30
+  --> tests/ui/unnecessary_fold.rs:118:30
    |
 LL |         let _ = map.values().fold(0, Add::add);
    |                              ^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:121:30
+  --> tests/ui/unnecessary_fold.rs:120:30
    |
 LL |         let _ = map.values().fold(1, |x, y| x * y);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:123:30
+  --> tests/ui/unnecessary_fold.rs:122:30
    |
 LL |         let _ = map.values().fold(1, Mul::mul);
    |                              ^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:125:35
+  --> tests/ui/unnecessary_fold.rs:124:35
    |
 LL |         let _: i32 = map.values().fold(0, |x, y| x + y);
    |                                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:127:35
+  --> tests/ui/unnecessary_fold.rs:126:35
    |
 LL |         let _: i32 = map.values().fold(0, Add::add);
    |                                   ^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:129:35
+  --> tests/ui/unnecessary_fold.rs:128:35
    |
 LL |         let _: i32 = map.values().fold(1, |x, y| x * y);
    |                                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:131:35
+  --> tests/ui/unnecessary_fold.rs:130:35
    |
 LL |         let _: i32 = map.values().fold(1, Mul::mul);
    |                                   ^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:133:31
+  --> tests/ui/unnecessary_fold.rs:132:31
    |
 LL |         anything(map.values().fold(0, |x, y| x + y));
    |                               ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:135:31
+  --> tests/ui/unnecessary_fold.rs:134:31
    |
 LL |         anything(map.values().fold(0, Add::add));
    |                               ^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:137:31
+  --> tests/ui/unnecessary_fold.rs:136:31
    |
 LL |         anything(map.values().fold(1, |x, y| x * y));
    |                               ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:139:31
+  --> tests/ui/unnecessary_fold.rs:138:31
    |
 LL |         anything(map.values().fold(1, Mul::mul));
    |                               ^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:141:26
+  --> tests/ui/unnecessary_fold.rs:140:26
    |
 LL |         num(map.values().fold(0, |x, y| x + y));
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:143:26
+  --> tests/ui/unnecessary_fold.rs:142:26
    |
 LL |         num(map.values().fold(0, Add::add));
    |                          ^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:145:26
+  --> tests/ui/unnecessary_fold.rs:144:26
    |
 LL |         num(map.values().fold(1, |x, y| x * y));
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:147:26
+  --> tests/ui/unnecessary_fold.rs:146:26
    |
 LL |         num(map.values().fold(1, Mul::mul));
    |                          ^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:154:16
+  --> tests/ui/unnecessary_fold.rs:153:16
    |
 LL |         (0..3).fold(0, |acc, x| acc + x)
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:158:16
+  --> tests/ui/unnecessary_fold.rs:157:16
    |
 LL |         (0..3).fold(1, |acc, x| acc * x)
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:162:16
+  --> tests/ui/unnecessary_fold.rs:161:16
    |
 LL |         (0..3).fold(0, |acc, x| acc + x)
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:166:16
+  --> tests/ui/unnecessary_fold.rs:165:16
    |
 LL |         (0..3).fold(1, |acc, x| acc * x)
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:172:21
+  --> tests/ui/unnecessary_fold.rs:171:21
    |
 LL |     let _ = (2..=3).fold(1, |a, b| a * b);
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:174:21
+  --> tests/ui/unnecessary_fold.rs:173:21
    |
 LL |     let _ = (1..=3).fold(0, |a, b| a + b);
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:176:21
+  --> tests/ui/unnecessary_fold.rs:175:21
    |
 LL |     let _ = (2..=3).fold(1, |b, a| a * b);
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:178:21
+  --> tests/ui/unnecessary_fold.rs:177:21
    |
 LL |     let _ = (1..=3).fold(0, |b, a| a + b);
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:181:20
+  --> tests/ui/unnecessary_fold.rs:180:20
    |
 LL |     let _ = (0..3).fold(false, |acc, x| x > 2 || acc);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
    |
    = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:183:20
+  --> tests/ui/unnecessary_fold.rs:182:20
    |
 LL |     let _ = (0..3).fold(true, |acc, x| x > 2 && acc);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `all(|x| x > 2)`
    |
    = note: the `all` method is short circuiting and may change the program semantics if the iterator has side effects
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:185:20
+  --> tests/ui/unnecessary_fold.rs:184:20
    |
 LL |     let _ = (0..3).fold(0, |acc, x| x + acc);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:187:20
+  --> tests/ui/unnecessary_fold.rs:186:20
    |
 LL |     let _ = (0..3).fold(1, |acc, x| x * acc);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:198:20
+  --> tests/ui/unnecessary_fold.rs:197:20
    |
 LL |     let _ = (0..3).fold(false, |acc: bool, x| acc || test_expr!(x));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| test_expr!(x))`