Struct rowan::ast::SyntaxNodePtr

pub struct SyntaxNodePtr<L: Language> { /* private fields */ }

A “pointer” to a SyntaxNode, via location in the source code.

Note

Since the location is source code dependent, this must not be used with mutable syntax trees. Any changes made in such trees causes the pointed node’s source location to change, invalidating the pointer.

Implementations

impl<L: Language> SyntaxNodePtr<L>

pub fn new(node: &SyntaxNode<L>) -> Self

Returns a SyntaxNodePtr for the node.

Panics if the provided node is mutable

pub fn to_node(&self, root: &SyntaxNode<L>) -> SyntaxNode<L>

Like Self::try_to_node but panics instead of returning None on failure.

pub fn try_to_node(&self, root: &SyntaxNode<L>) -> Option<SyntaxNode<L>>

“Dereferences” the pointer to get the SyntaxNode it points to.

Returns None if the node is not found, so make sure that the root syntax tree is equivalent to (i.e. is build from the same text from) the tree which was originally used to get this SyntaxNodePtr.

Also returns None if root is not actually a root (i.e. it has a parent).

NOTE: If this function is called on a mutable tree, it will panic

The complexity is linear in the depth of the tree and logarithmic in tree width. As most trees are shallow, thinking about this as O(log(N)) in the size of the tree is not too wrong!

pub fn cast<N: AstNode<Language = L>>(self) -> Option<AstPtr<N>>

Casts this to an AstPtr to the given node type if possible.

pub fn kind(&self) -> L::Kind

Returns the kind of the syntax node this points to.

pub fn text_range(&self) -> TextRange

Returns the range of the syntax node this points to.

Trait Implementations

impl<L: Clone + Language> Clone for SyntaxNodePtr<L>

where L::Kind: Clone,

fn clone(&self) -> SyntaxNodePtr<L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug + Language> Debug for SyntaxNodePtr<L>

where L::Kind: Debug,

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

Formats the value using the given formatter.

impl<N: AstNode> From<AstPtr<N>> for SyntaxNodePtr<N::Language>

fn from(ptr: AstPtr<N>) -> SyntaxNodePtr<N::Language>

Converts to this type from the input type.

impl<L: Hash + Language> Hash for SyntaxNodePtr<L>

where L::Kind: Hash,

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<L: PartialEq + Language> PartialEq for SyntaxNodePtr<L>

where L::Kind: PartialEq,

fn eq(&self, other: &SyntaxNodePtr<L>) -> 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<L: Copy + Language> Copy for SyntaxNodePtr<L>

where L::Kind: Copy,

impl<L: Eq + Language> Eq for SyntaxNodePtr<L>

where L::Kind: Eq,

impl<L: Language> StructuralPartialEq for SyntaxNodePtr<L>