Use reference patterns compatible with edition 2024

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

12 files changed, 33 insertions, 33 deletions

diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index 99991269029..b0e548f1790 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/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
     }
 
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index 6a860dad5af..cedf62a6b47 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/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
     }
 
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index f3239b59582..1616dec95b7 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/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
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 9477d0d795d..40133748d45 100644
--- a/tests/ui/manual_map_option.rs
+++ b/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,
     };
 
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index 8f9bce4c265..486379c1e5f 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/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())`
diff --git a/tests/ui/manual_map_option_2.fixed b/tests/ui/manual_map_option_2.fixed
index d698cc74ea6..206c6d5d077 100644
--- a/tests/ui/manual_map_option_2.fixed
+++ b/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,
             }
         };
diff --git a/tests/ui/manual_map_option_2.rs b/tests/ui/manual_map_option_2.rs
index 069c2381f6d..a47dc950760 100644
--- a/tests/ui/manual_map_option_2.rs
+++ b/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,
             }
         };
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
index ca8491131c0..016f520e216 100644
--- a/tests/ui/manual_retain.fixed
+++ b/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
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
index cd05a41f3f2..62f9b7b0595 100644
--- a/tests/ui/manual_retain.rs
+++ b/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
diff --git a/tests/ui/manual_retain.stderr b/tests/ui/manual_retain.stderr
index 2f81647dd8b..e7d3e34b5d7 100644
--- a/tests/ui/manual_retain.stderr
+++ b/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
diff --git a/tests/ui/needless_borrowed_ref.fixed b/tests/ui/needless_borrowed_ref.fixed
index e4504bc2784..84924cac62d 100644
--- a/tests/ui/needless_borrowed_ref.fixed
+++ b/tests/ui/needless_borrowed_ref.fixed
@@ -89,7 +89,7 @@ fn should_not_lint(
     tuple_struct: TupleStruct,
     s: Struct,
 ) {
-    if let [ref a] = slice {}
+    if let [a] = slice {}
     if let &[ref a, b] = slice {}
     if let &[ref a, .., b] = slice {}
 
diff --git a/tests/ui/needless_borrowed_ref.rs b/tests/ui/needless_borrowed_ref.rs
index 7edfda60b97..280cef43340 100644
--- a/tests/ui/needless_borrowed_ref.rs
+++ b/tests/ui/needless_borrowed_ref.rs
@@ -89,7 +89,7 @@ fn should_not_lint(
     tuple_struct: TupleStruct,
     s: Struct,
 ) {
-    if let [ref a] = slice {}
+    if let [a] = slice {}
     if let &[ref a, b] = slice {}
     if let &[ref a, .., b] = slice {}