Struct ExpressionArena 

pub struct ExpressionArena { /* private fields */ }

Arena-backed representation of an Expression tree.

The arena keeps direct parent/child links so callers can jump to known nodes without walking down from the root each time. Subtree replacement preserves the replaced node’s id and appends the replacement descendants; descendants of the old subtree become unreachable from the root.

Implementations

impl ExpressionArena

pub fn from_root(root: Expression) -> Self

Builds an arena from an expression tree.

pub fn root(&self) -> ExpressionNodeId

Returns the root node id.

pub fn expression(&self, id: ExpressionNodeId) -> &Expression

Returns the expression payload stored at id.

pub fn parent(&self, id: ExpressionNodeId) -> Option<ExpressionNodeId>

Returns the parent of id, or None for the root.

pub fn children(&self, id: ExpressionNodeId) -> &[ExpressionNodeId]

Returns the direct expression children of id.

pub fn is_reachable(&self, id: ExpressionNodeId) -> bool

Returns whether id is still reachable from the current root.

pub fn depth(&self, id: ExpressionNodeId) -> usize

Returns the depth of id below the root.

pub fn preorder_path(&self, id: ExpressionNodeId) -> Vec<usize>

Builds the current preorder path of id.

Lexicographic ordering of these paths is the model preorder used by the rewriter. Paths are only materialised for the relatively rare ordering operations; storing one on every node makes building a deep arena quadratic in the tree depth.

pub fn generation(&self, id: ExpressionNodeId) -> u32

Returns the generation counter for id.

pub fn bump_generation(&mut self, id: ExpressionNodeId)

Records that rewrite-relevant content at id has changed.

pub fn replace_subtree(&mut self, id: ExpressionNodeId, replacement: Expression)

Replaces the subtree at id while preserving id itself.

pub fn add_root_children( &mut self, children: Vec<Expression>, ) -> Vec<ExpressionNodeId>

Appends top-level constraints to the root expression.

pub fn rebuild_payload_from_children(&mut self, id: ExpressionNodeId)

Rebuilds the stored expression payload at id from its direct arena children.

Only children whose generation changed are copied into the payload, so refreshing a wide expression does not clone its unchanged siblings. Ancestor repair should walk upward so deeper nodes are refreshed first.

pub fn sync_payload_for_changed_child( &mut self, parent_id: ExpressionNodeId, child_id: ExpressionNodeId, )

Syncs the parent payload after a direct child changed.

Uses Uniplate::try_replace_child_at so same-arity updates avoid cloning siblings. The child’s stored slot gives its position in the parent in O(1). Falls back to a full rebuild if the child is missing or in-place replace fails (e.g. arity mismatch).

pub fn into_root_expression(self) -> Expression

Rebuilds the expression tree reachable from the arena root.

pub fn expression_from(&self, id: ExpressionNodeId) -> Expression

Rebuilds the expression tree reachable from id.

pub fn len(&self) -> usize

Returns the number of slots currently allocated in the arena.

This includes unreachable slots left behind by subtree replacement.

pub fn is_empty(&self) -> bool

Returns true when the arena contains no nodes.

pub fn reachable_subtree_ids( &self, id: ExpressionNodeId, ) -> Vec<ExpressionNodeId>

Returns reachable node ids under id in rewriter preorder.

Trait Implementations

impl Clone for ExpressionArena

fn clone(&self) -> ExpressionArena

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExpressionArena

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes