Allow Borrow indirection in BTree{Map,Set}::extract_if, like range

Author: rs-sac

library/alloc/src/collections/btree/map.rs

@@ -1437,20 +1437,22 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
     /// assert_eq!(high.keys().copied().collect::<Vec<_>>(), [4, 5, 6, 7]);
     /// ```
     #[unstable(feature = "btree_extract_if", issue = "70530")]
-    pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, K, V, R, F, A>
+    pub fn extract_if<F, R, Q>(&mut self, range: R, pred: F) -> ExtractIf<'_, K, V, R, F, A>
     where
-        K: Ord,
-        R: RangeBounds<K>,
+        K: Borrow<Q>,
+        Q: Ord,
+        R: RangeBounds<Q>,
         F: FnMut(&K, &mut V) -> bool,
     {
         let (inner, alloc) = self.extract_if_inner(range);
         ExtractIf { pred, inner, alloc }
     }
 
-    pub(super) fn extract_if_inner<R>(&mut self, range: R) -> (ExtractIfInner<'_, K, V, R>, A)
+    pub(super) fn extract_if_inner<R, Q>(&mut self, range: R) -> (ExtractIfInner<'_, K, V, R>, A)
     where
-        K: Ord,
-        R: RangeBounds<K>,
+        K: Borrow<Q>,
+        Q: Ord,
+        R: RangeBounds<Q>,
     {
         if let Some(root) = self.root.as_mut() {
             let (root, dormant_root) = DormantMutRef::new(root);

library/alloc/src/collections/btree/set.rs

@@ -1220,10 +1220,11 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
     /// assert_eq!(high.into_iter().collect::<Vec<_>>(), [4, 5, 6, 7]);
     /// ```
     #[unstable(feature = "btree_extract_if", issue = "70530")]
-    pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, T, R, F, A>
+    pub fn extract_if<F, R, Q>(&mut self, range: R, pred: F) -> ExtractIf<'_, T, R, F, A>
     where
-        T: Ord,
-        R: RangeBounds<T>,
+        T: Borrow<Q>,
+        Q: Ord,
+        R: RangeBounds<Q>,
         F: FnMut(&T) -> bool,
     {
         let (inner, alloc) = self.map.extract_if_inner(range);

src/tools/miri/tests/pass/btreemap.rs

@@ -50,7 +50,7 @@ pub fn main() {
     test_all_refs(&mut 13, b.values_mut());
 
     // Test forgetting the extractor.
-    let mut d = b.extract_if(.., |_, i| *i < 30);
+    let mut d = b.extract_if::<_, std::ops::RangeFull, String>(.., |_, i| *i < 30);
     d.next().unwrap();
     mem::forget(d);
 }

tests/ui/closures/2229_closure_analysis/run_pass/lit-pattern-matching-with-methods.rs

@@ -14,14 +14,14 @@ fn main() {
     map.insert("c", ());
 
     {
-        let mut it = map.extract_if(.., |_, _| true);
+        let mut it = map.extract_if::<_, std::ops::RangeFull, &str>(.., |_, _| true);
         catch_unwind(AssertUnwindSafe(|| while it.next().is_some() {})).unwrap_err();
         let result = catch_unwind(AssertUnwindSafe(|| it.next()));
         assert!(matches!(result, Ok(None)));
     }
 
     {
-        let mut it = map.extract_if(.., |_, _| true);
+        let mut it = map.extract_if::<_, std::ops::RangeFull, &str>(.., |_, _| true);
         catch_unwind(AssertUnwindSafe(|| while let Some(_) = it.next() {})).unwrap_err();
         let result = catch_unwind(AssertUnwindSafe(|| it.next()));
         assert!(matches!(result, Ok(None)));