Type Alias glsl_lang_pp::parser::SyntaxNode

pub(crate) type SyntaxNode = SyntaxNode<PreprocessorLang>;

Aliased Type

struct SyntaxNode { /* private fields */ }

Implementations

impl<L> SyntaxNode<L>

where L: Language,

pub fn new_root(green: GreenNode) -> SyntaxNode<L>

pub fn new_root_mut(green: GreenNode) -> SyntaxNode<L>

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

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

pub fn kind(&self) -> <L as Language>::Kind

pub fn text_range(&self) -> TextRange

pub fn index(&self) -> usize

pub fn text(&self) -> SyntaxText

pub fn green(&self) -> Cow<'_, GreenNodeData>

pub fn parent(&self) -> Option<SyntaxNode<L>>

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

pub fn children(&self) -> SyntaxNodeChildren<L>

pub fn children_with_tokens(&self) -> SyntaxElementChildren<L>

pub fn first_child(&self) -> Option<SyntaxNode<L>>

pub fn last_child(&self) -> Option<SyntaxNode<L>>

pub fn first_child_or_token( &self, ) -> Option<NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>

pub fn last_child_or_token( &self, ) -> Option<NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>

pub fn next_sibling(&self) -> Option<SyntaxNode<L>>

pub fn prev_sibling(&self) -> Option<SyntaxNode<L>>

pub fn next_sibling_or_token( &self, ) -> Option<NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>

pub fn prev_sibling_or_token( &self, ) -> Option<NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>

pub fn first_token(&self) -> Option<SyntaxToken<L>>

Return the leftmost token in the subtree of this node.

pub fn last_token(&self) -> Option<SyntaxToken<L>>

Return the rightmost token in the subtree of this node.

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

pub fn siblings_with_tokens( &self, direction: Direction, ) -> impl Iterator<Item = NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>

pub fn descendants(&self) -> impl Iterator<Item = SyntaxNode<L>>

pub fn descendants_with_tokens( &self, ) -> impl Iterator<Item = NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>

pub fn preorder(&self) -> Preorder<L>

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

pub fn preorder_with_tokens(&self) -> PreorderWithTokens<L>

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

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, ) -> NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>

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 child_or_token_at_range( &self, range: TextRange, ) -> Option<NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>

Finds a [SyntaxElement] which intersects with a given range. If there are several intersecting elements, any one can be returned.

The method uses binary search internally, so it’s complexity is O(log(N)) where N = self.children_with_tokens().count().

pub fn clone_subtree(&self) -> SyntaxNode<L>

Returns an independent copy of the subtree rooted at this node.

The parent of the returned node will be None, the start offset will be zero, but, otherwise, it’ll be equivalent to the source node.

pub fn clone_for_update(&self) -> SyntaxNode<L>

pub fn is_mutable(&self) -> bool

pub fn detach(&self)

pub fn splice_children( &self, to_delete: Range<usize>, to_insert: Vec<NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>>, )

Trait Implementations

impl<L> Clone for SyntaxNode<L>

where L: Clone + Language,

fn clone(&self) -> SyntaxNode<L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L> Debug for SyntaxNode<L>

where L: Language,

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

Formats the value using the given formatter.

impl<L> Display for SyntaxNode<L>

where L: Language,

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

Formats the value using the given formatter.

impl From<SendNode> for SyntaxNode<PreprocessorLang>

fn from(node: SendNode) -> Self

Converts to this type from the input type.

impl<L> From<SyntaxNode> for SyntaxNode<L>

where L: Language,

fn from(raw: SyntaxNode) -> SyntaxNode<L>

Converts to this type from the input type.

impl<L> Hash for SyntaxNode<L>

where L: Hash + Language,

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 SyntaxNode<L>

where L: PartialEq + Language,

fn eq(&self, other: &SyntaxNode<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> Eq for SyntaxNode<L>

where L: Eq + Language,

impl<L> StructuralPartialEq for SyntaxNode<L>

where L: Language,