Struct LinkedNode 

pub struct LinkedNode<'a> { /* private fields */ }

A syntax node in a context.

Knows its exact offset in the file and provides access to its children, parent and siblings.

Note that all sibling and leaf accessors skip over trivia!

Implementations

impl<'a> LinkedNode<'a>

pub fn new(root: &'a SyntaxNode) -> Self

Start a new traversal at a root node.

pub fn get(&self) -> &'a SyntaxNode

Get the contained syntax node.

pub fn index(&self) -> usize

The index of this node in its parent’s children list.

pub fn offset(&self) -> usize

The absolute byte offset of this node in the source file.

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

The byte range of this node in the source file.

pub fn children(&self) -> LinkedChildren<'a>

An iterator over this node’s children.

pub fn find(&self, span: Span) -> Option<Self>

Find a descendant with the given span.

pub fn mode_after(&self) -> Option<SyntaxMode>

Get the SyntaxMode we will be in when immediately after this node.

Unlike some other LinkedNode methods, this does not treat all trivia the same: it returns None for both comments and the bodies of raw text and returns Some for whitespace (based on the parent’s mode). The only other way this would return None is when inside a partial tree, i.e. one not rooted in Markup, Math, or Code.

Also note that errors inherit the mode of their parent.

pub fn parent_mode(&self) -> Option<SyntaxMode>

Get the SyntaxMode we will be in when immediately after the parent of this node.

impl LinkedNode<'_>

Access to parents and siblings.

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

Get this node’s parent.

pub fn prev_sibling(&self) -> Option<Self>

Get the first previous non-trivia sibling node.

pub fn prev_sibling_with_trivia(&self) -> Option<Self>

Get the first previous sibling node, including potential trivia.

pub fn next_sibling(&self) -> Option<Self>

Get the next non-trivia sibling node.

pub fn next_sibling_with_trivia(&self) -> Option<Self>

Get the next sibling node, including potential trivia.

pub fn parent_kind(&self) -> Option<SyntaxKind>

Get the kind of this node’s parent.

pub fn prev_sibling_kind(&self) -> Option<SyntaxKind>

Get the kind of this node’s first previous non-trivia sibling.

pub fn next_sibling_kind(&self) -> Option<SyntaxKind>

Get the kind of this node’s next non-trivia sibling.

impl LinkedNode<'_>

Access to leaves.

pub fn prev_leaf(&self) -> Option<Self>

Get the rightmost non-trivia leaf before this node.

pub fn leftmost_leaf(&self) -> Option<Self>

Find the leftmost contained non-trivia leaf.

pub fn leaf_at(&self, cursor: usize, side: Side) -> Option<Self>

Get the leaf at the specified byte offset.

pub fn rightmost_leaf(&self) -> Option<Self>

Find the rightmost contained non-trivia leaf.

pub fn next_leaf(&self) -> Option<Self>

Get the leftmost non-trivia leaf after this node.

Methods from Deref<Target = SyntaxNode>

pub fn is<'a, T: AstNode<'a>>(&'a self) -> bool

Whether the node can be cast to the given AST node.

pub fn cast<'a, T: AstNode<'a>>(&'a self) -> Option<T>

Try to convert the node to a typed AST node.

pub fn kind(&self) -> SyntaxKind

The type of the node.

pub fn is_empty(&self) -> bool

Return true if the length is 0.

pub fn len(&self) -> usize

The byte length of the node in the source text.

pub fn span(&self) -> Span

The span of the node.

pub fn leaf_text(&self) -> &EcoString

The text of the node if it is a leaf or error node.

Returns the empty string if this is an inner node.

pub fn full_text(&self) -> EcoString

Clone the full text from the node. If this is an inner node, it will traverse the tree to build the text which may be expensive.

pub fn children(&self) -> Iter<'_, SyntaxNode>

The node’s children.

pub fn diagnosis(&self) -> Diagnosis

Whether the node has diagnostic errors and/or warnings in it or its children. Diagnosis has public fields, so you can write node.diagnosis().errors to determine if a node is erroneous.

This can be used to determine whether Self::errors_and_warnings will return an empty vector without traversing the tree if it will not.

pub fn errors_and_warnings( &self, ) -> (Vec<SyntaxDiagnostic>, Vec<SyntaxDiagnostic>)

The error and warning diagnostics for this node and its descendants.

pub fn spanless_eq(&self, other: &Self) -> bool

Whether the two syntax nodes are the same apart from spans.

Trait Implementations

impl<'a> Clone for LinkedNode<'a>

fn clone(&self) -> LinkedNode<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinkedNode<'_>

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

Formats the value using the given formatter.

impl Deref for LinkedNode<'_>

fn deref(&self) -> &Self::Target

Dereference to a syntax node. Note that this shortens the lifetime, so you may need to use get() instead in some situations.

type Target = SyntaxNode

The resulting type after dereferencing.