vhdl_syntax 0.2.0

VHDL parser for lossless concrete syntax trees
Documentation
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.
//
// Copyright (c)  2026, Lukas Scheller lukasscheller@icloud.com

use std::marker::PhantomData;

use crate::syntax::green::{GreenChild, GreenNode, GreenNodeData, GreenToken};
use crate::syntax::meta::Layout;
use crate::syntax::node::SyntaxNode;
use crate::syntax::AstNode;
use crate::tokens::Token;

#[must_use]
pub struct RawNodeBuilder<T> {
    data: GreenNodeData,
    _marker: PhantomData<T>,
}

impl<T> RawNodeBuilder<T> {
    pub fn push_node<N: AstNode>(mut self, node: N) -> Self {
        self.push(GreenChild::Node(node.raw().green().clone()));
        self
    }

    pub fn push_opt_node<N: AstNode>(self, node: Option<N>) -> Self {
        if let Some(node) = node {
            self.push_node(node)
        } else {
            self
        }
    }

    pub fn push_nodes<N: AstNode>(mut self, nodes: impl IntoIterator<Item = N>) -> Self {
        for node in nodes {
            self.push(GreenChild::Node(node.raw().green().clone()));
        }
        self
    }

    pub fn push_token(mut self, token: Token) -> Self {
        self.push(GreenChild::Token(GreenToken::new(token)));
        self
    }

    pub fn push_opt_token(self, token: Option<Token>) -> Self {
        if let Some(token) = token {
            self.push_token(token)
        } else {
            self
        }
    }

    #[allow(dead_code, reason = "push_tokens can be generated by codegen")]
    pub fn push_tokens(mut self, tokens: impl IntoIterator<Item = Token>) -> Self {
        for token in tokens {
            self.push(GreenChild::Token(GreenToken::new(token)));
        }
        self
    }

    fn push(&mut self, child: GreenChild) {
        self.data.push(child);
    }

    pub fn finish_untyped(self) -> SyntaxNode {
        assert!(!self.data.is_empty(), "Cannot build empty nodes");
        SyntaxNode::new_root(GreenNode::new(self.data))
    }
}

impl<T: AstNode> RawNodeBuilder<T> {
    pub fn new() -> RawNodeBuilder<T> {
        match T::META {
            Layout::Sequence(sequence) => RawNodeBuilder {
                data: GreenNodeData::new(sequence.kind),
                _marker: PhantomData,
            },
            Layout::List(list) => RawNodeBuilder {
                data: GreenNodeData::new(list.kind),
                _marker: PhantomData,
            },
            Layout::Choice(_) => unreachable!("Choice nodes cannot be built"),
        }
    }

    pub fn finish(self) -> T {
        T::cast_unchecked(self.finish_untyped())
    }
}