introduce the Comparable trait for btree internals

conradludgate · conradludgate · commit 59d683cefbd2 · 2026-04-03T14:15:15.000+01:00
diff --git a/library/alloc/src/collections/btree/navigate.rs b/library/alloc/src/collections/btree/navigate.rs
@@ -1,4 +1,4 @@
-use core::borrow::Borrow;
+use core::cmp::Comparable;
 use core::ops::RangeBounds;
 use core::{hint, ptr};
 
@@ -267,7 +267,7 @@ impl<BorrowType: marker::BorrowType, K, V> NodeRef<BorrowType, K, V, marker::Lea
     ) -> LeafRange<BorrowType, K, V>
     where
         Q: Ord,
-        K: Borrow<Q>,
+        K: Comparable<&Q>,
         R: RangeBounds<Q>,
     {
         match self.search_tree_for_bifurcation(&range) {
@@ -316,7 +316,7 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Immut<'a>, K, V, marker::LeafOrInternal>
     pub(super) fn range_search<Q, R>(self, range: R) -> LeafRange<marker::Immut<'a>, K, V>
     where
         Q: ?Sized + Ord,
-        K: Borrow<Q>,
+        K: Comparable<&Q>,
         R: RangeBounds<Q>,
     {
         // SAFETY: our borrow type is immutable.
@@ -342,7 +342,7 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::ValMut<'a>, K, V, marker::LeafOrInternal>
     pub(super) fn range_search<Q, R>(self, range: R) -> LeafRange<marker::ValMut<'a>, K, V>
     where
         Q: ?Sized + Ord,
-        K: Borrow<Q>,
+        K: Comparable<&Q>,
         R: RangeBounds<Q>,
     {
         unsafe { self.find_leaf_edges_spanning_range(range) }
@@ -741,13 +741,12 @@ impl<BorrowType: marker::BorrowType, K, V>
 impl<BorrowType: marker::BorrowType, K, V> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {
     /// Returns the leaf edge corresponding to the first point at which the
     /// given bound is true.
-    pub(super) fn lower_bound<Q: ?Sized>(
+    pub(super) fn lower_bound<Q: Clone>(
         self,
-        mut bound: SearchBound<&Q>,
+        mut bound: SearchBound<Q>,
     ) -> Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>
     where
-        Q: Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         let mut node = self;
         loop {
@@ -764,13 +763,12 @@ impl<BorrowType: marker::BorrowType, K, V> NodeRef<BorrowType, K, V, marker::Lea
 
     /// Returns the leaf edge corresponding to the last point at which the
     /// given bound is true.
-    pub(super) fn upper_bound<Q: ?Sized>(
+    pub(super) fn upper_bound<Q: Clone>(
         self,
-        mut bound: SearchBound<&Q>,
+        mut bound: SearchBound<Q>,
     ) -> Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>
     where
-        Q: Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         let mut node = self;
         loop {
diff --git a/library/alloc/src/collections/btree/search.rs b/library/alloc/src/collections/btree/search.rs
@@ -1,5 +1,4 @@
-use core::borrow::Borrow;
-use core::cmp::Ordering;
+use core::cmp::{Comparable, Ordering};
 use core::ops::{Bound, RangeBounds};
 
 use SearchBound::*;
@@ -46,16 +45,15 @@ impl<BorrowType: marker::BorrowType, K, V> NodeRef<BorrowType, K, V, marker::Lea
     ///
     /// The result is meaningful only if the tree is ordered by key, like the tree
     /// in a `BTreeMap` is.
-    pub(super) fn search_tree<Q: ?Sized>(
+    pub(super) fn search_tree<Q: Clone>(
         mut self,
-        key: &Q,
+        key: Q,
     ) -> SearchResult<BorrowType, K, V, marker::LeafOrInternal, marker::Leaf>
     where
-        Q: Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         loop {
-            self = match self.search_node(key) {
+            self = match self.search_node(key.clone()) {
                 Found(handle) => return Found(handle),
                 GoDown(handle) => match handle.force() {
                     Leaf(leaf) => return GoDown(leaf),
@@ -95,7 +93,7 @@ impl<BorrowType: marker::BorrowType, K, V> NodeRef<BorrowType, K, V, marker::Lea
     >
     where
         Q: Ord,
-        K: Borrow<Q>,
+        K: Comparable<&Q>,
         R: RangeBounds<Q>,
     {
         // Determine if map or set is being searched
@@ -156,27 +154,25 @@ impl<BorrowType: marker::BorrowType, K, V> NodeRef<BorrowType, K, V, marker::Lea
     /// the matching child node, if `self` is an internal node.
     ///
     /// The result is meaningful only if the tree is ordered by key.
-    pub(super) fn find_lower_bound_edge<'r, Q>(
+    pub(super) fn find_lower_bound_edge<Q: Clone>(
         self,
-        bound: SearchBound<&'r Q>,
-    ) -> (Handle<Self, marker::Edge>, SearchBound<&'r Q>)
+        bound: SearchBound<Q>,
+    ) -> (Handle<Self, marker::Edge>, SearchBound<Q>)
     where
-        Q: ?Sized + Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         let (edge_idx, bound) = self.find_lower_bound_index(bound);
         let edge = unsafe { Handle::new_edge(self, edge_idx) };
         (edge, bound)
     }
 
     /// Clone of `find_lower_bound_edge` for the upper bound.
-    pub(super) fn find_upper_bound_edge<'r, Q>(
+    pub(super) fn find_upper_bound_edge<Q: Clone>(
         self,
-        bound: SearchBound<&'r Q>,
-    ) -> (Handle<Self, marker::Edge>, SearchBound<&'r Q>)
+        bound: SearchBound<Q>,
+    ) -> (Handle<Self, marker::Edge>, SearchBound<Q>)
     where
-        Q: ?Sized + Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         let (edge_idx, bound) = unsafe { self.find_upper_bound_index(bound, 0) };
         let edge = unsafe { Handle::new_edge(self, edge_idx) };
@@ -192,13 +188,9 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
     ///
     /// The result is meaningful only if the tree is ordered by key, like the tree
     /// in a `BTreeMap` is.
-    pub(super) fn search_node<Q: ?Sized>(
-        self,
-        key: &Q,
-    ) -> SearchResult<BorrowType, K, V, Type, Type>
+    pub(super) fn search_node<Q: Clone>(self, key: Q) -> SearchResult<BorrowType, K, V, Type, Type>
     where
-        Q: Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         match unsafe { self.find_key_index(key, 0) } {
             IndexResult::KV(idx) => Found(unsafe { Handle::new_kv(self, idx) }),
@@ -214,19 +206,18 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
     ///
     /// # Safety
     /// `start_index` must be a valid edge index for the node.
-    unsafe fn find_key_index<Q: ?Sized>(&self, key: &Q, start_index: usize) -> IndexResult
+    unsafe fn find_key_index<Q: Clone>(&self, key: Q, start_index: usize) -> IndexResult
     where
-        Q: Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         let node = self.reborrow();
         let keys = node.keys();
         debug_assert!(start_index <= keys.len());
         for (offset, k) in unsafe { keys.get_unchecked(start_index..) }.iter().enumerate() {
-            match key.cmp(k.borrow()) {
-                Ordering::Greater => {}
+            match k.compare(key.clone()) {
+                Ordering::Less => {}
                 Ordering::Equal => return IndexResult::KV(start_index + offset),
-                Ordering::Less => return IndexResult::Edge(start_index + offset),
+                Ordering::Greater => return IndexResult::Edge(start_index + offset),
             }
         }
         IndexResult::Edge(keys.len())
@@ -237,22 +228,18 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
     /// the matching child node, if `self` is an internal node.
     ///
     /// The result is meaningful only if the tree is ordered by key.
-    fn find_lower_bound_index<'r, Q>(
-        &self,
-        bound: SearchBound<&'r Q>,
-    ) -> (usize, SearchBound<&'r Q>)
+    fn find_lower_bound_index<Q: Clone>(&self, bound: SearchBound<Q>) -> (usize, SearchBound<Q>)
     where
-        Q: ?Sized + Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         match bound {
-            Included(key) => match unsafe { self.find_key_index(key, 0) } {
+            Included(key) => match unsafe { self.find_key_index(key.clone(), 0) } {
                 IndexResult::KV(idx) => (idx, AllExcluded),
-                IndexResult::Edge(idx) => (idx, bound),
+                IndexResult::Edge(idx) => (idx, Included(key)),
             },
-            Excluded(key) => match unsafe { self.find_key_index(key, 0) } {
+            Excluded(key) => match unsafe { self.find_key_index(key.clone(), 0) } {
                 IndexResult::KV(idx) => (idx + 1, AllIncluded),
-                IndexResult::Edge(idx) => (idx, bound),
+                IndexResult::Edge(idx) => (idx, Excluded(key)),
             },
             AllIncluded => (0, AllIncluded),
             AllExcluded => (self.len(), AllExcluded),
@@ -264,23 +251,22 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
     ///
     /// # Safety
     /// `start_index` must be a valid edge index for the node.
-    unsafe fn find_upper_bound_index<'r, Q>(
+    unsafe fn find_upper_bound_index<Q: Clone>(
         &self,
-        bound: SearchBound<&'r Q>,
+        bound: SearchBound<Q>,
         start_index: usize,
-    ) -> (usize, SearchBound<&'r Q>)
+    ) -> (usize, SearchBound<Q>)
     where
-        Q: ?Sized + Ord,
-        K: Borrow<Q>,
+        K: Comparable<Q>,
     {
         match bound {
-            Included(key) => match unsafe { self.find_key_index(key, start_index) } {
+            Included(key) => match unsafe { self.find_key_index(key.clone(), start_index) } {
                 IndexResult::KV(idx) => (idx + 1, AllExcluded),
-                IndexResult::Edge(idx) => (idx, bound),
+                IndexResult::Edge(idx) => (idx, Included(key)),
             },
-            Excluded(key) => match unsafe { self.find_key_index(key, start_index) } {
+            Excluded(key) => match unsafe { self.find_key_index(key.clone(), start_index) } {
                 IndexResult::KV(idx) => (idx, AllIncluded),
-                IndexResult::Edge(idx) => (idx, bound),
+                IndexResult::Edge(idx) => (idx, Excluded(key)),
             },
             AllIncluded => (self.len(), AllIncluded),
             AllExcluded => (start_index, AllExcluded),
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
@@ -98,6 +98,7 @@
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
 #![feature(coerce_unsized)]
+#![feature(comparable_trait)]
 #![feature(const_clone)]
 #![feature(const_cmp)]
 #![feature(const_convert)]
diff --git a/library/alloctests/lib.rs b/library/alloctests/lib.rs
@@ -17,6 +17,7 @@
 #![feature(allocator_api)]
 #![feature(array_into_iter_constructors)]
 #![feature(char_internals)]
+#![feature(comparable_trait)]
 #![feature(const_alloc_error)]
 #![feature(const_cmp)]
 #![feature(const_convert)]
