Struct GreenNode 

pub struct GreenNode<'a, L: Language> {
    pub kind: L::ElementType,
    pub children: &'a [GreenTree<'a, L>],
    pub byte_length: u32,
}

A green node that contains child elements.

Green nodes are allocated in a SyntaxArena and hold a slice reference to their children. They are POD (Plain Old Data) and strictly immutable.

Unlike red nodes, green nodes do not know their absolute position in the source code, which makes them highly reusable for incremental parsing.

Fields

kind: L::ElementType

The element type (kind) of this node.

children: &'a [GreenTree<'a, L>]

The children of this node, which can be other nodes or leaf tokens.

byte_length: u32

The total text length of this node (sum of children’s lengths) in bytes.

Implementations

impl<'a, L: Language> GreenNode<'a, L>

pub fn new(kind: L::ElementType, children: &'a [GreenTree<'a, L>]) -> Self

Creates a new green node from child elements.

This function assumes the children slice is already allocated in the arena. It automatically calculates the total text_len by summing child lengths.

Arguments

• kind - The node type.
• children - The slice of child elements.

pub fn kind(&self) -> L::ElementType

Returns the kind of this node.

pub fn text_len(&self) -> u32

Returns the total text length of this node in bytes.

pub fn children(&self) -> &'a [GreenTree<'a, L>]

Returns the children of this node.

pub fn child_at(&self, index: usize) -> Option<&'a GreenTree<'a, L>>

Returns a specific child at index.

Returns None if the index is out of bounds.

pub fn has_children(&self) -> bool

Checks if this node has any children.

pub fn children_count(&self) -> usize

Returns the number of children in this node.

Trait Implementations

impl<'a, L: Language> Clone for GreenNode<'a, L>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, L: Language> Debug for GreenNode<'a, L>

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

Formats the value using the given formatter.

impl<'a, L: Language> Hash for GreenNode<'a, L>

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<'a, L: Language> PartialEq for GreenNode<'a, L>

fn eq(&self, other: &Self) -> 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<'a, L: Language> Eq for GreenNode<'a, L>