Enum i_slint_compiler::parser::SyntaxKind

#[repr(u16)]
pub enum SyntaxKind {
    Error,
    Eof,
    Whitespace,
    Comment,
    StringLiteral,
    NumberLiteral,
    ColorLiteral,
    Identifier,
    DoubleArrow,
    PlusEqual,
    MinusEqual,
    StarEqual,
    DivEqual,
    LessEqual,
    GreaterEqual,
    EqualEqual,
    NotEqual,
    ColonEqual,
    FatArrow,
    Arrow,
    OrOr,
    AndAnd,
    LBrace,
    RBrace,
    LParent,
    RParent,
    LAngle,
    RAngle,
    LBracket,
    RBracket,
    Plus,
    Minus,
    Star,
    Div,
    Equal,
    Colon,
    Comma,
    Semicolon,
    Bang,
    Dot,
    Question,
    Dollar,
    At,
    Document,
    Component,
    SubElement,
    Element,
    RepeatedElement,
    RepeatedIndex,
    ConditionalElement,
    CallbackDeclaration,
    Function,
    ArgumentDeclaration,
    ReturnType,
    CallbackConnection,
    PropertyDeclaration,
    PropertyAnimation,
    QualifiedName,
    DeclaredIdentifier,
    ChildrenPlaceholder,
    Binding,
    TwoWayBinding,
    BindingExpression,
    CodeBlock,
    ReturnStatement,
    Expression,
    StringTemplate,
    AtImageUrl,
    AtGradient,
    FunctionCallExpression,
    IndexExpression,
    SelfAssignment,
    ConditionalExpression,
    BinaryExpression,
    UnaryOpExpression,
    MemberAccess,
    Array,
    ObjectLiteral,
    ObjectMember,
    States,
    State,
    StatePropertyChange,
    Transitions,
    Transition,
    ExportsList,
    ExportSpecifier,
    ExportIdentifier,
    ExportName,
    ExportModule,
    ImportSpecifier,
    ImportIdentifierList,
    ImportIdentifier,
    ExternalName,
    InternalName,
    Type,
    ObjectType,
    ObjectTypeMember,
    ArrayType,
    StructDeclaration,
}

Variants

Error

Eof

Whitespace

Token

Comment

Token

StringLiteral

Token

NumberLiteral

Token

ColorLiteral

Token

Identifier

Token

DoubleArrow

Token

PlusEqual

Token

MinusEqual

Token

StarEqual

Token

DivEqual

Token

LessEqual

Token

GreaterEqual

Token

EqualEqual

Token

NotEqual

Token

ColonEqual

Token

FatArrow

Token

Arrow

Token

OrOr

Token

AndAnd

Token

LBrace

Token

RBrace

Token

LParent

Token

RParent

Token

LAngle

Token

RAngle

Token

LBracket

Token

RBracket

Token

Plus

Token

Minus

Token

Star

Token

Div

Token

Equal

Token

Colon

Token

Comma

Token

Semicolon

Token

Bang

Token

Dot

Token

Question

Token

Dollar

Token

At

Token

Document

Component

DeclaredIdentifier := Element { ... }

SubElement

id := Element { ... }

Element

RepeatedElement

RepeatedIndex

ConditionalElement

CallbackDeclaration

Function

ArgumentDeclaration

ReturnType

-> type (but without the ->)

CallbackConnection

PropertyDeclaration

Declaration of a property.

PropertyAnimation

QualifiedName are the properties name

QualifiedName

wraps Identifiers, like Rectangle or SomeModule.SomeType

DeclaredIdentifier

Wraps single identifier (to disambiguate when there are other identifier in the production)

ChildrenPlaceholder

Binding

TwoWayBinding

xxx <=> something

BindingExpression

the right-hand-side of a binding

CodeBlock

ReturnStatement

Expression

StringTemplate

Concatenate the Expressions to make a string (usually expended from a template string)

AtImageUrl

@image-url("foo.png")

AtGradient

@linear-gradient(...) or @radial-gradient(...)

FunctionCallExpression

expression()

IndexExpression

expression[index]

SelfAssignment

expression += expression

ConditionalExpression

condition ? first : second

BinaryExpression

expr + expr

UnaryOpExpression

- expr

MemberAccess

(foo).bar, where foo is the base expression, and bar is a Identifier.

Array

[ ... ]

ObjectLiteral

{ foo: bar }

ObjectMember

foo: bar inside an ObjectLiteral

States

states: [...]

State

The DeclaredIdentifier is the state name. The Expression, if any, is the condition.

StatePropertyChange

binding within a state

Transitions

transitions: [...]

Transition

There is an identifier “in” or “out”, the DeclaredIdentifier is the state name

ExportsList

Export a set of declared components by name

ExportSpecifier

Declare the first identifier to be exported, either under its name or instead under the name of the second identifier.

ExportIdentifier

ExportName

ExportModule

export * from "foo". The import uri is stored as string literal.

ImportSpecifier

import { foo, bar, baz } from “blah”; The import uri is stored as string literal.

ImportIdentifierList

ImportIdentifier

{ foo as bar } or just { foo }

ExternalName

InternalName

Type

The representation of a type

ObjectType

{foo: string, bar: string}

ObjectTypeMember

foo: type inside an ObjectType

ArrayType

[ type ]

StructDeclaration

`struct Foo := { … }

Trait Implementations

impl Clone for SyntaxKind

fn clone(&self) -> SyntaxKind

Returns a copy 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 Display for SyntaxKind

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

Formats the value using the given formatter.

impl From<SyntaxKind> for SyntaxKind

fn from(v: SyntaxKind) -> Self

Converts to this type from the input type.

impl From<SyntaxKind> for u16

fn from(enum_value: 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 Ord for SyntaxKind

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<SyntaxKind> for SyntaxKind

fn eq(&self, other: &SyntaxKind) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<SyntaxKind> 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl TryFrom<u16> for SyntaxKind

type Error = TryFromPrimitiveError<SyntaxKind>

The type returned in the event of a conversion error.

fn try_from(number: u16) -> Result<Self, TryFromPrimitiveError<Self>>

Performs the conversion.

impl TryFromPrimitive for SyntaxKind

type Primitive = u16

const NAME: &'static str = _

fn try_from_primitive(
    number: Self::Primitive
) -> Result<Self, TryFromPrimitiveError<Self>>

impl Copy for SyntaxKind

impl Eq for SyntaxKind

impl StructuralEq for SyntaxKind

impl StructuralPartialEq for SyntaxKind