Type Definition rslint_parser::SyntaxNode

type SyntaxNode = SyntaxNode<JsLanguage>;

Trait Implementations

impl SyntaxNodeExt for SyntaxNode

fn to_node(&self) -> &SyntaxNode

fn tokens(&self) -> Vec<SyntaxToken>

Get all of the tokens of this node, recursively, including whitespace and comments.

fn lossy_tokens(&self) -> Vec<SyntaxToken>

Get all the tokens of this node, recursively, not including whitespace and comments.

fn first_lossy_token(&self) -> Option<SyntaxToken>

Get the first non-whitespace child token.

fn is<T: AstNode>(&self) -> bool

Check if the node is a certain AST node and that it can be casted to it.

fn to<T: AstNode>(&self) -> T

Cast this node to a certain AST node.

fn try_to<T: AstNode>(&self) -> Option<T>

Try to cast this node to a certain AST node

fn lexical_eq(&self, right: &SyntaxNode) -> bool

Compare two syntax nodes by comparing their underlying non-whitespace tokens.

fn color(&self) -> String

Syntax highlight the node's text into an ANSI string. If stdout and stderr are not terminals, this will return the raw node text.

fn trimmed_range(&self) -> TextRange

Get the text range of this node, not including any leading or trailing whitespace.

fn trimmed_text(&self) -> SyntaxText

Get the text of this node, not including leading or trailing whitespace

fn in_ts(&self, set: TokenSet) -> bool

Check whether this node's kind is contained in a token set.

fn readable_stmt_name(&self) -> String

A human readable name for this node's kind. e.g.: BREAK_STMT => Break statement

fn is_loop(&self) -> bool

Whether this node is an iteration statement.

fn descendants_with<F>(&self, func: &mut F) where
    F: FnMut(&SyntaxNode) -> bool, 

Go over the descendants of this node, at every descendant call func, and keep traversing the descendants of that node if the function's return is true. If the function returns false then stop traversing the descendants of that node go on to the next child.

fn structural_lossy_token_eq(&self, tokens: &[impl AsRef<str>]) -> bool

Separate all the lossy tokens of this node, then compare each token's text with the corresponding text in tokens.

fn contains_comments(&self) -> bool

Whether the node contains any comments.

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

Get the first child with a specific kind.

fn expr_parent(&self) -> Option<SyntaxNode>

Get the parent of this node, recursing through any grouping expressions

fn child_with_ast<T: AstNode>(&self) -> Option<T>

Get the first child in this node that can be casted to an AST node

fn descendants_with_tokens_with<F>(&self, func: &mut F) where
    F: FnMut(&SyntaxElement) -> bool, 

Same as descendants_with but considers tokens too.