From 29114ff0fb79f63f14ba1958e745324cedc13b2d Mon Sep 17 00:00:00 2001 From: Stein Somers Date: Mon, 23 Nov 2020 14:41:53 +0100 Subject: [PATCH] BTreeMap: relax the explicit borrow rule to make code shorter and safer --- library/alloc/src/collections/btree/map.rs | 2 +- library/alloc/src/collections/btree/node.rs | 212 ++++++++++---------- 2 files changed, 108 insertions(+), 106 deletions(-) diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs index bd2ad257402fa..735213363f60d 100644 --- a/library/alloc/src/collections/btree/map.rs +++ b/library/alloc/src/collections/btree/map.rs @@ -248,7 +248,7 @@ where let (map, dormant_map) = DormantMutRef::new(self); let root_node = Self::ensure_is_owned(&mut map.root).borrow_mut(); match search::search_tree::, K, (), K>(root_node, &key) { - Found(handle) => Some(mem::replace(handle.into_key_mut(), key)), + Found(mut kv) => Some(mem::replace(kv.key_mut(), key)), GoDown(handle) => { VacantEntry { key, handle, dormant_map, _marker: PhantomData }.insert(()); None diff --git a/library/alloc/src/collections/btree/node.rs b/library/alloc/src/collections/btree/node.rs index 22e179af4a932..a3ff83561f1be 100644 --- a/library/alloc/src/collections/btree/node.rs +++ b/library/alloc/src/collections/btree/node.rs @@ -239,17 +239,16 @@ impl NodeRef { /// - We cannot get implicit coercion from say `Mut<'a>` to `Immut<'a>`. /// Therefore, we have to explicitly call `reborrow` on a more powerfull /// `NodeRef` in order to reach a method like `key_at`. -/// - All methods on `NodeRef` that return some kind of reference, except -/// `reborrow` and `reborrow_mut`, take `self` by value and not by reference. -/// This avoids silently returning a second reference somewhere in the tree. -/// That is irrelevant when `BorrowType` is `Immut<'a>`, but the rule does -/// no harm because we make those `NodeRef` implicitly `Copy`. -/// The rule also avoids implicitly returning the lifetime of `&self`, -/// instead of the lifetime carried by `BorrowType`. -/// An exception to this rule are the insert functions. -/// - Given the above, we need a `reborrow_mut` to explicitly copy a `Mut<'a>` -/// `NodeRef` whenever we want to invoke a method returning an extra reference -/// somewhere in the tree. +/// +/// All methods on `NodeRef` that return some kind of reference, either: +/// - Take `self` by value, and return the lifetime carried by `BorrowType`. +/// Sometimes, to invoke such a method, we need to call `reborrow_mut`. +/// - Take `self` by reference, and (implicitly) return that reference's +/// lifetime, instead of the lifetime carried by `BorrowType`. That way, +/// the borrow checker guarantees that the `NodeRef` remains borrowed as long +/// as the returned reference is used. +/// The methods supporting insert bend this rule by returning a raw pointer, +/// i.e., a reference without any lifetime. pub struct NodeRef { /// The number of levels that the node and the level of leaves are apart, a /// constant of the node that cannot be entirely described by `Type`, and that @@ -305,9 +304,9 @@ impl<'a, K, V> NodeRef, K, V, marker::Internal> { } impl<'a, K, V> NodeRef, K, V, marker::Internal> { - /// Offers exclusive access to the data of an internal node. - fn as_internal_mut(this: &mut Self) -> &'a mut InternalNode { - let ptr = Self::as_internal_ptr(this); + /// Borrows exclusive access to the data of an internal node. + fn as_internal_mut(&mut self) -> &mut InternalNode { + let ptr = Self::as_internal_ptr(self); unsafe { &mut *ptr } } } @@ -355,7 +354,7 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { /// The node has more than `idx` initialized elements. pub unsafe fn key_at(self, idx: usize) -> &'a K { debug_assert!(idx < self.len()); - unsafe { Self::as_leaf(&self).keys.get_unchecked(idx).assume_init_ref() } + unsafe { self.into_leaf().keys.get_unchecked(idx).assume_init_ref() } } /// Exposes one of the values stored in the node. @@ -364,7 +363,7 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { /// The node has more than `idx` initialized elements. unsafe fn val_at(self, idx: usize) -> &'a V { debug_assert!(idx < self.len()); - unsafe { Self::as_leaf(&self).vals.get_unchecked(idx).assume_init_ref() } + unsafe { self.into_leaf().vals.get_unchecked(idx).assume_init_ref() } } } @@ -431,8 +430,8 @@ impl NodeRef { impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { /// Exposes the leaf portion of any leaf or internal node in an immutable tree. - fn as_leaf(this: &Self) -> &'a LeafNode { - let ptr = Self::as_leaf_ptr(this); + fn into_leaf(self) -> &'a LeafNode { + let ptr = Self::as_leaf_ptr(&self); // SAFETY: there can be no mutable references into this tree borrowed as `Immut`. unsafe { &*ptr } } @@ -489,42 +488,49 @@ impl<'a, K, V, Type> NodeRef, K, V, Type> { NodeRef { height: self.height, node: self.node, _marker: PhantomData } } + /// Borrows exclusive access to the leaf portion of any leaf or internal node. + fn as_leaf_mut(&mut self) -> &mut LeafNode { + let ptr = Self::as_leaf_ptr(self); + // SAFETY: we have exclusive access to the entire node. + unsafe { &mut *ptr } + } + /// Offers exclusive access to the leaf portion of any leaf or internal node. - fn as_leaf_mut(this: &mut Self) -> &'a mut LeafNode { - let ptr = Self::as_leaf_ptr(this); + fn into_leaf_mut(mut self) -> &'a mut LeafNode { + let ptr = Self::as_leaf_ptr(&mut self); // SAFETY: we have exclusive access to the entire node. unsafe { &mut *ptr } } } impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { - /// Offers exclusive access to a part of the key storage area. + /// Borrows exclusive access to an element of the key storage area. /// /// # Safety /// The node has more than `idx` initialized elements. - unsafe fn into_key_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit { + unsafe fn key_area_mut_at(&mut self, idx: usize) -> &mut MaybeUninit { debug_assert!(idx < self.len()); - unsafe { Self::as_leaf_mut(&mut self).keys.get_unchecked_mut(idx) } + unsafe { self.as_leaf_mut().keys.get_unchecked_mut(idx) } } - /// Offers exclusive access to a part of the value storage area. + /// Borrows exclusive access to an element of the value storage area. /// /// # Safety /// The node has more than `idx` initialized elements. - unsafe fn into_val_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit { + unsafe fn val_area_mut_at(&mut self, idx: usize) -> &mut MaybeUninit { debug_assert!(idx < self.len()); - unsafe { Self::as_leaf_mut(&mut self).vals.get_unchecked_mut(idx) } + unsafe { self.as_leaf_mut().vals.get_unchecked_mut(idx) } } } impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { - /// Offers exclusive access to a part of the storage area for edge contents. + /// Borrows exclusive access to an element of the storage area for edge contents. /// /// # Safety /// The node has at least `idx` initialized elements. - unsafe fn into_edge_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit> { + unsafe fn edge_area_mut_at(&mut self, idx: usize) -> &mut MaybeUninit> { debug_assert!(idx <= self.len()); - unsafe { Self::as_internal_mut(&mut self).edges.get_unchecked_mut(idx) } + unsafe { self.as_internal_mut().edges.get_unchecked_mut(idx) } } } @@ -533,14 +539,14 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { /// regardless of the node's current length, /// having exclusive access to the entire node. unsafe fn key_area(self) -> &'a [MaybeUninit] { - Self::as_leaf(&self).keys.as_slice() + self.into_leaf().keys.as_slice() } /// Exposes the entire value storage area in the node, /// regardless of the node's current length, /// having exclusive access to the entire node. unsafe fn val_area(self) -> &'a [MaybeUninit] { - Self::as_leaf(&self).vals.as_slice() + self.into_leaf().vals.as_slice() } } @@ -554,33 +560,33 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { } impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { - /// Offers exclusive access to a sized slice of key storage area in the node. - unsafe fn into_key_area_slice(mut self) -> &'a mut [MaybeUninit] { + /// Borrows exclusive access to a sized slice of key storage area in the node. + unsafe fn key_area_slice(&mut self) -> &mut [MaybeUninit] { let len = self.len(); // SAFETY: the caller will not be able to call further methods on self // until the key slice reference is dropped, as we have unique access // for the lifetime of the borrow. - unsafe { Self::as_leaf_mut(&mut self).keys.get_unchecked_mut(..len) } + unsafe { self.as_leaf_mut().keys.get_unchecked_mut(..len) } } - /// Offers exclusive access to a sized slice of value storage area in the node. - unsafe fn into_val_area_slice(mut self) -> &'a mut [MaybeUninit] { + /// Borrows exclusive access to a sized slice of value storage area in the node. + unsafe fn val_area_slice(&mut self) -> &mut [MaybeUninit] { let len = self.len(); // SAFETY: the caller will not be able to call further methods on self // until the value slice reference is dropped, as we have unique access // for the lifetime of the borrow. - unsafe { Self::as_leaf_mut(&mut self).vals.get_unchecked_mut(..len) } + unsafe { self.as_leaf_mut().vals.get_unchecked_mut(..len) } } } impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { - /// Offers exclusive access to a sized slice of storage area for edge contents in the node. - unsafe fn into_edge_area_slice(mut self) -> &'a mut [MaybeUninit>] { + /// Borrows exclusive access to a sized slice of storage area for edge contents in the node. + unsafe fn edge_area_slice(&mut self) -> &mut [MaybeUninit>] { let len = self.len(); // SAFETY: the caller will not be able to call further methods on self // until the edge slice reference is dropped, as we have unique access // for the lifetime of the borrow. - unsafe { Self::as_internal_mut(&mut self).edges.get_unchecked_mut(..len + 1) } + unsafe { self.as_internal_mut().edges.get_unchecked_mut(..len + 1) } } } @@ -604,9 +610,9 @@ impl<'a, K, V, Type> NodeRef, K, V, Type> { } impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { - /// Exposes exclusive access to the length of the node. - pub fn into_len_mut(mut self) -> &'a mut u16 { - &mut (*Self::as_leaf_mut(&mut self)).len + /// Borrows exclusive access to the length of the node. + pub fn len_mut(&mut self) -> &mut u16 { + &mut self.as_leaf_mut().len } } @@ -623,7 +629,8 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { impl NodeRef { /// Clears the root's link to its parent edge. fn clear_parent_link(&mut self) { - let leaf = NodeRef::as_leaf_mut(&mut self.borrow_mut()); + let mut root_node = self.borrow_mut(); + let leaf = root_node.as_leaf_mut(); leaf.parent = None; } } @@ -631,13 +638,13 @@ impl NodeRef { impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Leaf> { /// Adds a key-value pair to the end of the node. pub fn push(&mut self, key: K, val: V) { - let len = unsafe { self.reborrow_mut().into_len_mut() }; + let len = self.len_mut(); let idx = usize::from(*len); assert!(idx < CAPACITY); *len += 1; unsafe { - self.reborrow_mut().into_key_area_mut_at(idx).write(key); - self.reborrow_mut().into_val_area_mut_at(idx).write(val); + self.key_area_mut_at(idx).write(key); + self.val_area_mut_at(idx).write(val); } } @@ -646,9 +653,9 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Leaf> { assert!(self.len() < CAPACITY); unsafe { - *self.reborrow_mut().into_len_mut() += 1; - slice_insert(self.reborrow_mut().into_key_area_slice(), 0, key); - slice_insert(self.reborrow_mut().into_val_area_slice(), 0, val); + *self.len_mut() += 1; + slice_insert(self.key_area_slice(), 0, key); + slice_insert(self.val_area_slice(), 0, val); } } } @@ -675,14 +682,14 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { pub fn push(&mut self, key: K, val: V, edge: Root) { assert!(edge.height == self.height - 1); - let len = unsafe { self.reborrow_mut().into_len_mut() }; + let len = self.len_mut(); let idx = usize::from(*len); assert!(idx < CAPACITY); *len += 1; unsafe { - self.reborrow_mut().into_key_area_mut_at(idx).write(key); - self.reborrow_mut().into_val_area_mut_at(idx).write(val); - self.reborrow_mut().into_edge_area_mut_at(idx + 1).write(edge.node); + self.key_area_mut_at(idx).write(key); + self.val_area_mut_at(idx).write(val); + self.edge_area_mut_at(idx + 1).write(edge.node); Handle::new_edge(self.reborrow_mut(), idx + 1).correct_parent_link(); } } @@ -694,10 +701,10 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { assert!(self.len() < CAPACITY); unsafe { - *self.reborrow_mut().into_len_mut() += 1; - slice_insert(self.reborrow_mut().into_key_area_slice(), 0, key); - slice_insert(self.reborrow_mut().into_val_area_slice(), 0, val); - slice_insert(self.reborrow_mut().into_edge_area_slice(), 0, edge.node); + *self.len_mut() += 1; + slice_insert(self.key_area_slice(), 0, key); + slice_insert(self.val_area_slice(), 0, val); + slice_insert(self.edge_area_slice(), 0, edge.node); } self.correct_all_childrens_parent_links(); @@ -728,7 +735,7 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { } }; - *self.reborrow_mut().into_len_mut() -= 1; + *self.len_mut() -= 1; (key, val, edge) } } @@ -742,12 +749,12 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { let old_len = self.len(); unsafe { - let key = slice_remove(self.reborrow_mut().into_key_area_slice(), 0); - let val = slice_remove(self.reborrow_mut().into_val_area_slice(), 0); + let key = slice_remove(self.key_area_slice(), 0); + let val = slice_remove(self.val_area_slice(), 0); let edge = match self.reborrow_mut().force() { ForceResult::Leaf(_) => None, ForceResult::Internal(mut internal) => { - let node = slice_remove(internal.reborrow_mut().into_edge_area_slice(), 0); + let node = slice_remove(internal.edge_area_slice(), 0); let mut edge = Root { node, height: internal.height - 1, _marker: PhantomData }; // Currently, clearing the parent link is superfluous, because we will // insert the node elsewhere and set its parent link again. @@ -759,14 +766,14 @@ impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { } }; - *self.reborrow_mut().into_len_mut() -= 1; + *self.len_mut() -= 1; (key, val, edge) } } fn into_kv_pointers_mut(mut self) -> (*mut K, *mut V) { - let leaf = Self::as_leaf_mut(&mut self); + let leaf = self.as_leaf_mut(); let keys = MaybeUninit::slice_as_mut_ptr(&mut leaf.keys); let vals = MaybeUninit::slice_as_mut_ptr(&mut leaf.vals); (keys, vals) @@ -970,11 +977,11 @@ impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, mark debug_assert!(self.node.len() < CAPACITY); unsafe { - *self.node.reborrow_mut().into_len_mut() += 1; - slice_insert(self.node.reborrow_mut().into_key_area_slice(), self.idx, key); - slice_insert(self.node.reborrow_mut().into_val_area_slice(), self.idx, val); + *self.node.len_mut() += 1; + slice_insert(self.node.key_area_slice(), self.idx, key); + slice_insert(self.node.val_area_slice(), self.idx, val); - self.node.reborrow_mut().into_val_area_mut_at(self.idx).assume_init_mut() + self.node.val_area_mut_at(self.idx).assume_init_mut() } } } @@ -1028,10 +1035,10 @@ impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Internal>, debug_assert!(edge.height == self.node.height - 1); unsafe { - *self.node.reborrow_mut().into_len_mut() += 1; - slice_insert(self.node.reborrow_mut().into_key_area_slice(), self.idx, key); - slice_insert(self.node.reborrow_mut().into_val_area_slice(), self.idx, val); - slice_insert(self.node.reborrow_mut().into_edge_area_slice(), self.idx + 1, edge.node); + *self.node.len_mut() += 1; + slice_insert(self.node.key_area_slice(), self.idx, key); + slice_insert(self.node.val_area_slice(), self.idx, val); + slice_insert(self.node.edge_area_slice(), self.idx + 1, edge.node); self.node.correct_childrens_parent_links((self.idx + 1)..=self.node.len()); } @@ -1134,12 +1141,13 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeTyp } impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { - pub fn into_key_mut(self) -> &'a mut K { - unsafe { self.node.into_key_area_mut_at(self.idx).assume_init_mut() } + pub fn key_mut(&mut self) -> &mut K { + unsafe { self.node.key_area_mut_at(self.idx).assume_init_mut() } } pub fn into_val_mut(self) -> &'a mut V { - unsafe { self.node.into_val_area_mut_at(self.idx).assume_init_mut() } + let leaf = self.node.into_leaf_mut(); + unsafe { leaf.vals.get_unchecked_mut(self.idx).assume_init_mut() } } } @@ -1154,7 +1162,7 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType> // We cannot call separate key and value methods, because calling the second one // invalidates the reference returned by the first. unsafe { - let leaf = NodeRef::as_leaf_mut(&mut self.node.reborrow_mut()); + let leaf = self.node.as_leaf_mut(); let key = leaf.keys.get_unchecked_mut(self.idx).assume_init_mut(); let val = leaf.vals.get_unchecked_mut(self.idx).assume_init_mut(); (key, val) @@ -1196,7 +1204,7 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType> new_len, ); - *self.node.reborrow_mut().into_len_mut() = self.idx as u16; + *self.node.len_mut() = self.idx as u16; (k, v) } } @@ -1227,9 +1235,9 @@ impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, mark mut self, ) -> ((K, V), Handle, K, V, marker::Leaf>, marker::Edge>) { unsafe { - let k = slice_remove(self.node.reborrow_mut().into_key_area_slice(), self.idx); - let v = slice_remove(self.node.reborrow_mut().into_val_area_slice(), self.idx); - *self.node.reborrow_mut().into_len_mut() -= 1; + let k = slice_remove(self.node.key_area_slice(), self.idx); + let v = slice_remove(self.node.val_area_slice(), self.idx); + *self.node.len_mut() -= 1; ((k, v), self.left_edge()) } } @@ -1374,29 +1382,27 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> { }); unsafe { - *left_node.reborrow_mut().into_len_mut() = new_left_len as u16; + *left_node.len_mut() = new_left_len as u16; - let parent_key = - slice_remove(parent_node.reborrow_mut().into_key_area_slice(), parent_idx); - left_node.reborrow_mut().into_key_area_mut_at(old_left_len).write(parent_key); + let parent_key = slice_remove(parent_node.key_area_slice(), parent_idx); + left_node.key_area_mut_at(old_left_len).write(parent_key); ptr::copy_nonoverlapping( right_node.reborrow().key_area().as_ptr(), - left_node.reborrow_mut().into_key_area_slice().as_mut_ptr().add(old_left_len + 1), + left_node.key_area_slice().as_mut_ptr().add(old_left_len + 1), right_len, ); - let parent_val = - slice_remove(parent_node.reborrow_mut().into_val_area_slice(), parent_idx); - left_node.reborrow_mut().into_val_area_mut_at(old_left_len).write(parent_val); + let parent_val = slice_remove(parent_node.val_area_slice(), parent_idx); + left_node.val_area_mut_at(old_left_len).write(parent_val); ptr::copy_nonoverlapping( right_node.reborrow().val_area().as_ptr(), - left_node.reborrow_mut().into_val_area_slice().as_mut_ptr().add(old_left_len + 1), + left_node.val_area_slice().as_mut_ptr().add(old_left_len + 1), right_len, ); - slice_remove(&mut parent_node.reborrow_mut().into_edge_area_slice(), parent_idx + 1); + slice_remove(&mut parent_node.edge_area_slice(), parent_idx + 1); parent_node.correct_childrens_parent_links(parent_idx + 1..old_parent_len); - *parent_node.reborrow_mut().into_len_mut() -= 1; + *parent_node.len_mut() -= 1; if parent_node.height > 1 { // SAFETY: the height of the nodes being merged is one below the height @@ -1405,11 +1411,7 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> { let right_node = right_node.cast_to_internal_unchecked(); ptr::copy_nonoverlapping( right_node.reborrow().edge_area().as_ptr(), - left_node - .reborrow_mut() - .into_edge_area_slice() - .as_mut_ptr() - .add(old_left_len + 1), + left_node.edge_area_slice().as_mut_ptr().add(old_left_len + 1), right_len + 1, ); @@ -1511,14 +1513,14 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> { move_kv(left_kv, new_left_len, parent_kv, 0, 1); } - *left_node.reborrow_mut().into_len_mut() -= count as u16; - *right_node.reborrow_mut().into_len_mut() += count as u16; + *left_node.len_mut() -= count as u16; + *right_node.len_mut() += count as u16; match (left_node.reborrow_mut().force(), right_node.reborrow_mut().force()) { (ForceResult::Internal(left), ForceResult::Internal(mut right)) => { // Make room for stolen edges. let left = left.reborrow(); - let right_edges = right.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + let right_edges = right.edge_area_slice().as_mut_ptr(); ptr::copy(right_edges, right_edges.add(count), old_right_len + 1); right.correct_childrens_parent_links(count..count + old_right_len + 1); @@ -1569,8 +1571,8 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> { ptr::copy(right_kv.1.add(count), right_kv.1, new_right_len); } - *left_node.reborrow_mut().into_len_mut() += count as u16; - *right_node.reborrow_mut().into_len_mut() -= count as u16; + *left_node.len_mut() += count as u16; + *right_node.len_mut() -= count as u16; match (left_node.reborrow_mut().force(), right_node.reborrow_mut().force()) { (ForceResult::Internal(left), ForceResult::Internal(mut right)) => { @@ -1578,7 +1580,7 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> { move_edges(right.reborrow(), 0, left, old_left_len + 1, count); // Fill gap where stolen edges used to be. - let right_edges = right.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + let right_edges = right.edge_area_slice().as_mut_ptr(); ptr::copy(right_edges.add(count), right_edges, new_right_len + 1); right.correct_childrens_parent_links(0..=new_right_len); } @@ -1612,7 +1614,7 @@ unsafe fn move_edges<'a, K: 'a, V: 'a>( ) { unsafe { let source_ptr = source.edge_area().as_ptr(); - let dest_ptr = dest.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + let dest_ptr = dest.edge_area_slice().as_mut_ptr(); ptr::copy_nonoverlapping(source_ptr.add(source_offset), dest_ptr.add(dest_offset), count); dest.correct_childrens_parent_links(dest_offset..dest_offset + count); } @@ -1708,8 +1710,8 @@ impl<'a, K, V> Handle, K, V, marker::LeafOrInternal>, ma move_kv(left_kv, new_left_len, right_kv, 0, new_right_len); - *left_node.reborrow_mut().into_len_mut() = new_left_len as u16; - *right_node.reborrow_mut().into_len_mut() = new_right_len as u16; + *left_node.len_mut() = new_left_len as u16; + *right_node.len_mut() = new_right_len as u16; match (left_node.force(), right_node.force()) { (ForceResult::Internal(left), ForceResult::Internal(right)) => {