all: Refactor many type bounds

Author: udoprog

crates/rune-alloc/src/borrow/mod.rs

@@ -294,8 +294,7 @@ where
 #[cfg(feature = "alloc")]
 impl<'a, T: ?Sized + 'a> TryFrom<rust_alloc::borrow::Cow<'a, T>> for Cow<'a, T>
 where
-    T: ToOwned + TryToOwned,
-    <T as TryToOwned>::Owned: TryFrom<<T as ToOwned>::Owned>,
+    T: ToOwned + TryToOwned<Owned: TryFrom<<T as ToOwned>::Owned>>,
 {
     type Error = <<T as TryToOwned>::Owned as TryFrom<<T as ToOwned>::Owned>>::Error;
 
@@ -307,9 +306,9 @@ where
     }
 }
 
-impl<B: ?Sized + TryToOwned> Deref for Cow<'_, B>
+impl<B> Deref for Cow<'_, B>
 where
-    B::Owned: Borrow<B>,
+    B: ?Sized + TryToOwned<Owned: Borrow<B>>,
 {
     type Target = B;
 

crates/rune-alloc/src/btree/append.rs

@@ -19,7 +19,7 @@ impl<K, V> Root<K, V> {
     /// a `BTreeMap`, both iterators should produce keys in strictly ascending
     /// order, each greater than all keys in the tree, including any keys
     /// already in the tree upon entry.
-    pub(crate) fn try_append_from_sorted_iters<I, A: Allocator>(
+    pub(crate) fn try_append_from_sorted_iters<I, A>(
         &mut self,
         left: I,
         right: I,
@@ -29,6 +29,7 @@ impl<K, V> Root<K, V> {
     where
         K: Ord,
         I: Iterator<Item = (K, V)> + FusedIterator,
+        A: Allocator,
     {
         // We prepare to merge `left` and `right` into a sorted sequence in linear time.
         let iter = MergeIter(MergeIterInner::new(left, right));
@@ -40,14 +41,15 @@ impl<K, V> Root<K, V> {
     /// Pushes all key-value pairs to the end of the tree, incrementing a
     /// `length` variable along the way. The latter makes it easier for the
     /// caller to avoid a leak when the iterator panicks.
-    pub(crate) fn try_bulk_push<I, A: Allocator>(
+    pub(crate) fn try_bulk_push<I, A>(
         &mut self,
         iter: I,
         length: &mut usize,
         alloc: &A,
     ) -> Result<(), AllocError>
     where
         I: Iterator<Item = (K, V)>,
+        A: Allocator,
     {
         let mut cur_node = self.borrow_mut().last_leaf_edge().into_node();
         // Iterate through all key-value pairs, pushing them into nodes at the right level.
@@ -103,9 +105,10 @@ impl<K, V> Root<K, V> {
     }
 
     #[cfg(test)]
-    pub(crate) fn bulk_push<I, A: Allocator>(&mut self, iter: I, length: &mut usize, alloc: &A)
+    pub(crate) fn bulk_push<I, A>(&mut self, iter: I, length: &mut usize, alloc: &A)
     where
         I: Iterator<Item = (K, V)>,
+        A: Allocator,
     {
         self.try_bulk_push(iter, length, alloc).abort()
     }

crates/rune-alloc/src/btree/fix.rs

@@ -8,10 +8,13 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
     /// sibling. If successful but at the cost of shrinking the parent node,
     /// returns that shrunk parent node. Returns an `Err` if the node is
     /// an empty root.
-    fn fix_node_through_parent<A: Allocator>(
+    fn fix_node_through_parent<A>(
         self,
         alloc: &A,
-    ) -> Result<Option<NodeRef<marker::Mut<'a>, K, V, marker::Internal>>, Self> {
+    ) -> Result<Option<NodeRef<marker::Mut<'a>, K, V, marker::Internal>>, Self>
+    where
+        A: Allocator,
+    {
         let len = self.len();
         if len >= MIN_LEN {
             Ok(None)
@@ -55,7 +58,10 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
     ///
     /// This method does not expect ancestors to already be underfull upon entry
     /// and panics if it encounters an empty ancestor.
-    pub(crate) fn fix_node_and_affected_ancestors<A: Allocator>(mut self, alloc: &A) -> bool {
+    pub(crate) fn fix_node_and_affected_ancestors<A>(mut self, alloc: &A) -> bool
+    where
+        A: Allocator,
+    {
         loop {
             match self.fix_node_through_parent(alloc) {
                 Ok(Some(parent)) => self = parent.forget_type(),
@@ -68,7 +74,10 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
 
 impl<K, V> Root<K, V> {
     /// Removes empty levels on the top, but keeps an empty leaf if the entire tree is empty.
-    pub(crate) fn fix_top<A: Allocator>(&mut self, alloc: &A) {
+    pub(crate) fn fix_top<A>(&mut self, alloc: &A)
+    where
+        A: Allocator,
+    {
         while self.height() > 0 && self.len() == 0 {
             self.pop_internal_level(alloc);
         }
@@ -77,7 +86,10 @@ impl<K, V> Root<K, V> {
     /// Stocks up or merge away any underfull nodes on the right border of the
     /// tree. The other nodes, those that are not the root nor a rightmost edge,
     /// must already have at least MIN_LEN elements.
-    pub(crate) fn fix_right_border<A: Allocator>(&mut self, alloc: &A) {
+    pub(crate) fn fix_right_border<A>(&mut self, alloc: &A)
+    where
+        A: Allocator,
+    {
         self.fix_top(alloc);
         if self.len() > 0 {
             self.borrow_mut()
@@ -88,7 +100,10 @@ impl<K, V> Root<K, V> {
     }
 
     /// The symmetric clone of `fix_right_border`.
-    pub(crate) fn fix_left_border<A: Allocator>(&mut self, alloc: &A) {
+    pub(crate) fn fix_left_border<A>(&mut self, alloc: &A)
+    where
+        A: Allocator,
+    {
         self.fix_top(alloc);
         if self.len() > 0 {
             self.borrow_mut()
@@ -120,14 +135,20 @@ impl<K, V> Root<K, V> {
 }
 
 impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, marker::KV> {
-    fn fix_left_border_of_left_edge<A: Allocator>(mut self, alloc: &A) {
+    fn fix_left_border_of_left_edge<A>(mut self, alloc: &A)
+    where
+        A: Allocator,
+    {
         while let Internal(internal_kv) = self.force() {
             self = internal_kv.fix_left_child(alloc).first_kv();
             debug_assert!(self.reborrow().into_node().len() > MIN_LEN);
         }
     }
 
-    fn fix_right_border_of_right_edge<A: Allocator>(mut self, alloc: &A) {
+    fn fix_right_border_of_right_edge<A>(mut self, alloc: &A)
+    where
+        A: Allocator,
+    {
         while let Internal(internal_kv) = self.force() {
             self = internal_kv.fix_right_child(alloc).last_kv();
             debug_assert!(self.reborrow().into_node().len() > MIN_LEN);
@@ -140,10 +161,10 @@ impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>,
     /// provisions an extra element to allow merging its children in turn
     /// without becoming underfull.
     /// Returns the left child.
-    fn fix_left_child<A: Allocator>(
-        self,
-        alloc: &A,
-    ) -> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
+    fn fix_left_child<A>(self, alloc: &A) -> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>
+    where
+        A: Allocator,
+    {
         let mut internal_kv = self.consider_for_balancing();
         let left_len = internal_kv.left_child_len();
         debug_assert!(internal_kv.right_child_len() >= MIN_LEN);
@@ -163,10 +184,10 @@ impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>,
     /// provisions an extra element to allow merging its children in turn
     /// without becoming underfull.
     /// Returns wherever the right child ended up.
-    fn fix_right_child<A: Allocator>(
-        self,
-        alloc: &A,
-    ) -> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
+    fn fix_right_child<A>(self, alloc: &A) -> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>
+    where
+        A: Allocator,
+    {
         let mut internal_kv = self.consider_for_balancing();
         let right_len = internal_kv.right_child_len();
         debug_assert!(internal_kv.left_child_len() >= MIN_LEN);