Struct AstNode 

pub struct AstNode<'r, D>
where
    D: Doc,
{ /* private fields */ }

A single node in an Abstract Syntax Tree.

Node represents a specific element in the parsed AST, such as a function declaration, variable assignment, or expression. Each node knows its position in the source code, its type (kind), and provides methods for navigation and pattern matching.

Lifetime

The lifetime 'r ties the node to its root AST, ensuring memory safety. Nodes cannot outlive the Root that owns the underlying tree structure.

Example

let ast = Language::Tsx.ast_grep("function hello() { return 'world'; }");
let root_node = ast.root();

// Check the node type
println!("Root kind: {}", root_node.kind());

// Navigate to children
for child in root_node.children() {
    println!("Child: {} at {}:{}", child.kind(),
        child.start_pos().line(), child.start_pos().column(&child));
}

// Find specific patterns
if let Some(return_stmt) = root_node.find("return $VALUE") {
    let value = return_stmt.get_env().get_match("VALUE").unwrap();
    println!("Returns: {}", value.text());
}

Implementations

impl<'r, D> Node<'r, D>

where D: Doc,

APIs for Node inspection

pub const fn get_doc(&self) -> &'r D

pub fn node_id(&self) -> usize

pub fn is_leaf(&self) -> bool

pub fn is_named_leaf(&self) -> bool

if has no named children. N.B. it is different from is_named && is_leaf

pub fn is_error(&self) -> bool

pub fn kind(&self) -> Cow<'_, str>

pub fn kind_id(&self) -> u16

pub fn is_named(&self) -> bool

pub fn is_missing(&self) -> bool

pub fn range(&self) -> Range<usize>

byte offsets of start and end.

pub fn start_pos(&self) -> Position

Nodes’ start position in terms of zero-based rows and columns.

pub fn end_pos(&self) -> Position

Nodes’ end position in terms of rows and columns.

pub fn text(&self) -> Cow<'r, str>

pub fn lang(&self) -> &'r <D as Doc>::Lang

pub fn get_inner_node(&self) -> <D as Doc>::Node<'r>

the underlying tree-sitter Node

pub const fn root(&self) -> &'r Root<D>

impl<D> Node<'_, D>

where D: Doc,

Corresponds to inside/has/precedes/follows

pub fn matches<M>(&self, m: M) -> bool

where M: Matcher,

pub fn inside<M>(&self, m: M) -> bool

where M: Matcher,

pub fn has<M>(&self, m: M) -> bool

where M: Matcher,

pub fn precedes<M>(&self, m: M) -> bool

where M: Matcher,

pub fn follows<M>(&self, m: M) -> bool

where M: Matcher,

impl<'r, D> Node<'r, D>

where D: Doc,

tree traversal API

pub fn parent(&self) -> Option<Node<'r, D>>

pub fn children(&self) -> impl ExactSizeIterator

pub fn child(&self, nth: usize) -> Option<Node<'r, D>>

pub fn field(&self, name: &str) -> Option<Node<'r, D>>

pub fn child_by_field_id(&self, field_id: u16) -> Option<Node<'r, D>>

pub fn field_children(&self, name: &str) -> impl Iterator<Item = Node<'r, D>>

pub fn ancestors(&self) -> impl Iterator<Item = Node<'r, D>>

Returns all ancestors nodes of self. Using cursor is overkill here because adjust cursor is too expensive.

pub fn next(&self) -> Option<Node<'r, D>>

pub fn next_all(&self) -> impl Iterator<Item = Node<'r, D>>

Returns all sibling nodes next to self.

pub fn prev(&self) -> Option<Node<'r, D>>

pub fn prev_all(&self) -> impl Iterator<Item = Node<'r, D>>

pub fn dfs<'s>(&'s self) -> impl Iterator<Item = Node<'r, D>> + 's

pub fn find<M>(&self, pat: M) -> Option<NodeMatch<'r, D>>

where M: Matcher,

pub fn find_all<'s, M>( &'s self, pat: M, ) -> impl Iterator<Item = NodeMatch<'r, D>> + 's

where M: Matcher + 's,

impl<D> Node<'_, D>

where D: Doc,

Tree manipulation API

pub fn replace<M, R>( &self, matcher: M, replacer: R, ) -> Option<Edit<<D as Doc>::Source>>

where M: Matcher, R: Replacer<D>,

pub fn after(&self) -> Edit<<D as Doc>::Source>

pub fn before(&self) -> Edit<<D as Doc>::Source>

pub fn append(&self) -> Edit<<D as Doc>::Source>

pub fn prepend(&self) -> Edit<<D as Doc>::Source>

pub fn empty(&self) -> Option<Edit<<D as Doc>::Source>>

Empty children. Remove all child node

pub fn remove(&self) -> Edit<<D as Doc>::Source>

Remove the node itself

impl<'r, L> Node<'r, StrDoc<L>>

where L: LanguageExt,

these methods are only for StrDoc

pub fn replace_all<M, R>(&self, matcher: M, replacer: R) -> Vec<Edit<String>>

where M: Matcher, R: Replacer<StrDoc<L>>,

Trait Implementations

impl<'tree, D> Borrow<Node<'tree, D>> for NodeMatch<'tree, D>

where D: Doc,

NodeMatch is an immutable view to Node

fn borrow(&self) -> &Node<'tree, D>

Immutably borrows from an owned value.

impl<'r, D> Clone for Node<'r, D>

where D: Clone + Doc, <D as Doc>::Node<'r>: Clone,

fn clone(&self) -> Node<'r, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'r, D> Debug for Node<'r, D>

where D: Debug + Doc, <D as Doc>::Node<'r>: Debug,

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

Formats the value using the given formatter.

impl<'r, D> From<Node<'r, D>> for PatternNode

where D: Doc,

fn from(node: Node<'r, D>) -> PatternNode

Converts to this type from the input type.

impl<'r, D> From<Node<'r, D>> for Pattern

where D: Doc,

fn from(node: Node<'r, D>) -> Pattern

Converts to this type from the input type.

impl<'tree, D> From<Node<'tree, D>> for NodeMatch<'tree, D>

where D: Doc,

fn from(node: Node<'tree, D>) -> NodeMatch<'tree, D>

Converts to this type from the input type.

impl<'tree, D> From<NodeMatch<'tree, D>> for Node<'tree, D>

where D: Doc,

NodeMatch is an immutable view to Node

fn from(node_match: NodeMatch<'tree, D>) -> Node<'tree, D>

Converts to this type from the input type.

impl<D> Replacer<D> for Node<'_, D>

where D: Doc,

fn generate_replacement( &self, _nm: &NodeMatch<'_, D>, ) -> Vec<<<D as Doc>::Source as Content>::Underlying>

Generate replacement content for a matched node.

fn get_replaced_range( &self, nm: &NodeMatch<'_, D>, matcher: impl Matcher, ) -> Range<usize>

Determine the exact range of source code to replace.