Struct cstree::GreenNodeBuilder

pub struct GreenNodeBuilder<'cache, 'interner, I = TokenInterner> { /* fields omitted */ }

A builder for green trees. Construct with new or with_cache. To add tree nodes, start them with start_node, add tokens and then finish_node. When the whole tree is constructed, call finish to obtain the root.

Examples

let mut builder = GreenNodeBuilder::new();
builder.start_node(ROOT);
builder.token(INT, "42");
builder.finish_node();
let (tree, interner) = builder.finish();
assert_eq!(tree.kind(), ROOT);
let int = tree.children().next().unwrap();
assert_eq!(int.kind(), INT);
let resolver = interner.unwrap().into_resolver();
assert_eq!(int.as_token().unwrap().text(&resolver), "42");

Implementations

impl GreenNodeBuilder<'static, 'static>

pub fn new() -> Self

Creates new builder with an empty NodeCache.

impl<'cache, 'interner, I> GreenNodeBuilder<'cache, 'interner, I> where
    I: Interner, 

pub fn with_cache(cache: &'cache mut NodeCache<'interner, I>) -> Self

Reusing a NodeCache between multiple builders saves memory, as it allows to structurally share underlying trees.

pub fn token(&mut self, kind: SyntaxKind, text: &str)

Add new token to the current branch.

pub fn start_node(&mut self, kind: SyntaxKind)

Start new node of the given kind and make it current.

pub fn finish_node(&mut self)

Finish the current branch and restore the previous branch as current.

pub fn checkpoint(&self) -> Checkpoint

Prepare for maybe wrapping the next node with a surrounding node.

The way wrapping works is that you first get a checkpoint, then you add nodes and tokens as normal, and then you maybe call start_node_at.

Examples

let checkpoint = builder.checkpoint();
parser.parse_expr();
if parser.peek() == Some(PLUS) {
    // 1 + 2 = Add(1, 2)
    builder.start_node_at(checkpoint, OPERATION);
    parser.parse_expr();
    builder.finish_node();
}

pub fn start_node_at(&mut self, checkpoint: Checkpoint, kind: SyntaxKind)

Wrap the previous branch marked by checkpoint in a new branch and make it current.

pub fn finish(self) -> (GreenNode, Option<I>)

Complete building the tree.

Make sure that calls to start_node / start_node_at and finish_node are balanced, i.e. that every started node has been completed!

If this builder was constructed with new, this method returns the interner used to deduplicate source text (strings) as its second return value to allow resolving tree tokens back to text and re-using the interner to build additonal trees.

Trait Implementations

impl<'cache, 'interner, I: Debug> Debug for GreenNodeBuilder<'cache, 'interner, I>

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

Formats the value using the given formatter.

impl Default for GreenNodeBuilder<'static, 'static>

fn default() -> Self

Returns the “default value” for a type.