Struct ResolvedNode 

pub struct ResolvedNode<S: Syntax, D: 'static = ()> { /* private fields */ }

Syntax tree node that is guaranteed to belong to a tree that contains an associated Resolver.

See also

SyntaxNode SyntaxNode::new_root_with_resolver

Implementations

impl<S: Syntax, D> ResolvedNode<S, D>

pub fn syntax(&self) -> &SyntaxNode<S, D>

Returns this node as a SyntaxNode.

impl<S: Syntax, D> ResolvedNode<S, D>

pub fn text(&self) -> SyntaxText<'_, '_, dyn Resolver<TokenKey>, S, D>

Uses the resolver associated with this tree to return an efficient representation of all source text covered by this node, i.e. the combined text of all token leafs of the subtree originating in this node.

impl<S, D> ResolvedNode<S, D>

where S: Syntax,

pub fn as_serialize_with_data(&self) -> impl Serialize + '_

where D: Serialize,

Available on crate feature serialize only.

Return an anonymous object that can be used to serialize this node, including the data for each node.

impl<S: Syntax, D> ResolvedNode<S, D>

pub fn resolver(&self) -> &StdArc<dyn Resolver<TokenKey>>

Returns the Resolver associated with this tree.

pub fn new_root_with_resolver( green: GreenNode, resolver: impl Resolver<TokenKey> + 'static, ) -> Self

See SyntaxNode::new_root_with_resolver.

pub fn try_resolved(&self) -> Option<&ResolvedNode<S, D>>

Always returns Some(self).

This method mostly exists to allow the convenience of being agnostic over SyntaxNode vs ResolvedNode.

pub fn resolved(&self) -> &ResolvedNode<S, D>

Always returns self.

This method mostly exists to allow the convenience of being agnostic over SyntaxNode vs ResolvedNode.

pub fn root(&self) -> &SyntaxNode<S, D>

The root of the tree this node belongs to.

If this node is the root, returns self.

pub fn parent(&self) -> Option<&Self>

The parent node of this node, except if this node is the root.

pub fn ancestors(&self) -> impl Iterator<Item = &Self>

Returns an iterator along the chain of parents of this node.

pub fn children(&self) -> impl Iterator<Item = &Self>

Returns an iterator over all nodes that are children of this node.

If you want to also consider leafs, see children_with_tokens.

pub fn children_with_tokens( &self, ) -> impl Iterator<Item = ResolvedElementRef<'_, S, D>>

Returns an iterator over child elements of this node, including tokens.

pub fn first_child(&self) -> Option<&ResolvedNode<S, D>>

The first child node of this node, if any.

If you want to also consider leafs, see first_child_or_token.

pub fn first_child_or_token(&self) -> Option<ResolvedElementRef<'_, S, D>>

The first child element of this node, if any, including tokens.

pub fn last_child(&self) -> Option<&ResolvedNode<S, D>>

The last child node of this node, if any.

If you want to also consider leafs, see last_child_or_token.

pub fn last_child_or_token(&self) -> Option<ResolvedElementRef<'_, S, D>>

The last child element of this node, if any, including tokens.

pub fn next_child_after( &self, n: usize, offset: TextSize, ) -> Option<&ResolvedNode<S, D>>

The first child node of this node starting at the (n + 1)-st, if any. Note that even if this method returns Some, the contained node may not actually be the (n + 1)-st child, but the next child from there that is a node.

If you want to also consider leafs, see next_child_or_token_after.

pub fn next_child_or_token_after( &self, n: usize, offset: TextSize, ) -> Option<ResolvedElementRef<'_, S, D>>

The first child element of this node starting at the (n + 1)-st, if any. If this method returns Some, the contained node is the (n + 1)-st child of this node.

pub fn prev_child_before( &self, n: usize, offset: TextSize, ) -> Option<&ResolvedNode<S, D>>

The last child node of this node up to the nth, if any. Note that even if this method returns Some, the contained node may not actually be the (n - 1)-st child, but the previous child from there that is a node.

If you want to also consider leafs, see prev_child_or_token_before.

pub fn prev_child_or_token_before( &self, n: usize, offset: TextSize, ) -> Option<ResolvedElementRef<'_, S, D>>

The last child node of this node up to the nth, if any. If this method returns Some, the contained node is the (n - 1)-st child.

pub fn next_sibling(&self) -> Option<&ResolvedNode<S, D>>

The node to the right of this one, i.e. the next child node (!) of this node’s parent after this node.

If you want to also consider leafs, see next_sibling_or_token.

pub fn next_sibling_or_token(&self) -> Option<ResolvedElementRef<'_, S, D>>

The tree element to the right of this one, i.e. the next child of this node’s parent after this node.

pub fn prev_sibling(&self) -> Option<&ResolvedNode<S, D>>

The node to the left of this one, i.e. the previous child node (!) of this node’s parent before this node.

If you want to also consider leafs, see prev_sibling_or_token.

pub fn prev_sibling_or_token(&self) -> Option<ResolvedElementRef<'_, S, D>>

The tree element to the left of this one, i.e. the previous child of this node’s parent before this node.

pub fn first_token(&self) -> Option<&ResolvedToken<S, D>>

Return the leftmost token in the subtree of this node

pub fn last_token(&self) -> Option<&ResolvedToken<S, D>>

Return the rightmost token in the subtree of this node

pub fn siblings( &self, direction: Direction, ) -> impl Iterator<Item = &ResolvedNode<S, D>>

Returns an iterator over all sibling nodes of this node in the given direction, i.e. all of this node’s parent’s child nodes (!) from this node on to the left or the right. The first item in the iterator will always be this node.

If you want to also consider leafs, see siblings_with_tokens.

pub fn siblings_with_tokens( &self, direction: Direction, ) -> impl Iterator<Item = ResolvedElementRef<'_, S, D>>

Returns an iterator over all siblings of this node in the given direction, i.e. all of this node’s parent’s children from this node on to the left or the right. The first item in the iterator will always be this node.

pub fn descendants(&self) -> impl Iterator<Item = &ResolvedNode<S, D>>

Returns an iterator over all nodes (!) in the subtree starting at this node, including this node.

If you want to also consider leafs, see descendants_with_tokens.

pub fn descendants_with_tokens( &self, ) -> impl Iterator<Item = ResolvedElementRef<'_, S, D>>

Returns an iterator over all elements in the subtree starting at this node, including this node.

pub fn preorder(&self) -> impl Iterator<Item = WalkEvent<&ResolvedNode<S, D>>>

Traverse the subtree rooted at the current node (including the current node) in preorder, excluding tokens.

pub fn preorder_with_tokens( &self, ) -> impl Iterator<Item = WalkEvent<ResolvedElementRef<'_, S, D>>>

Traverse the subtree rooted at the current node (including the current node) in preorder, including tokens.

pub fn token_at_offset( &self, offset: TextSize, ) -> TokenAtOffset<ResolvedToken<S, D>>

Find a token in the subtree corresponding to this node, which covers the offset. Precondition: offset must be withing node’s range.

pub fn covering_element(&self, range: TextRange) -> ResolvedElementRef<'_, S, D>

Return the deepest node or token in the current subtree that fully contains the range. If the range is empty and is contained in two leaf nodes, either one can be returned. Precondition: range must be contained withing the current node

Methods from Deref<Target = SyntaxNode<S, D>>

pub fn write_debug<R>( &self, resolver: &R, target: &mut impl Write, recursive: bool, ) -> Result

where R: Resolver<TokenKey> + ?Sized,

Writes this node’s Debug representation into the given target. If recursive is true, prints the entire subtree rooted in this node. Otherwise, only this node’s kind and range are written.

pub fn debug<R>(&self, resolver: &R, recursive: bool) -> String

where R: Resolver<TokenKey> + ?Sized,

Returns this node’s Debug representation as a string. If recursive is true, prints the entire subtree rooted in this node. Otherwise, only this node’s kind and range are written.

To avoid allocating for every node, see write_debug.

pub fn write_display<R>(&self, resolver: &R, target: &mut impl Write) -> Result

where R: Resolver<TokenKey> + ?Sized,

Writes this node’s Display representation into the given target.

pub fn display<R>(&self, resolver: &R) -> String

where R: Resolver<TokenKey> + ?Sized,

Returns this node’s Display representation as a string.

To avoid allocating for every node, see write_display.

pub fn resolver(&self) -> Option<&StdArc<dyn Resolver<TokenKey>>>

If there is a resolver associated with this tree, returns it.

pub fn try_resolved(&self) -> Option<&ResolvedNode<S, D>>

Turns this node into a ResolvedNode, but only if there is a resolver associated with this tree.

pub fn resolved(&self) -> &ResolvedNode<S, D>

Turns this node into a ResolvedNode.

Panics

If there is no resolver associated with this tree.

pub fn root(&self) -> &SyntaxNode<S, D>

The root of the tree this node belongs to.

If this node is the root, returns self.

pub fn set_data(&self, data: D) -> Arc<D>

Stores custom data for this node. If there was previous data associated with this node, it will be replaced.

pub fn try_set_data(&self, data: D) -> Result<Arc<D>, D>

Stores custom data for this node, but only if no data was previously set. If it was, the given data is returned unchanged.

pub fn get_data(&self) -> Option<Arc<D>>

Returns the data associated with this node, if any.

pub fn clear_data(&self)

Removes the data associated with this node.

pub fn replace_with(&self, replacement: GreenNode) -> GreenNode

Returns a green tree, equal to the green tree this node belongs two, except with this node substitute. The complexity of operation is proportional to the depth of the tree

pub fn syntax_kind(&self) -> RawSyntaxKind

The internal representation of the kind of this node.

pub fn kind(&self) -> S

The kind of this node in terms of your language.

pub fn text_range(&self) -> TextRange

The range this node covers in the source text, in bytes.

pub fn resolve_text<'n, 'i, I>( &'n self, resolver: &'i I, ) -> SyntaxText<'n, 'i, I, S, D>

where I: Resolver<TokenKey> + ?Sized,

Uses the provided resolver to return an efficient representation of all source text covered by this node, i.e. the combined text of all token leafs of the subtree originating in this node.

pub fn green(&self) -> &GreenNode

Returns the unterlying green tree node of this node.

pub fn parent(&self) -> Option<&SyntaxNode<S, D>>

The parent node of this node, except if this node is the root.

pub fn arity(&self) -> usize

The number of child nodes (!) of this node.

If you want to also consider leafs, see arity_with_tokens.

pub fn arity_with_tokens(&self) -> usize

The number of children of this node.

pub fn ancestors(&self) -> impl Iterator<Item = &SyntaxNode<S, D>>

Returns an iterator along the chain of parents of this node.

pub fn children(&self) -> SyntaxNodeChildren<'_, S, D>

Returns an iterator over all nodes that are children of this node.

If you want to also consider leafs, see children_with_tokens.

pub fn children_with_tokens(&self) -> SyntaxElementChildren<'_, S, D>

Returns an iterator over child elements of this node, including tokens.

pub fn first_child(&self) -> Option<&SyntaxNode<S, D>>

The first child node of this node, if any.

If you want to also consider leafs, see first_child_or_token.

pub fn first_child_or_token(&self) -> Option<SyntaxElementRef<'_, S, D>>

The first child element of this node, if any, including tokens.

pub fn last_child(&self) -> Option<&SyntaxNode<S, D>>

The last child node of this node, if any.

If you want to also consider leafs, see last_child_or_token.

pub fn last_child_or_token(&self) -> Option<SyntaxElementRef<'_, S, D>>

The last child element of this node, if any, including tokens.

pub fn next_child_after( &self, n: usize, offset: TextSize, ) -> Option<&SyntaxNode<S, D>>

The first child node of this node starting at the (n + 1)-st, if any. Note that even if this method returns Some, the contained node may not actually be the (n + 1)-st child, but the next child from there that is a node.

If you want to also consider leafs, see next_child_or_token_after.

pub fn next_child_or_token_after( &self, n: usize, offset: TextSize, ) -> Option<SyntaxElementRef<'_, S, D>>

The first child element of this node starting at the (n + 1)-st, if any. If this method returns Some, the contained node is the (n + 1)-st child of this node.

pub fn prev_child_before( &self, n: usize, offset: TextSize, ) -> Option<&SyntaxNode<S, D>>

The last child node of this node up to the nth, if any. Note that even if this method returns Some, the contained node may not actually be the (n - 1)-st child, but the previous child from there that is a node.

If you want to also consider leafs, see prev_child_or_token_before.

pub fn prev_child_or_token_before( &self, n: usize, offset: TextSize, ) -> Option<SyntaxElementRef<'_, S, D>>

The last child node of this node up to the nth, if any. If this method returns Some, the contained node is the (n - 1)-st child.

pub fn next_sibling(&self) -> Option<&SyntaxNode<S, D>>

The node to the right of this one, i.e. the next child node (!) of this node’s parent after this node.

If you want to also consider leafs, see next_sibling_or_token.

pub fn next_sibling_or_token(&self) -> Option<SyntaxElementRef<'_, S, D>>

The tree element to the right of this one, i.e. the next child of this node’s parent after this node.

pub fn prev_sibling(&self) -> Option<&SyntaxNode<S, D>>

The node to the left of this one, i.e. the previous child node (!) of this node’s parent before this node.

If you want to also consider leafs, see prev_sibling_or_token.

pub fn prev_sibling_or_token(&self) -> Option<SyntaxElementRef<'_, S, D>>

The tree element to the left of this one, i.e. the previous child of this node’s parent before this node.

pub fn first_token(&self) -> Option<&SyntaxToken<S, D>>

Return the leftmost token in the subtree of this node

pub fn last_token(&self) -> Option<&SyntaxToken<S, D>>

Return the rightmost token in the subtree of this node

pub fn siblings( &self, direction: Direction, ) -> impl Iterator<Item = &SyntaxNode<S, D>>

Returns an iterator over all sibling nodes of this node in the given direction, i.e. all of this node’s parent’s child nodes (!) from this node on to the left or the right. The first item in the iterator will always be this node.

If you want to also consider leafs, see siblings_with_tokens.

pub fn siblings_with_tokens( &self, direction: Direction, ) -> impl Iterator<Item = SyntaxElementRef<'_, S, D>>

Returns an iterator over all siblings of this node in the given direction, i.e. all of this node’s parent’s children from this node on to the left or the right. The first item in the iterator will always be this node.

pub fn descendants(&self) -> impl Iterator<Item = &SyntaxNode<S, D>>

Returns an iterator over all nodes (!) in the subtree starting at this node, including this node.

If you want to also consider leafs, see descendants_with_tokens.

pub fn descendants_with_tokens( &self, ) -> impl Iterator<Item = SyntaxElementRef<'_, S, D>>

Returns an iterator over all elements in the subtree starting at this node, including this node.

pub fn preorder(&self) -> impl Iterator<Item = WalkEvent<&SyntaxNode<S, D>>>

Traverse the subtree rooted at the current node (including the current node) in preorder, excluding tokens.

pub fn preorder_with_tokens( &self, ) -> impl Iterator<Item = WalkEvent<SyntaxElementRef<'_, S, D>>>

Traverse the subtree rooted at the current node (including the current node) in preorder, including tokens.

pub fn token_at_offset( &self, offset: TextSize, ) -> TokenAtOffset<SyntaxToken<S, D>>

Find a token in the subtree corresponding to this node, which covers the offset. Precondition: offset must be withing node’s range.

pub fn covering_element(&self, range: TextRange) -> SyntaxElementRef<'_, S, D>

Return the deepest node or token in the current subtree that fully contains the range. If the range is empty and is contained in two leaf nodes, either one can be returned. Precondition: range must be contained withing the current node

pub fn as_serialize_with_data_with_resolver<'node>( &'node self, resolver: &'node impl Resolver<TokenKey>, ) -> impl Serialize + 'node

where D: Serialize,

Available on crate feature serialize only.

Return an anonymous object that can be used to serialize this node, including the data and by using an external resolver.

pub fn as_serialize_with_resolver<'node>( &'node self, resolver: &'node impl Resolver<TokenKey>, ) -> impl Serialize + 'node

Available on crate feature serialize only.

Return an anonymous object that can be used to serialize this node, which uses the given resolver instead of the resolver inside the tree.

Trait Implementations

impl<S: Syntax, D> Clone for ResolvedNode<S, D>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Syntax, D> Debug for ResolvedNode<S, D>

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

Formats the value using the given formatter.

impl<S: Syntax, D> Deref for ResolvedNode<S, D>

type Target = SyntaxNode<S, D>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: Syntax, D> DerefMut for ResolvedNode<S, D>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, S, D> Deserialize<'de> for ResolvedNode<S, D>

where S: Syntax, D: Deserialize<'de>,

Available on crate feature serialize only.

fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>

where De: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: Syntax, D> Display for ResolvedNode<S, D>

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

Formats the value using the given formatter.

impl<'a, S: Syntax, D> From<&'a ResolvedNode<S, D>> for ResolvedElementRef<'a, S, D>

fn from(node: &'a ResolvedNode<S, D>) -> Self

Converts to this type from the input type.

impl<S: Syntax, D> From<ResolvedNode<S, D>> for ResolvedElement<S, D>

fn from(node: ResolvedNode<S, D>) -> ResolvedElement<S, D>

Converts to this type from the input type.

impl<S: Syntax, D> Hash for ResolvedNode<S, D>

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<S: Syntax, D> PartialEq for ResolvedNode<S, D>

fn eq(&self, other: &Self) -> 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<S, D> Serialize for ResolvedNode<S, D>

where S: Syntax, D: Serialize,

Available on crate feature serialize only.

fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>

where Ser: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Syntax, D> Eq for ResolvedNode<S, D>