Enum sixtyfps_compilerlib::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,
    Document,
    Component,
    SubElement,
    Element,
    RepeatedElement,
    RepeatedIndex,
    ConditionalElement,
    SignalDeclaration,
    ReturnType,
    SignalConnection,
    PropertyDeclaration,
    PropertyAnimation,
    QualifiedName,
    DeclaredIdentifier,
    ChildrenPlaceholder,
    Binding,
    TwoWayBinding,
    BindingExpression,
    CodeBlock,
    Expression,
    BangExpression,
    FunctionCallExpression,
    SelfAssignment,
    ConditionalExpression,
    BinaryExpression,
    UnaryOpExpression,
    Array,
    ObjectLiteral,
    ObjectMember,
    States,
    State,
    StatePropertyChange,
    Transitions,
    Transition,
    ExportsList,
    ExportSpecifier,
    ExportIdentifier,
    ExportName,
    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

Document

Component

SubElement

Note: This is in fact the same as Component as far as the parser is concerned

Element

RepeatedElement

RepeatedIndex

ConditionalElement

SignalDeclaration

ReturnType

-> type (but without the ->)

SignalConnection

PropertyDeclaration

Declaration of a propery.

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

Expression

BangExpression

foo!bar

FunctionCallExpression

expression()

SelfAssignment

expression += expression

ConditionalExpression

condition ? first : second

BinaryExpression

expr + expr

UnaryOpExpression

- expr

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 idientfier "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

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

pub fn clone(&self) -> SyntaxKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for SyntaxKind

impl Debug for SyntaxKind

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

Formats the value using the given formatter.

impl Eq for SyntaxKind

impl From<SyntaxKind> for u16

pub fn from(enum_value: SyntaxKind) -> Self

Performs the conversion.

impl From<SyntaxKind> for SyntaxKind

pub fn from(v: SyntaxKind) -> Self

Performs the conversion.

impl PartialEq<SyntaxKind> for SyntaxKind

pub fn eq(&self, other: &SyntaxKind) -> 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 !=.

impl StructuralEq for SyntaxKind

impl StructuralPartialEq for SyntaxKind

impl TryFrom<u16> for SyntaxKind

type Error = TryFromPrimitiveError<Self>

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFromPrimitive for SyntaxKind

type Primitive = u16

pub const NAME: &'static str

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