Struct SyntaxNode 

pub struct SyntaxNode { /* private fields */ }

Node in the red syntax tree.

Implementations

impl SyntaxNode

pub fn new_root(green: GreenNode) -> Self

Build a new syntax tree on top of a green tree.

pub fn kind(&self) -> SyntaxKind

Kind of this node.

pub fn text_range(&self) -> TextRange

The range that this node covers in the original text.

pub fn green(&self) -> &GreenNode

The underlying green node of this red node.

pub fn amber(&self) -> AmberNode<'_>

The corresponding amber node of this red node.

pub fn parent(&self) -> Option<SyntaxNode>

Parent of this node. It returns None if this node is the root.

pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode>

Iterator along the chain of parents of this node.

pub fn children(&self) -> SyntaxNodeChildren

Iterator over the child nodes of this node.

If you want to iterate over both nodes and tokens, use children_with_tokens instead.

Though you can filter specific kinds of children on this iterator manually, it is more efficient to use children_by_kind instead.

pub fn children_by_kind<M>( &self, matcher: M, ) -> impl DoubleEndedIterator<Item = SyntaxNode> + use<'_, M>

where M: SyntaxKindMatch,

Iterator over specific kinds of child nodes of this node. This is more efficient than filtering with children manually.

pub fn tokens_by_kind<M>( &self, matcher: M, ) -> impl DoubleEndedIterator<Item = SyntaxToken> + use<'_, M>

where M: SyntaxKindMatch,

Iterator over specific kinds of child tokens of this node.

pub fn children_with_tokens( &self, ) -> impl DoubleEndedIterator<Item = NodeOrToken<SyntaxNode, SyntaxToken>>

Iterator over the child nodes and tokens of this node.

pub fn has_child_or_token_by_kind<M>(&self, matcher: M) -> bool

where M: SyntaxKindMatch,

Check if this node has specific kinds of child nodes or tokens.

This is an efficient alternative to node.children_with_tokens().any(...) since it won’t create any nodes or tokens.

pub fn next_siblings(&self) -> impl Iterator<Item = SyntaxNode>

Nodes that come immediately after this node.

If you want to iterate over both nodes and tokens, use next_siblings_with_tokens instead.

Unlike rowan, the iterator doesn’t contain the current node itself.

pub fn next_sibling_or_token( &self, ) -> Option<NodeOrToken<SyntaxNode, SyntaxToken>>

Node or token that comes immediately after this node.

pub fn next_siblings_with_tokens( &self, ) -> impl Iterator<Item = NodeOrToken<SyntaxNode, SyntaxToken>>

Nodes and tokens that come immediately after this node.

Unlike rowan, the iterator doesn’t contain the current node itself.

pub fn next_consecutive_tokens(&self) -> impl Iterator<Item = SyntaxToken>

Consecutive tokens sequence that come immediately after this node without any nodes in between.

pub fn prev_siblings(&self) -> impl Iterator<Item = SyntaxNode>

Nodes that come immediately before this node.

If you want to iterate over both nodes and tokens, use prev_siblings_with_tokens instead.

Unlike rowan, the iterator doesn’t contain the current node itself.

pub fn prev_sibling_or_token( &self, ) -> Option<NodeOrToken<SyntaxNode, SyntaxToken>>

Node or token that comes immediately before this node.

pub fn prev_siblings_with_tokens( &self, ) -> impl Iterator<Item = NodeOrToken<SyntaxNode, SyntaxToken>>

Nodes and tokens that come immediately before this node.

Unlike rowan, the iterator doesn’t contain the current node itself.

pub fn prev_consecutive_tokens(&self) -> impl Iterator<Item = SyntaxToken>

Consecutive tokens sequence that come immediately before this node without any nodes in between.

pub fn descendants(&self) -> impl Iterator<Item = SyntaxNode>

Iterator over all nodes in the subtree, including this node itself.

pub fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset

Find a token in the subtree corresponding to this node, which covers the offset.

pub fn child_at_range(&self, range: TextRange) -> Option<SyntaxNode>

Find a child node that intersects with the given range.

pub fn replace_with(&self, replacement: GreenNode) -> GreenNode

Replace this node with new green node. It returns new root green node with replaced node.

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 Display for SyntaxNode

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

Formats the value using the given formatter.

impl<'a> From<&'a SyntaxNode> for AmberNode<'a>

fn from(node: &'a SyntaxNode) -> Self

Converts to this type from the input type.

impl From<SyntaxNode> for NodeOrToken<SyntaxNode, SyntaxToken>

fn from(node: SyntaxNode) -> Self

Converts to this type from the input type.

impl Hash for SyntaxNode

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 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