Struct AmberNode 

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

Node in the amber syntax tree.

It’s a lightweight version of SyntaxNode without access to parent and siblings. It’s much cheaper than SyntaxNode to create and use. This is preferred to use for better performance if you don’t need to visit parent and siblings.

Implementations

impl<'a> AmberNode<'a>

pub fn new_root(green: &'a GreenNode) -> Self

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

pub fn new(green: &'a GreenNode, start: TextSize) -> Self

Create a new amber node with the given green node based on the offset.

Note that passing wrong offset can cause unexpectedly incorrect syntax tree. Be careful.

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) -> &'a GreenNode

The underlying green node of this amber node.

pub fn to_ptr(&self) -> SyntaxNodePtr

The corresponding SyntaxNodePtr of this amber node.

pub fn children(&self) -> impl DoubleEndedIterator<Item = AmberNode<'a>> + Clone

Iterator over the child nodes of this node.

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

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

where M: SyntaxKindMatch,

Iterator over specific kinds of child nodes of this node.

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

where M: SyntaxKindMatch,

Iterator over specific kinds of child tokens of this node.

pub fn children_with_tokens( &self, ) -> impl DoubleEndedIterator<Item = NodeOrToken<AmberNode<'a>, AmberToken<'a>>>

Iterator over the child nodes and tokens of this node.

pub fn descendant_tokens( &self, ) -> impl Iterator<Item = (AmberToken<'a>, AmberNode<'a>, Option<AmberNode<'a>>)> + 'a

Iterator over all tokens in the subtree.

The iterator yields a three-component tuple:

1. current token
2. the parent of current token
3. the grandparent of current token

Trait Implementations

impl<'a> Clone for AmberNode<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Converts to this type from the input type.

impl<'a> From<AmberNode<'a>> for NodeOrToken<AmberNode<'a>, AmberToken<'a>>

fn from(node: AmberNode<'a>) -> Self

Converts to this type from the input type.

impl<'a> Hash for AmberNode<'a>

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<'a> PartialEq for AmberNode<'a>

fn eq(&self, other: &AmberNode<'a>) -> 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<'a> Copy for AmberNode<'a>

impl<'a> Eq for AmberNode<'a>

impl<'a> StructuralPartialEq for AmberNode<'a>