Use reference patterns compatible with edition 2024

Reference patterns have become stricter in edition 2024. The binding
modes cannot be mixed.

Author: samueltardieu

tests/ui/iter_overeager_cloned.fixed

@@ -59,7 +59,7 @@ fn main() {
         iter: impl Iterator<Item = &'a (&'a u32, String)> + 'a,
         target: String,
     ) -> impl Iterator<Item = (&'a u32, String)> + 'a {
-        iter.filter(move |&(&a, b)| a == 1 && b == &target).cloned()
+        iter.filter(move |&&(&a, ref b)| a == 1 && b == &target).cloned()
         //~^ iter_overeager_cloned
     }
 

tests/ui/iter_overeager_cloned.rs

@@ -60,7 +60,7 @@ fn main() {
         iter: impl Iterator<Item = &'a (&'a u32, String)> + 'a,
         target: String,
     ) -> impl Iterator<Item = (&'a u32, String)> + 'a {
-        iter.cloned().filter(move |(&a, b)| a == 1 && b == &target)
+        iter.cloned().filter(move |&(&a, ref b)| a == 1 && b == &target)
         //~^ iter_overeager_cloned
     }
 

tests/ui/iter_overeager_cloned.stderr

@@ -120,10 +120,10 @@ LL |         let _ = vec.iter().cloned().find(f);
 error: unnecessarily eager cloning of iterator items
   --> tests/ui/iter_overeager_cloned.rs:63:9
    |
-LL |         iter.cloned().filter(move |(&a, b)| a == 1 && b == &target)
-   |         ^^^^-------------------------------------------------------
+LL |         iter.cloned().filter(move |&(&a, ref b)| a == 1 && b == &target)
+   |         ^^^^------------------------------------------------------------
    |             |
-   |             help: try: `.filter(move |&(&a, b)| a == 1 && b == &target).cloned()`
+   |             help: try: `.filter(move |&&(&a, ref b)| a == 1 && b == &target).cloned()`
 
 error: unnecessarily eager cloning of iterator items
   --> tests/ui/iter_overeager_cloned.rs:75:13

tests/ui/manual_map_option.rs

@@ -101,7 +101,7 @@ fn main() {
 
     match &mut Some(String::new()) {
         //~^ manual_map
-        Some(ref x) => Some(x.len()),
+        &mut Some(ref x) => Some(x.len()),
         None => None,
     };
 

tests/ui/manual_map_option.stderr

@@ -127,7 +127,7 @@ error: manual implementation of `Option::map`
    |
 LL | /     match &mut Some(String::new()) {
 LL | |
-LL | |         Some(ref x) => Some(x.len()),
+LL | |         &mut Some(ref x) => Some(x.len()),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.len())`

tests/ui/manual_map_option_2.fixed

@@ -115,7 +115,7 @@ mod with_type_coercion {
     fn with_fn_ret(s: &Option<String>) -> Option<(String, &str)> {
         // Don't lint, `map` doesn't work as the return type is adjusted.
         match s {
-            Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+            Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
             None => None,
         }
     }
@@ -124,7 +124,7 @@ mod with_type_coercion {
         if true {
             // Don't lint, `map` doesn't work as the return type is adjusted.
             return match s {
-                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
                 None => None,
             };
         }
@@ -136,7 +136,7 @@ mod with_type_coercion {
         let x: Option<(String, &'a str)>;
         x = {
             match s {
-                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
                 None => None,
             }
         };

tests/ui/manual_map_option_2.rs

@@ -143,7 +143,7 @@ mod with_type_coercion {
     fn with_fn_ret(s: &Option<String>) -> Option<(String, &str)> {
         // Don't lint, `map` doesn't work as the return type is adjusted.
         match s {
-            Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+            Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
             None => None,
         }
     }
@@ -152,7 +152,7 @@ mod with_type_coercion {
         if true {
             // Don't lint, `map` doesn't work as the return type is adjusted.
             return match s {
-                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
                 None => None,
             };
         }
@@ -164,7 +164,7 @@ mod with_type_coercion {
         let x: Option<(String, &'a str)>;
         x = {
             match s {
-                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
                 None => None,
             }
         };

tests/ui/manual_retain.fixed

@@ -1,5 +1,5 @@
 #![warn(clippy::manual_retain)]
-#![allow(unused, clippy::redundant_clone)]
+#![allow(unused, clippy::needless_borrowed_reference, clippy::redundant_clone)]
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
 
 fn main() {
@@ -31,7 +31,7 @@ fn binary_heap_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = BinaryHeap::from([(0, 1), (1, 2), (2, 3)]);
-    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|&(ref x, ref y)| *x == 0);
     //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
     //~^ manual_retain
@@ -99,7 +99,7 @@ fn btree_set_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = BTreeSet::from([(0, 1), (1, 2), (2, 3)]);
-    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|&(ref x, ref y)| *x == 0);
     //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
     //~^ manual_retain
@@ -166,7 +166,7 @@ fn hash_set_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = HashSet::from([(0, 1), (1, 2), (2, 3)]);
-    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|&(ref x, ref y)| *x == 0);
     //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
     //~^ manual_retain
@@ -220,7 +220,7 @@ fn vec_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = vec![(0, 1), (1, 2), (2, 3)];
-    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|&(ref x, ref y)| *x == 0);
     //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
     //~^ manual_retain

tests/ui/manual_retain.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::manual_retain)]
-#![allow(unused, clippy::redundant_clone)]
+#![allow(unused, clippy::needless_borrowed_reference, clippy::redundant_clone)]
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
 
 fn main() {
@@ -31,7 +31,7 @@ fn binary_heap_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = BinaryHeap::from([(0, 1), (1, 2), (2, 3)]);
-    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
     //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
     //~^ manual_retain
@@ -103,7 +103,7 @@ fn btree_set_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = BTreeSet::from([(0, 1), (1, 2), (2, 3)]);
-    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
     //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
     //~^ manual_retain
@@ -174,7 +174,7 @@ fn hash_set_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = HashSet::from([(0, 1), (1, 2), (2, 3)]);
-    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
     //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
     //~^ manual_retain
@@ -228,7 +228,7 @@ fn vec_retain() {
 
     // Do lint, because we use pattern matching
     let mut tuples = vec![(0, 1), (1, 2), (2, 3)];
-    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
     //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
     //~^ manual_retain

tests/ui/manual_retain.stderr

@@ -22,8 +22,8 @@ LL |     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).cloned().colle
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:34:5
    |
-LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+LL |     tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|&(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:36:5
@@ -74,8 +74,8 @@ LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:106:5
    |
-LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+LL |     tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|&(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:108:5
@@ -126,8 +126,8 @@ LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:177:5
    |
-LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+LL |     tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|&(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:179:5
@@ -162,8 +162,8 @@ LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:231:5
    |
-LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+LL |     tuples = tuples.iter().filter(|&&(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|&(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
   --> tests/ui/manual_retain.rs:233:5