Struct ConcreteSyntaxTree 

pub struct ConcreteSyntaxTree<T, Nt> { /* private fields */ }

A generic concrete syntax tree with stable child ordering

Implementations

impl<T, Nt> ConcreteSyntaxTree<T, Nt>

where T: Clone, Nt: Clone,

pub fn new(root_data: CstNodeData<T, Nt>) -> Self

pub fn root(&self) -> CstNodeId

pub fn set_root(&mut self, new_root: CstNodeId)

pub fn change_parent(&mut self, id: CstNodeId, new_parent: CstNodeId)

pub fn add_node(&mut self, data: CstNodeData<T, Nt>) -> CstNodeId

pub fn add_node_with_parent( &mut self, data: CstNodeData<T, Nt>, parent: CstNodeId, ) -> CstNodeId

pub fn add_child(&mut self, parent: CstNodeId, child: CstNodeId)

pub fn has_no_children(&self, node: CstNodeId) -> bool

pub fn children( &self, node: CstNodeId, ) -> impl DoubleEndedIterator<Item = CstNodeId> + '_

pub fn parent(&self, node: CstNodeId) -> Option<CstNodeId>

pub fn get_str<'a: 'c, 'b: 'c, 'c>( &'a self, terminal: TerminalData, input: &'b str, ) -> Option<&'c str>

pub fn dynamic_token(&self, id: DynamicTokenId) -> Option<&str>

pub fn update_node( &mut self, id: CstNodeId, data: CstNodeData<T, Nt>, ) -> Option<CstNodeData<T, Nt>>

pub fn update_children( &mut self, id: CstNodeId, new_children: impl IntoIterator<Item = CstNodeId>, )

pub fn insert_dynamic_terminal( &mut self, data: impl Into<String>, ) -> DynamicTokenId

impl<T, Nt> ConcreteSyntaxTree<T, Nt>

where T: Copy, Nt: Copy,

pub fn node_data(&self, node: CstNodeId) -> Option<CstNodeData<T, Nt>>

pub fn remove_node(&mut self, id: CstNodeId)

Remove a node from the tree by removing it from all parent-child relationships. The node data remains in the vector but becomes unreachable through tree traversal.

impl ConcreteSyntaxTree<TerminalKind, NonTerminalKind>

pub fn get_non_terminal( &self, id: CstNodeId, kind: NonTerminalKind, ) -> Result<NonTerminalData, CstConstructError>

pub fn get_terminal( &self, id: CstNodeId, kind: TerminalKind, ) -> Result<TerminalData, CstConstructError>

pub fn collect_nodes<'v, const N: usize, V: BuiltinTerminalVisitor<E, F>, O, E, F: CstFacade>( &self, facade: &F, parent: CstNodeId, nodes: [NodeKind<TerminalKind, NonTerminalKind>; N], visitor: impl FnMut([CstNodeId; N], &'v mut V) -> Result<(O, &'v mut V), CstConstructError<E>>, visit_ignored: &'v mut V, ) -> Result<O, CstConstructError<E>>

pub fn root_handle(&self) -> RootHandle

pub fn visit_from_root<V: CstVisitor<Self>>( &self, visitor: &mut V, ) -> Result<(), V::Error>

Trait Implementations

impl<T: Clone, Nt: Clone> Clone for ConcreteSyntaxTree<T, Nt>

fn clone(&self) -> ConcreteSyntaxTree<T, Nt>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CstFacade for ConcreteSyntaxTree<TerminalKind, NonTerminalKind>

fn get_str<'a: 'c, 'b: 'c, 'c>( &'a self, terminal: TerminalData, input: &'b str, ) -> Option<&'c str>

fn node_data( &self, node: CstNodeId, ) -> Option<CstNodeData<TerminalKind, NonTerminalKind>>

fn has_no_children(&self, node: CstNodeId) -> bool

fn children( &self, node: CstNodeId, ) -> impl DoubleEndedIterator<Item = CstNodeId>

fn get_terminal( &self, node: CstNodeId, kind: TerminalKind, ) -> Result<TerminalData, CstConstructError>

fn get_non_terminal( &self, node: CstNodeId, kind: NonTerminalKind, ) -> Result<NonTerminalData, CstConstructError>

fn collect_nodes<'v, const N: usize, V: BuiltinTerminalVisitor<E, Self>, O, E>( &self, parent: CstNodeId, nodes: [NodeKind<TerminalKind, NonTerminalKind>; N], visitor: impl FnMut([CstNodeId; N], &'v mut V) -> Result<(O, &'v mut V), CstConstructError<E>>, visit_ignored: &'v mut V, ) -> Result<O, CstConstructError<E>>

fn dynamic_token(&self, id: DynamicTokenId) -> Option<&str>

fn parent(&self, node: CstNodeId) -> Option<CstNodeId>

fn root_handle(&self) -> RootHandle

fn get_terminal_str<'a: 'c, 'b: 'c, 'c, T: TerminalHandle>( &'a self, input: &'b str, handle: T, ) -> Result<Result<&'c str, DynamicTokenId>, CstConstructError>

Returns the string representation of a terminal. Returns None if the terminal is a dynamic token and not found.

fn span(&self, node_id: CstNodeId) -> Option<InputSpan>

Returns a span that excludes leading and trailing trivia (whitespace, newlines, comments).

fn concrete_span(&self, node_id: CstNodeId) -> Option<InputSpan>

Returns the span of a node, including the trivia.

fn find_first_non_trivia_span(&self, node_id: CstNodeId) -> Option<InputSpan>

Helper: finds the first non-trivia span by depth-first search from the start.

fn find_last_non_trivia_span(&self, node_id: CstNodeId) -> Option<InputSpan>

Helper: finds the last non-trivia span by depth-first search from the end.

impl<T: Debug, Nt: Debug> Debug for ConcreteSyntaxTree<T, Nt>

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

Formats the value using the given formatter.

impl<T: PartialEq, Nt: PartialEq> PartialEq for ConcreteSyntaxTree<T, Nt>

fn eq(&self, other: &ConcreteSyntaxTree<T, Nt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq, Nt: Eq> Eq for ConcreteSyntaxTree<T, Nt>

impl<T, Nt> StructuralPartialEq for ConcreteSyntaxTree<T, Nt>