Struct ConcreteSyntaxTree 

pub struct ConcreteSyntaxTree { /* private fields */ }

A Concrete Syntax Tree for VB6 code.

This structure wraps the rowan library’s GreenNode internally but provides a public API that doesn’t expose rowan types.

Implementations

impl ConcreteSyntaxTree

pub fn debug_tree(&self) -> String

Get a textual representation of the tree structure (for debugging)

pub fn text(&self) -> String

Get the text content of the entire tree

pub fn child_count(&self) -> usize

Get the number of children of the root node

pub fn children(&self) -> Vec<CstNode>

Get the children of the root node

Returns a vector of child nodes with their kind and text content.

pub fn children_by_kind( &self, kind: SyntaxKind, ) -> impl Iterator<Item = CstNode>

Get an iterator over direct children of a specific kind

This method returns an iterator for better performance and composability. If you need a Vec, call .collect() on the result.

Arguments

• kind - The SyntaxKind to search for

Returns

An iterator over child nodes matching the specified kind

Example

// Use iterator directly
for dim_stmt in cst.children_by_kind(SyntaxKind::DimStatement) {
    println!("Found: {}", dim_stmt.text());
}

// Or collect into a Vec
let dim_stmts: Vec<_> = cst.children_by_kind(SyntaxKind::DimStatement).collect();

pub fn first_child_by_kind(&self, kind: SyntaxKind) -> Option<CstNode>

Find the first direct child of a specific kind

Arguments

• kind - The SyntaxKind to search for

Returns

The first child node matching the kind, or None if not found

pub fn contains_kind(&self, kind: SyntaxKind) -> bool

Check if the tree contains any node of the specified kind

Arguments

• kind - The SyntaxKind to search for

Returns

true if at least one node of the specified kind exists, false otherwise

pub fn first_child(&self) -> Option<CstNode>

Get the first child node (including tokens)

Returns

The first child node if it exists, None otherwise

pub fn last_child(&self) -> Option<CstNode>

Get the last child node (including tokens)

Returns

The last child node if it exists, None otherwise

pub fn child_at(&self, index: usize) -> Option<CstNode>

Get child at a specific index

Arguments

• index - The index of the child to retrieve

Returns

The child at the specified index if it exists, None otherwise

pub fn find(&self, kind: SyntaxKind) -> Option<CstNode>

Find the first descendant node of a specific kind (depth-first search)

This searches recursively through the entire tree, unlike first_child_by_kind() which only searches direct children.

Arguments

• kind - The SyntaxKind to search for

Returns

The first descendant node matching the kind, or None if not found

pub fn find_all(&self, kind: SyntaxKind) -> Vec<CstNode>

Find all descendant nodes of a specific kind (depth-first search)

This searches recursively through the entire tree, unlike children_by_kind() which only searches direct children.

Arguments

• kind - The SyntaxKind to search for

Returns

A vector of all descendant nodes matching the kind

pub fn non_token_children(&self) -> impl Iterator<Item = CstNode>

Get an iterator over non-token children (structural nodes only)

pub fn token_children(&self) -> impl Iterator<Item = CstNode>

Get an iterator over token children only

pub fn first_non_whitespace_child(&self) -> Option<CstNode>

Get the first non-whitespace child

pub fn significant_children(&self) -> impl Iterator<Item = CstNode>

Get an iterator over significant children (excluding whitespace and newlines)

pub fn find_if<F>(&self, predicate: F) -> Option<CstNode>

where F: Fn(&CstNode) -> bool,

Find the first descendant node matching a predicate (depth-first search)

This allows flexible searching with custom logic beyond just matching kinds.

Arguments

• predicate - A closure that takes a &CstNode and returns bool

Returns

The first descendant node for which the predicate returns true, or None if not found

pub fn find_all_if<F>(&self, predicate: F) -> Vec<CstNode>

where F: Fn(&CstNode) -> bool,

Find all descendant nodes matching a predicate (depth-first search)

This allows flexible searching with custom logic beyond just matching kinds.

Arguments

• predicate - A closure that takes a &CstNode and returns bool

Returns

A vector of all descendant nodes for which the predicate returns true

pub fn descendants(&self) -> DepthFirstIterOwned

Get an iterator over all descendants (depth-first, pre-order)

This visits every node in the tree.

Returns

An iterator that yields owned copies of all descendants in depth-first order

pub fn depth_first_iter(&self) -> DepthFirstIterOwned

Get a depth-first iterator over the tree

This is an alias for descendants() for compatibility with common tree APIs.

Returns

An iterator that yields owned copies of all descendants in depth-first order

impl ConcreteSyntaxTree

pub fn from_source(source_file: &SourceFile) -> ParseResult<'_, Self>

Parse a CST from a SourceFile.

Arguments

• source_file - The source file to parse.

Returns

A result containing the parsed CST or an error.

pub fn from_text<S>(file_name: S, contents: &str) -> ParseResult<'_, Self>

where S: Into<String>,

Parse a CST from source code.

Arguments

• file_name - The name of the source file.
• contents - The contents of the source file.

Returns

A result containing the parsed CST or an error.

pub fn root_kind(&self) -> SyntaxKind

Get the kind of the root node

pub fn to_serializable(&self) -> SerializableTree

Convert the CST to a serializable representation.

This method creates a SerializableTree that can be used with snapshot testing tools like insta. The serializable tree contains the complete tree structure as a hierarchy of CstNode instances.

Example

use vb6parse::ConcreteSyntaxTree;

let source = "Sub Test()\nEnd Sub\n";
let result = ConcreteSyntaxTree::from_text("test.bas", source);

let (cst_opt, failures) = result.unpack();

let cst = cst_opt.expect("Failed to parse source");

if !failures.is_empty() {
    for failure in failures.iter() {
        failure.print();
    }
    panic!("Failed to parse source with {} errors.", failures.len());
};

let serializable = cst.to_serializable();

// Can now be used with insta::assert_yaml_snapshot!

pub fn to_root_node(&self) -> CstNode

Convert the internal rowan tree to a root CstNode.

Returns

The root CstNode representing the entire CST.

pub fn without_kinds(&self, kinds_to_remove: &[SyntaxKind]) -> Self

Create a new CST with specified node kinds removed from the root level.

This method filters out direct children of the root node that match any of the specified kinds. This is useful for removing nodes that have already been parsed into structured data (like version statements, attributes, etc.) to avoid duplication.

Arguments

• kinds_to_remove - A slice of SyntaxKind values to filter out

Returns

A new ConcreteSyntaxTree with the specified kinds removed from the root level.

Example

use vb6parse::ConcreteSyntaxTree;
use vb6parse::parsers::SyntaxKind;

let source = "VERSION 5.00\nSub Test()\nEnd Sub\n";
let result = ConcreteSyntaxTree::from_text("test.bas", source);
let (cst_opt, failures) = result.unpack();
let cst = cst_opt.expect("Failed to parse source");

// Remove version statement since it's already parsed
let filtered = cst.without_kinds(&[SyntaxKind::VersionStatement]);

assert!(!filtered.contains_kind(SyntaxKind::VersionStatement));

Trait Implementations

impl Clone for ConcreteSyntaxTree

fn clone(&self) -> ConcreteSyntaxTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConcreteSyntaxTree

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

Formats the value using the given formatter.

impl Hash for ConcreteSyntaxTree

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ConcreteSyntaxTree

fn eq(&self, other: &ConcreteSyntaxTree) -> 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 Eq for ConcreteSyntaxTree

impl StructuralPartialEq for ConcreteSyntaxTree