Struct SyntaxNode 

pub struct SyntaxNode { /* private fields */ }

A branch node in the syntax tree.

Holds an ordered list of child SyntaxElements (nodes or tokens).

Implementations

impl SyntaxNode

pub fn new( kind: SyntaxKind, range: TextRange, children: Vec<SyntaxElement>, ) -> Self

Creates a new node with the given kind, range, and children.

pub fn kind(&self) -> SyntaxKind

The kind of this node.

pub fn range(&self) -> &TextRange

The source range of this node.

Examples found in repository

examples/parse_numpy.rs (line 48)

fn main() {
    let docstring = r#"
Calculate the area of a rectangle.

This function takes the width and height of a rectangle
and returns its area.

Parameters
----------
width : float
    The width of the rectangle.
height : float
    The height of the rectangle.

Returns
-------
float
    The area of the rectangle.

Raises
------
ValueError
    If width or height is negative.

Examples
--------
>>> calculate_area(5.0, 3.0)
15.0
"#;

    let parsed = parse_numpy(docstring);
    let doc = NumPyDocstring::cast(parsed.root()).unwrap();

    println!("╔══════════════════════════════════════════════════╗");
    println!("║          NumPy-style Docstring Example           ║");
    println!("╚══════════════════════════════════════════════════╝");

    println!();

    // Display: raw source text
    println!("── raw text ────────────────────────────────────────");
    println!("{}", doc.syntax().range().source_text(parsed.source()));

    println!();

    // pretty_print: structured AST
    println!("── parsed AST ──────────────────────────────────────");
    print!("{}", parsed.pretty_print());
}

pub fn children(&self) -> &[SyntaxElement]

The ordered child elements.

pub fn children_mut(&mut self) -> &mut [SyntaxElement]

Mutable access to the ordered child elements.

pub fn push_child(&mut self, child: SyntaxElement)

Append a child element.

pub fn extend_range_to(&mut self, end: TextSize)

Extend this node’s range end to end.

pub fn find_token(&self, kind: SyntaxKind) -> Option<&SyntaxToken>

Find the first token child with the given kind.

pub fn required_token(&self, kind: SyntaxKind) -> &SyntaxToken

Return the first token child with the given kind.

Panics

Panics if no such token exists. This should only be used for tokens that the parser guarantees to be present.

pub fn tokens(&self, kind: SyntaxKind) -> impl Iterator<Item = &SyntaxToken>

Iterate over all token children with the given kind.

pub fn find_node(&self, kind: SyntaxKind) -> Option<&SyntaxNode>

Find the first child node with the given kind.

pub fn nodes(&self, kind: SyntaxKind) -> impl Iterator<Item = &SyntaxNode>

Iterate over all child nodes with the given kind.

pub fn pretty_fmt(&self, src: &str, indent: usize, out: &mut String)

Write a pretty-printed tree representation.

Trait Implementations

impl Clone for SyntaxNode

fn clone(&self) -> SyntaxNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyntaxNode

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

Formats the value using the given formatter.

impl PartialEq for SyntaxNode

fn eq(&self, other: &SyntaxNode) -> 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 Eq for SyntaxNode

impl StructuralPartialEq for SyntaxNode