Struct cstree::syntax::SyntaxToken

pub struct SyntaxToken<L: Language, D: 'static = (), R: 'static = ()> { /* fields omitted */ }

Syntax tree token.

Implementations

impl<L: Language, D, R> SyntaxToken<L, D, R>

pub fn debug(&self, resolver: &impl Resolver) -> String

pub fn display(&self, resolver: &impl Resolver) -> String

impl<L: Language, D, R> SyntaxToken<L, D, R>

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

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

pub fn syntax_kind(&self) -> SyntaxKind

The internal representation of the kind of this token.

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

The kind of this token in terms of your language.

pub fn text_range(&self) -> TextRange

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

pub fn resolve_text<'i, I: ?Sized>(&self, resolver: &'i I) -> &'i str where
    I: Resolver, 

Uses the provided resolver to return the source text of this token.

pub fn green(&self) -> &GreenToken

Returns the unterlying green tree token of this token.

pub fn parent(&self) -> &SyntaxNode<L, D, R>

The parent node of this token.

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

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

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

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

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

The tree element to the left of this one, i.e. the previous child of this token's parent after this token.

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

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

pub fn next_token(&self) -> Option<&SyntaxToken<L, D, R>>

Returns the next token in the tree. This is not necessary a direct sibling of this token, but will always be further right in the tree.

pub fn prev_token(&self) -> Option<&SyntaxToken<L, D, R>>

Returns the previous token in the tree. This is not necessary a direct sibling of this token, but will always be further left in the tree.

impl<L: Language, D, R> SyntaxToken<L, D, R> where
    R: Resolver, 

pub fn text(&self) -> &str

Uses the resolver associated with this tree to return the source text of this token.

Trait Implementations

impl<L: Language, D, R> Clone for SyntaxToken<L, D, R>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Language, D, R> Debug for SyntaxToken<L, D, R> where
    R: Resolver, 

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

Formats the value using the given formatter.

impl<L: Language, D, R> Display for SyntaxToken<L, D, R> where
    R: Resolver, 

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

Formats the value using the given formatter.

impl<L: Language, D, R> Eq for SyntaxToken<L, D, R>

impl<'a, L: Language, D, R> From<&'a SyntaxToken<L, D, R>> for SyntaxElementRef<'a, L, D, R>

fn from(token: &'a SyntaxToken<L, D, R>) -> Self

Performs the conversion.

impl<L: Language, D, R> From<SyntaxToken<L, D, R>> for SyntaxElement<L, D, R>

fn from(token: SyntaxToken<L, D, R>) -> SyntaxElement<L, D, R>

Performs the conversion.

impl<L: Language, D, R> Hash for SyntaxToken<L, D, R>

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

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<L: Language, D, R> PartialEq<SyntaxToken<L, D, R>> for SyntaxToken<L, D, R>

fn eq(&self, other: &SyntaxToken<L, D, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.