mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Stop BTreeMap casts from reborrowing

Browse Source
This commit is contained in:
Stein Somers 2020-08-01 14:01:43 +02:00
parent 441fd22557
commit 0522040233
1 changed files with 16 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
library/alloc/src/collections/btree/node.rs
View File

@ -413,7 +413,7 @@ impl<K, V> NodeRef<marker::Owned, K, V, marker::LeafOrInternal> {
impl<'a, K, V, Type> NodeRef<marker::Mut<'a>, K, V, Type> { impl<'a, K, V, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
/// Unsafely asserts to the compiler some static information about whether this /// Unsafely asserts to the compiler some static information about whether this
/// node is a `Leaf` or an `Internal`. /// node is a `Leaf` or an `Internal`.
unsafe fn cast_unchecked<NewType>(&mut self) -> NodeRef<marker::Mut<'_>, K, V, NewType> { unsafe fn cast_unchecked<NewType>(self) -> NodeRef<marker::Mut<'a>, K, V, NewType> {
NodeRef { height: self.height, node: self.node, root: self.root, _marker: PhantomData } NodeRef { height: self.height, node: self.node, root: self.root, _marker: PhantomData }
} }
@ -721,7 +721,7 @@ impl<Node: Copy, Type> Clone for Handle<Node, Type> {
} }
impl<Node, Type> Handle<Node, Type> { impl<Node, Type> Handle<Node, Type> {
/// Retrieves the node that contains the edge of key/value pair this handle points to. /// Retrieves the node that contains the edge or key/value pair this handle points to.
pub fn into_node(self) -> Node { pub fn into_node(self) -> Node {
self.node self.node
} }
@ -1082,7 +1082,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::KV>
} }
/// Removes the key/value pair pointed to by this handle and returns it, along with the edge /// Removes the key/value pair pointed to by this handle and returns it, along with the edge
/// between the now adjacent key/value pairs (if any) to the left and right of this handle. /// that the key/value pair collapsed into.
pub fn remove( pub fn remove(
mut self, mut self,
) -> ((K, V), Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>) { ) -> ((K, V), Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>) {
@ -1140,7 +1140,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
/// to by this handle, and the node immediately to the right of this handle into one new /// to by this handle, and the node immediately to the right of this handle into one new
/// child of the underlying node, returning an edge referencing that new child. /// child of the underlying node, returning an edge referencing that new child.
/// ///
/// Assumes that this edge `.can_merge()`. /// Panics unless this edge `.can_merge()`.
pub fn merge( pub fn merge(
mut self, mut self,
) -> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::Edge> { ) -> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::Edge> {
@ -1148,10 +1148,9 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
let self2 = unsafe { ptr::read(&self) }; let self2 = unsafe { ptr::read(&self) };
let mut left_node = self1.left_edge().descend(); let mut left_node = self1.left_edge().descend();
let left_len = left_node.len(); let left_len = left_node.len();
let mut right_node = self2.right_edge().descend(); let right_node = self2.right_edge().descend();
let right_len = right_node.len(); let right_len = right_node.len();
// necessary for correctness, but in a private module
assert!(left_len + right_len < CAPACITY); assert!(left_len + right_len < CAPACITY);
unsafe { unsafe {
@ -1182,28 +1181,25 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
(*left_node.as_leaf_mut()).len += right_len as u16 + 1; (*left_node.as_leaf_mut()).len += right_len as u16 + 1;
let layout = if self.node.height > 1 { if self.node.height > 1 {
// SAFETY: the height of the nodes being merged is one below the height
// of the node of this edge, thus above zero, so they are internal.
let mut left_node = left_node.cast_unchecked();
let right_node = right_node.cast_unchecked();
ptr::copy_nonoverlapping( ptr::copy_nonoverlapping(
right_node.cast_unchecked().as_internal().edges.as_ptr(), right_node.reborrow().as_internal().edges.as_ptr(),
left_node left_node.reborrow_mut().as_internal_mut().edges.as_mut_ptr().add(left_len + 1),
.cast_unchecked()
.as_internal_mut()
.edges
.as_mut_ptr()
.add(left_len + 1),
right_len + 1, right_len + 1,
); );
for i in left_len + 1..left_len + right_len + 2 { for i in left_len + 1..left_len + right_len + 2 {
Handle::new_edge(left_node.cast_unchecked().reborrow_mut(), i) Handle::new_edge(left_node.reborrow_mut(), i).correct_parent_link();
.correct_parent_link();
} }
Layout::new::<InternalNode<K, V>>() Global.dealloc(right_node.node.cast(), Layout::new::<InternalNode<K, V>>());
} else { } else {
Layout::new::<LeafNode<K, V>>() Global.dealloc(right_node.node.cast(), Layout::new::<LeafNode<K, V>>());
}; }
Global.dealloc(right_node.node.cast(), layout);
Handle::new_edge(self.node, self.idx) Handle::new_edge(self.node, self.idx)
} }