factor out tree_visitor into own file

Author: royAmmerschuber

src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs

@@ -13,6 +13,7 @@ pub mod diagnostics;
 mod foreign_access_skipping;
 mod perms;
 mod tree;
+mod tree_visitor;
 mod unimap;
 mod wildcard;
 

src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs

@@ -18,15 +18,16 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_span::Span;
 use smallvec::SmallVec;
 
-use super::diagnostics::AccessCause;
-use super::wildcard::WildcardState;
-use crate::borrow_tracker::tree_borrows::Permission;
-use crate::borrow_tracker::tree_borrows::diagnostics::{
-    self, NodeDebugInfo, TbError, TransitionError, no_valid_exposed_references_error,
+use super::Permission;
+use super::diagnostics::{
+    self, AccessCause, NodeDebugInfo, TbError, TransitionError,
+    no_valid_exposed_references_error,
 };
-use crate::borrow_tracker::tree_borrows::foreign_access_skipping::IdempotentForeignAccess;
-use crate::borrow_tracker::tree_borrows::perms::PermTransition;
-use crate::borrow_tracker::tree_borrows::unimap::{UniIndex, UniKeyMap, UniValMap};
+use super::foreign_access_skipping::IdempotentForeignAccess;
+use super::perms::PermTransition;
+use super::tree_visitor::{ChildrenVisitMode, ContinueTraversal, NodeAppArgs, TreeVisitor};
+use super::unimap::{UniIndex, UniKeyMap, UniValMap};
+use super::wildcard::WildcardState;
 use crate::borrow_tracker::{AccessKind, GlobalState, ProtectorKind};
 use crate::*;
 
@@ -339,290 +340,6 @@ pub(super) struct Node {
     pub debug_info: NodeDebugInfo,
 }
 
-/// Data given to the transition function
-struct NodeAppArgs<'visit> {
-    /// The index of the current node.
-    idx: UniIndex,
-    /// Relative position of the access.
-    rel_pos: AccessRelatedness,
-    /// The node map of this tree.
-    nodes: &'visit mut UniValMap<Node>,
-    /// The permissions map of this tree.
-    loc: &'visit mut LocationTree,
-}
-/// Internal contents of `Tree` with the minimum of mutable access for
-/// For soundness do not modify the children or parent indexes of nodes
-/// during traversal.
-struct TreeVisitor<'tree> {
-    nodes: &'tree mut UniValMap<Node>,
-    loc: &'tree mut LocationTree,
-}
-
-/// Whether to continue exploring the children recursively or not.
-#[derive(Debug)]
-enum ContinueTraversal {
-    Recurse,
-    SkipSelfAndChildren,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub enum ChildrenVisitMode {
-    VisitChildrenOfAccessed,
-    SkipChildrenOfAccessed,
-}
-
-enum RecursionState {
-    BeforeChildren,
-    AfterChildren,
-}
-
-/// Stack of nodes left to explore in a tree traversal.
-/// See the docs of `traverse_this_parents_children_other` for details on the
-/// traversal order.
-struct TreeVisitorStack<NodeContinue, NodeApp> {
-    /// Function describing whether to continue at a tag.
-    /// This is only invoked for foreign accesses.
-    f_continue: NodeContinue,
-    /// Function to apply to each tag.
-    f_propagate: NodeApp,
-    /// Mutable state of the visit: the tags left to handle.
-    /// Every tag pushed should eventually be handled,
-    /// and the precise order is relevant for diagnostics.
-    /// Since the traversal is piecewise bottom-up, we need to
-    /// remember whether we're here initially, or after visiting all children.
-    /// The last element indicates this.
-    /// This is just an artifact of how you hand-roll recursion,
-    /// it does not have a deeper meaning otherwise.
-    stack: Vec<(UniIndex, AccessRelatedness, RecursionState)>,
-}
-
-impl<NodeContinue, NodeApp, Err> TreeVisitorStack<NodeContinue, NodeApp>
-where
-    NodeContinue: Fn(&NodeAppArgs<'_>) -> ContinueTraversal,
-    NodeApp: FnMut(NodeAppArgs<'_>) -> Result<(), Err>,
-{
-    fn should_continue_at(
-        &self,
-        this: &mut TreeVisitor<'_>,
-        idx: UniIndex,
-        rel_pos: AccessRelatedness,
-    ) -> ContinueTraversal {
-        let args = NodeAppArgs { idx, rel_pos, nodes: this.nodes, loc: this.loc };
-        (self.f_continue)(&args)
-    }
-
-    fn propagate_at(
-        &mut self,
-        this: &mut TreeVisitor<'_>,
-        idx: UniIndex,
-        rel_pos: AccessRelatedness,
-    ) -> Result<(), Err> {
-        (self.f_propagate)(NodeAppArgs { idx, rel_pos, nodes: this.nodes, loc: this.loc })
-    }
-
-    /// Returns the root of this tree.
-    fn go_upwards_from_accessed(
-        &mut self,
-        this: &mut TreeVisitor<'_>,
-        accessed_node: UniIndex,
-        visit_children: ChildrenVisitMode,
-    ) -> Result<UniIndex, Err> {
-        // We want to visit the accessed node's children first.
-        // However, we will below walk up our parents and push their children (our cousins)
-        // onto the stack. To ensure correct iteration order, this method thus finishes
-        // by reversing the stack. This only works if the stack is empty initially.
-        assert!(self.stack.is_empty());
-        // First, handle accessed node. A bunch of things need to
-        // be handled differently here compared to the further parents
-        // of `accesssed_node`.
-        {
-            self.propagate_at(this, accessed_node, AccessRelatedness::LocalAccess)?;
-            if matches!(visit_children, ChildrenVisitMode::VisitChildrenOfAccessed) {
-                let accessed_node = this.nodes.get(accessed_node).unwrap();
-                // We `rev()` here because we reverse the entire stack later.
-                for &child in accessed_node.children.iter().rev() {
-                    self.stack.push((
-                        child,
-                        AccessRelatedness::ForeignAccess,
-                        RecursionState::BeforeChildren,
-                    ));
-                }
-            }
-        }
-        // Then, handle the accessed node's parents. Here, we need to
-        // make sure we only mark the "cousin" subtrees for later visitation,
-        // not the subtree that contains the accessed node.
-        let mut last_node = accessed_node;
-        while let Some(current) = this.nodes.get(last_node).unwrap().parent {
-            self.propagate_at(this, current, AccessRelatedness::LocalAccess)?;
-            let node = this.nodes.get(current).unwrap();
-            // We `rev()` here because we reverse the entire stack later.
-            for &child in node.children.iter().rev() {
-                if last_node == child {
-                    continue;
-                }
-                self.stack.push((
-                    child,
-                    AccessRelatedness::ForeignAccess,
-                    RecursionState::BeforeChildren,
-                ));
-            }
-            last_node = current;
-        }
-        // Reverse the stack, as discussed above.
-        self.stack.reverse();
-        Ok(last_node)
-    }
-
-    fn finish_foreign_accesses(&mut self, this: &mut TreeVisitor<'_>) -> Result<(), Err> {
-        while let Some((idx, rel_pos, step)) = self.stack.last_mut() {
-            let idx = *idx;
-            let rel_pos = *rel_pos;
-            match *step {
-                // How to do bottom-up traversal, 101: Before you handle a node, you handle all children.
-                // For this, you must first find the children, which is what this code here does.
-                RecursionState::BeforeChildren => {
-                    // Next time we come back will be when all the children are handled.
-                    *step = RecursionState::AfterChildren;
-                    // Now push the children, except if we are told to skip this subtree.
-                    let handle_children = self.should_continue_at(this, idx, rel_pos);
-                    match handle_children {
-                        ContinueTraversal::Recurse => {
-                            let node = this.nodes.get(idx).unwrap();
-                            for &child in node.children.iter() {
-                                self.stack.push((child, rel_pos, RecursionState::BeforeChildren));
-                            }
-                        }
-                        ContinueTraversal::SkipSelfAndChildren => {
-                            // skip self
-                            self.stack.pop();
-                            continue;
-                        }
-                    }
-                }
-                // All the children are handled, let's actually visit this node
-                RecursionState::AfterChildren => {
-                    self.stack.pop();
-                    self.propagate_at(this, idx, rel_pos)?;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn new(f_continue: NodeContinue, f_propagate: NodeApp) -> Self {
-        Self { f_continue, f_propagate, stack: Vec::new() }
-    }
-}
-
-impl<'tree> TreeVisitor<'tree> {
-    /// Applies `f_propagate` to every vertex of the tree in a piecewise bottom-up way: First, visit
-    /// all ancestors of `start_idx` (starting with `start_idx` itself), then children of `start_idx`, then the rest,
-    /// going bottom-up in each of these two "pieces" / sections.
-    /// This ensures that errors are triggered in the following order
-    /// - first invalid accesses with insufficient permissions, closest to the accessed node first,
-    /// - then protector violations, bottom-up, starting with the children of the accessed node, and then
-    ///   going upwards and outwards.
-    ///
-    /// The following graphic visualizes it, with numbers indicating visitation order and `start_idx` being
-    /// the node that is visited first ("1"):
-    ///
-    /// ```text
-    ///         3
-    ///        /|
-    ///       / |
-    ///      9  2
-    ///      |  |\
-    ///      |  | \
-    ///      8  1  7
-    ///        / \
-    ///       4   6
-    ///           |
-    ///           5
-    /// ```
-    ///
-    /// `f_propagate` should follow the following format: for a given `Node` it updates its
-    /// `Permission` depending on the position relative to `start_idx` (given by an
-    /// `AccessRelatedness`).
-    /// `f_continue` is called earlier on foreign nodes, and describes whether to even start
-    /// visiting the subtree at that node. If it e.g. returns `SkipSelfAndChildren` on node 6
-    /// above, then nodes 5 _and_ 6 would not be visited by `f_propagate`. It is not used for
-    /// notes having a child access (nodes 1, 2, 3).
-    ///
-    /// Finally, remember that the iteration order is not relevant for UB, it only affects
-    /// diagnostics. It also affects tree traversal optimizations built on top of this, so
-    /// those need to be reviewed carefully as well whenever this changes.
-    ///
-    /// Returns the index of the root of the accessed tree.
-    fn traverse_this_parents_children_other<Err>(
-        mut self,
-        start_idx: UniIndex,
-        f_continue: impl Fn(&NodeAppArgs<'_>) -> ContinueTraversal,
-        f_propagate: impl FnMut(NodeAppArgs<'_>) -> Result<(), Err>,
-    ) -> Result<UniIndex, Err> {
-        let mut stack = TreeVisitorStack::new(f_continue, f_propagate);
-        // Visits the accessed node itself, and all its parents, i.e. all nodes
-        // undergoing a child access. Also pushes the children and the other
-        // cousin nodes (i.e. all nodes undergoing a foreign access) to the stack
-        // to be processed later.
-        let root = stack.go_upwards_from_accessed(
-            &mut self,
-            start_idx,
-            ChildrenVisitMode::VisitChildrenOfAccessed,
-        )?;
-        // Now visit all the foreign nodes we remembered earlier.
-        // For this we go bottom-up, but also allow f_continue to skip entire
-        // subtrees from being visited if it would be a NOP.
-        stack.finish_foreign_accesses(&mut self)?;
-        Ok(root)
-    }
-
-    /// Like `traverse_this_parents_children_other`, but skips the children of `start_idx`.
-    ///
-    /// Returns the index of the root of the accessed tree.
-    fn traverse_nonchildren<Err>(
-        mut self,
-        start_idx: UniIndex,
-        f_continue: impl Fn(&NodeAppArgs<'_>) -> ContinueTraversal,
-        f_propagate: impl FnMut(NodeAppArgs<'_>) -> Result<(), Err>,
-    ) -> Result<UniIndex, Err> {
-        let mut stack = TreeVisitorStack::new(f_continue, f_propagate);
-        // Visits the accessed node itself, and all its parents, i.e. all nodes
-        // undergoing a child access. Also pushes the other cousin nodes to the
-        // stack, but not the children of the accessed node.
-        let root = stack.go_upwards_from_accessed(
-            &mut self,
-            start_idx,
-            ChildrenVisitMode::SkipChildrenOfAccessed,
-        )?;
-        // Now visit all the foreign nodes we remembered earlier.
-        // For this we go bottom-up, but also allow f_continue to skip entire
-        // subtrees from being visited if it would be a NOP.
-        stack.finish_foreign_accesses(&mut self)?;
-        Ok(root)
-    }
-
-    /// Traverses all children of `start_idx` including `start_idx` itself.
-    /// Uses `f_continue` to filter out subtrees and then processes each node
-    /// with `f_propagate` so that the children get processed before their
-    /// parents.
-    fn traverse_children_this<Err>(
-        mut self,
-        start_idx: UniIndex,
-        f_continue: impl Fn(&NodeAppArgs<'_>) -> ContinueTraversal,
-        f_propagate: impl FnMut(NodeAppArgs<'_>) -> Result<(), Err>,
-    ) -> Result<(), Err> {
-        let mut stack = TreeVisitorStack::new(f_continue, f_propagate);
-
-        stack.stack.push((
-            start_idx,
-            AccessRelatedness::ForeignAccess,
-            RecursionState::BeforeChildren,
-        ));
-        stack.finish_foreign_accesses(&mut self)
-    }
-}
-
 impl Tree {
     /// Create a new tree, with only a root pointer.
     pub fn new(root_tag: BorTag, size: Size, span: Span) -> Self {