Type Alias SyntaxNodePtr

pub type SyntaxNodePtr = SyntaxNodePtr<RustLanguage>;

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

Aliased Type

struct SyntaxNodePtr { /* private fields */ }

Implementations

impl<L> SyntaxNodePtr<L>

where L: Language,

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

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>(self) -> Option<AstPtr<N>>

where N: AstNode<Language = L>,

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

pub fn kind(&self) -> <L as Language>::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<N: AstNode> From<AstPtr<N>> for SyntaxNodePtr

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

Converts to this type from the input type.

impl<L> Clone for SyntaxNodePtr<L>

where L: Clone + Language, <L as Language>::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 for SyntaxNodePtr<L>

where L: Debug + Language, <L as Language>::Kind: Debug,

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

Formats the value using the given formatter.

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

where N: AstNode,

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

Converts to this type from the input type.

impl<L> Hash for SyntaxNodePtr<L>

where L: Hash + Language, <L as Language>::Kind: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 for SyntaxNodePtr<L>

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

where L: Copy + Language, <L as Language>::Kind: Copy,

impl<L> Eq for SyntaxNodePtr<L>

where L: Eq + Language, <L as Language>::Kind: Eq,

impl<L> StructuralPartialEq for SyntaxNodePtr<L>

where L: Language,