Struct rowan::ast::SyntaxNodePtr

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

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

Implementations

impl<L: Language> SyntaxNodePtr<L>

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

Returns a SyntaxNodePtr for the node.

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

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method 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> StructuralEq for SyntaxNodePtr<L>

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