Struct GreenNode 

pub struct GreenNode { /* private fields */ }

An immutable, byte-faithful syntax-tree node.

A GreenNode is purely structural — it carries kind, text_len, and an Arc<[GreenChild]> of children. The actual source text lives elsewhere (on the owning crate::cst::Document), and every text-bearing API takes the source as an argument.

Cloning a GreenNode is O(1) — three Arc increments at most.

The text of a node is the concatenation, in document order, of the text of every descendant leaf. For an unmodified parse this equals the input.

Examples

use noyalib::cst::parse_document;

let src = "key: value\n";
let doc = parse_document(src).unwrap();
assert_eq!(doc.syntax().text_len(), src.len());
assert_eq!(doc.syntax().text(src), src);

Implementations

impl GreenNode

pub fn new(kind: SyntaxKind, children: Vec<GreenChild>) -> Self

Build a green node from its kind and children. The total text_len is summed from the children — callers do not need to compute it separately.

Panics

Panics if the children’s total length exceeds u32::MAX bytes. The crate’s own builders use the fallible form and return an error instead.

pub fn kind(&self) -> SyntaxKind

Classification of this node.

pub fn text_len(&self) -> usize

Total byte length of this node’s text.

Returns usize for ergonomic arithmetic at call sites; the underlying u32 storage is widened at this boundary.

pub fn children(&self) -> impl Iterator<Item = &GreenChild>

Iterate immediate children of this node.

pub fn text(&self, source: &str) -> String

Concatenation of every descendant leaf’s text in document order, given the source string the leaves index into. For an unmodified parse this is identical to the input. For a post-edit document call this with crate::cst::Document::source.

Trait Implementations

impl Clone for GreenNode

fn clone(&self) -> GreenNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GreenNode

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

Formats the value using the given formatter.

impl Drop for GreenNode

fn drop(&mut self)

Release the subtree without recursion.

The derived drop would recurse once per nesting level, so a deep enough tree would exhaust the stack while it is being freed. Each uniquely owned child list is detached and pushed on a heap stack instead, so every node is dropped with an empty child list. Shared lists (still referenced by another tree after an edit) only lose a reference count.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.