Enum SyntaxKind 

pub enum SyntaxKind {
    ParenOpen = 0,
    ParenClose,
    BracketOpen,
    BracketClose,
    BraceOpen,
    BraceClose,
    DoubleColon,
    Colon,
    Equals,
    Negation,
    Minus,
    Tilde,
    Underscore,
    Star,
    Plus,
    Question,
    StarQuestion,
    PlusQuestion,
    QuestionQuestion,
    Slash,
    Comma,
    Pipe,
    DoubleQuote,
    SingleQuote,
    StrVal,
    KwError,
    KwMissing,
    Id,
    Dot,
    CaptureToken,
    SuppressiveCapture,
    At,
    Whitespace,
    Newline,
    LineComment,
    BlockComment,
    OpEq,
    OpNe,
    OpStartsWith,
    OpEndsWith,
    OpContains,
    OpRegexMatch,
    OpRegexNoMatch,
    RegexPredicateMatch,
    RegexPredicateNoMatch,
    RegexLiteral,
    RegexContent,
    XMLGarbage,
    TsPredicate,
    Garbage,
    Error,
    Root,
    Tree,
    Ref,
    Str,
    Field,
    Capture,
    Type,
    Quantifier,
    Seq,
    Alt,
    Branch,
    Wildcard,
    Anchor,
    NegatedField,
    Def,
    NodePredicate,
    Regex,
    // some variants omitted
}

All token and node kinds. Tokens first, then nodes, then __LAST sentinel. #[repr(u16)] enables safe transmute in kind_from_raw.

Variants

ParenOpen = 0

ParenClose

BracketOpen

BracketClose

BraceOpen

BraceClose

DoubleColon

:: for type annotations. Defined before Colon for correct precedence.

Colon

Equals

Negation

Minus

Tilde

Underscore

Star

Plus

Question

StarQuestion

Non-greedy *? quantifier

PlusQuestion

Non-greedy +? quantifier

QuestionQuestion

Non-greedy ?? quantifier

Slash

Slash for supertype paths: (expression/binary_expression)

Comma

Comma (invalid separator, for error recovery)

Pipe

Pipe (invalid separator, for error recovery)

DoubleQuote

SingleQuote

StrVal

String content between quotes

KwError

KwMissing

Id

Identifier. Accepts dots/hyphens for tree-sitter compat; parser validates per context. Defined after keywords so they take precedence.

Dot

CaptureToken

Regular capture: @name (matches before At)

SuppressiveCapture

Suppressive capture: @_ or @_name (matches before At)

At

Bare @ (for error recovery: “capture without target”)

Whitespace

Newline

LineComment

BlockComment

OpEq

== for predicate equals

OpNe

!= for predicate not equals

OpStartsWith

^= for predicate starts-with

OpEndsWith

$= for predicate ends-with

OpContains

*= for predicate contains (defined after Star for correct precedence)

OpRegexMatch

=~ for predicate regex match (when followed by string or error)

OpRegexNoMatch

!~ for predicate regex no-match (when followed by string or error)

RegexPredicateMatch

=~ followed by regex literal: =~ /pattern/ Compound token to avoid // being lexed as line comment.

RegexPredicateNoMatch

!~ followed by regex literal: !~ /pattern/

RegexLiteral

Regex literal token (after splitting compound predicate)

RegexContent

Regex pattern content (between slashes, set by parser)

XMLGarbage

XML-like tags matched as errors (common LLM output)

TsPredicate

Tree-sitter predicates (unsupported)

Garbage

Coalesced unrecognized characters

Error

Root

Tree

Ref

Str

Field

Capture

Type

Quantifier

Seq

Alt

Branch

Wildcard

Anchor

NegatedField

Def

NodePredicate

Predicate on a node: (identifier == "foo")

Regex

Regex literal: /pattern/

Implementations

impl SyntaxKind

pub fn is_trivia(self) -> bool

pub fn is_error(self) -> bool

Trait Implementations

impl Clone for SyntaxKind

fn clone(&self) -> SyntaxKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyntaxKind

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

Formats the value using the given formatter.

impl From<SyntaxKind> for SyntaxKind

fn from(kind: SyntaxKind) -> Self

Converts to this type from the input type.

impl Hash for SyntaxKind

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> Logos<'s> for SyntaxKind

type Error = ()

Error type returned by the lexer. This can be set using #[logos(error = MyError)]. Defaults to () if not set.

type Extras = ()

Associated type Extras for the particular lexer. This can be set using #[logos(extras = MyExtras)] and accessed inside callbacks.

type Source = str

Source type this token can be lexed from. This will default to str, unless one of the defined patterns explicitly uses non-unicode byte values or byte slices, in which case that implementation will use [u8].

fn lex( lex: &mut Lexer<'s, Self>, ) -> Option<Result<Self, <Self as Logos<'s>>::Error>>

The heart of Logos. Called by the Lexer. The implementation for this function is generated by the logos-derive crate.

fn lexer(source: &'source Self::Source) -> Lexer<'source, Self>

where Self::Extras: Default,

Create a new instance of a Lexer that will produce tokens implementing this Logos.

fn lexer_with_extras( source: &'source Self::Source, extras: Self::Extras, ) -> Lexer<'source, Self>

Create a new instance of a Lexer with the provided Extras that will produce tokens implementing this Logos.

impl Ord for SyntaxKind

fn cmp(&self, other: &SyntaxKind) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SyntaxKind

fn eq(&self, other: &SyntaxKind) -> 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 PartialOrd for SyntaxKind

fn partial_cmp(&self, other: &SyntaxKind) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for SyntaxKind

impl Eq for SyntaxKind

impl StructuralPartialEq for SyntaxKind