Struct AstPtr

pub struct AstPtr<N: AstNode> { /* private fields */ }

Like SyntaxNodePtr, but remembers the type of node.

Note

As with SyntaxNodePtr, this must not be used on mutable syntax trees, since any mutation can cause the pointed node’s source location to change, invalidating the pointer

Implementations

impl<N: AstNode> AstPtr<N>

pub fn new(node: &N) -> Self

Returns an AstPtr for the node.

Panics if the provided node is mutable

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

Like Self::try_to_node but panics on failure.

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

Given the root node containing the node n that self is a pointer to, returns n if possible. Panics if root is mutable. See SyntaxNodePtr::try_to_node.

pub fn syntax_node_ptr(&self) -> SyntaxNodePtr<N::Language>

Returns the underlying SyntaxNodePtr.

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

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

Trait Implementations

impl<N: AstNode> Clone for AstPtr<N>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: AstNode> Debug for AstPtr<N>

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<N: AstNode> Hash for AstPtr<N>

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<N: AstNode> PartialEq for AstPtr<N>

fn eq(&self, other: &AstPtr<N>) -> 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<N: AstNode> Eq for AstPtr<N>