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>

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

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

Also panics 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 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, 

Feeds a slice of this type into the given Hasher.

impl<L: PartialEq + Language> PartialEq<SyntaxNodePtr<L>> 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: &SyntaxNodePtr<L>) -> bool

This method tests for !=.

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>