Enum SyntaxKind 

pub enum SyntaxKind {
    L_BRACE = 0,
    R_BRACE,
    L_PAREN,
    R_PAREN,
    COMMA,
    GT,
    AT,
    BARE_SCALAR,
    QUOTED_SCALAR,
    RAW_SCALAR,
    HEREDOC_START,
    HEREDOC_CONTENT,
    HEREDOC_END,
    LINE_COMMENT,
    DOC_COMMENT,
    WHITESPACE,
    NEWLINE,
    EOF,
    ERROR,
    DOCUMENT,
    ENTRY,
    OBJECT,
    SEQUENCE,
    SCALAR,
    UNIT,
    TAG,
    TAG_NAME,
    TAG_PAYLOAD,
    KEY,
    VALUE,
    HEREDOC,
    ATTRIBUTES,
    ATTRIBUTE,
    // some variants omitted
}

The kind of a syntax element (node or token).

Tokens are terminal elements (leaves), while nodes are non-terminal (contain children). The distinction is made by value: tokens have lower values than __LAST_TOKEN.

The SCREAMING_CASE naming convention is used to match rowan/rust-analyzer conventions for syntax kinds.

Variants

L_BRACE = 0

{

R_BRACE

}

L_PAREN

(

R_PAREN

)

COMMA

,

GT

=

AT

@

BARE_SCALAR

Bare (unquoted) scalar: hello, 42, true

QUOTED_SCALAR

Quoted scalar: "hello world"

RAW_SCALAR

Raw scalar: r#"..."#

HEREDOC_START

Heredoc start marker: <<DELIM\n

HEREDOC_CONTENT

Heredoc content

HEREDOC_END

Heredoc end marker

LINE_COMMENT

Line comment: // ...

DOC_COMMENT

Doc comment: /// ...

WHITESPACE

Horizontal whitespace (spaces, tabs)

NEWLINE

Newline (\n or \r\n)

EOF

End of file

ERROR

Lexer/parser error

DOCUMENT

Root document node

ENTRY

An entry (key-value pair or sequence element)

OBJECT

An explicit object { ... }

SEQUENCE

A sequence ( ... )

SCALAR

A scalar value wrapper

UNIT

Unit value @

TAG

A tag @name with optional payload

TAG_NAME

Tag name (without @)

TAG_PAYLOAD

Tag payload (the value after the tag name)

KEY

Key in an entry

VALUE

Value in an entry

HEREDOC

A heredoc (groups start, content, end)

ATTRIBUTES

A group of attributes (key=value pairs)

ATTRIBUTE

A single attribute (key=value)

Implementations

impl SyntaxKind

pub fn is_token(self) -> bool

Whether this is a token (terminal) kind.

pub fn is_node(self) -> bool

Whether this is a node (non-terminal) kind.

pub fn is_trivia(self) -> bool

Whether this is trivia (whitespace or comments).

impl SyntaxKind

pub const fn from_raw(raw: u16) -> Option<Self>

Convert from a raw u16 value to SyntaxKind. Returns None if the value is out of range or corresponds to __LAST_TOKEN.

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 From<TokenKind> for SyntaxKind

fn from(kind: TokenKind) -> 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 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