Enum GreenChild 

pub enum GreenChild {
    Node(GreenNode),
    Token {
        kind: SyntaxKind,
        len: u32,
    },
}

A leaf-or-node child of a GreenNode.

Token leaves carry only their byte length within their parent. To materialise text, walk the tree from the root and pass the running offset down (see GreenChild::token_text).

Examples

use noyalib::cst::{parse_document, GreenChild, SyntaxKind};

let doc = parse_document("a: 1\n").unwrap();
let src = doc.source();
// Walk children, tracking byte offset, to materialise leaf text.
let mut offset = 0;
for child in doc.syntax().children() {
    if let GreenChild::Token { kind, len } = child {
        // `len` is `u32` — cast to `usize` for slice arithmetic.
        let text = &src[offset..offset + *len as usize];
        assert_eq!(text.is_empty(), false);
        let _ = (kind, text);
    }
    offset += child.text_len();
}

Variants

Node(GreenNode)

A nested node.

Token

A leaf token. len is its byte length in the source — its absolute position depends on the running offset accumulated while walking from the root.

len is u32 (not usize) — YAML documents are bounded at 4 GiB by the parser’s max_document_length cap, and the narrower field halves the size of every leaf in the CST. On a 64-bit target this drops GreenChild::Token from 24 bytes to 8 bytes and meaningfully improves L1/L2 cache locality on tree traversals. Cast to usize at arithmetic call sites: &source[offset..offset + len as usize].

Fields

kind: SyntaxKind

Classification of this leaf.

len: u32

Byte length of this leaf in the source.

Implementations

impl GreenChild

pub fn text_len(&self) -> usize

Total byte length of this child’s contribution to its parent’s text. For nodes this is text_len(); for tokens it is len.

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

pub fn token_text<'s>(&self, source: &'s str, offset: usize) -> Option<&'s str>

Borrow the source text of this leaf, given source (the document’s source) and offset (the running byte position at which this child begins). Returns None for Node variants — recurse into them with offset + 0 as the new base for their children.

Examples

use noyalib::cst::{parse_document, GreenChild, GreenNode};

fn first_leaf_text<'a>(node: &GreenNode, src: &'a str, base: usize) -> Option<&'a str> {
    let mut offset = base;
    for c in node.children() {
        match c {
            GreenChild::Token { .. } => return c.token_text(src, offset),
            GreenChild::Node(n) => {
                if let Some(t) = first_leaf_text(n, src, offset) {
                    return Some(t);
                }
            }
        }
        offset += c.text_len();
    }
    None
}

let doc = parse_document("a: 1\n").unwrap();
assert_eq!(first_leaf_text(doc.syntax(), doc.source(), 0), Some("a"));

Trait Implementations

impl Clone for GreenChild

fn clone(&self) -> GreenChild

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GreenChild

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

Formats the value using the given formatter.