Enum MojoElementType 

pub enum MojoElementType {
    Fn,
    Struct,
    Var,
    Let,
    If,
    Else,
    While,
    For,
    In,
    Return,
    Break,
    Continue,
    Import,
    From,
    True,
    False,
    None,
    Identifier,
    Integer,
    Float,
    String,
    Plus,
    Minus,
    Star,
    Slash,
    Percent,
    Equal,
    EqualEqual,
    NotEqual,
    Less,
    LessEqual,
    Greater,
    GreaterEqual,
    And,
    Or,
    Not,
    LeftParen,
    RightParen,
    LeftBracket,
    RightBracket,
    LeftBrace,
    RightBrace,
    Comma,
    Dot,
    Colon,
    Semicolon,
    Arrow,
    Whitespace,
    Newline,
    Comment,
    Indent,
    Dedent,
    EndOfStream,
    FunctionDef,
    StructDef,
    VariableDecl,
    Assignment,
    IfStatement,
    WhileStatement,
    ForStatement,
    ReturnStatement,
    ExpressionStatement,
    BinaryExpr,
    UnaryExpr,
    CallExpr,
    LiteralExpr,
    IdentifierExpr,
    MemberExpr,
    ListExpr,
    ParamList,
    ArgList,
    Block,
    Root,
    Grouping,
    Error,
}

Element types for the Mojo language parser.

This enum represents all possible element types in the Mojo language, including tokens mapped from MojoTokenType, statement types, expression types, and special node types.

Variants

Fn

Function keyword fn.

Struct

Struct keyword struct.

Var

Variable keyword var.

Let

Let keyword let.

If

If keyword if.

Else

Else keyword else.

While

While keyword while.

For

For keyword for.

In

In keyword in.

Return

Return keyword return.

Break

Break keyword break.

Continue

Continue keyword continue.

Import

Import keyword import.

From

From keyword from.

True

Boolean literal True.

False

Boolean literal False.

None

None literal.

Identifier

Identifier token.

Integer

Integer literal token.

Float

Float literal token.

String

String literal token.

Plus

Plus operator +.

Minus

Minus operator -.

Star

Star operator *.

Slash

Slash operator /.

Percent

Percent operator %.

Equal

Assignment operator =.

EqualEqual

Equality operator ==.

NotEqual

Inequality operator !=.

Less

Less than operator <.

LessEqual

Less than or equal operator <=.

Greater

Greater than operator >.

GreaterEqual

Greater than or equal operator >=.

And

Logical and operator and.

Or

Logical or operator or.

Not

Logical not operator not.

LeftParen

Left parenthesis (.

RightParen

Right parenthesis ).

LeftBracket

Left bracket [.

RightBracket

Right bracket ].

LeftBrace

Left brace {.

RightBrace

Right brace }.

Comma

Comma ,.

Dot

Dot ..

Colon

Colon :.

Semicolon

Semicolon ;.

Arrow

Arrow operator ->.

Whitespace

Whitespace token.

Newline

Newline token.

Comment

Comment token.

Indent

Indent token for significant whitespace.

Dedent

Dedent token for significant whitespace.

EndOfStream

End of stream marker.

FunctionDef

Function definition statement.

StructDef

Struct definition statement.

VariableDecl

Variable declaration statement.

Assignment

Assignment statement.

IfStatement

If statement.

WhileStatement

While statement.

ForStatement

For statement.

ReturnStatement

Return statement.

ExpressionStatement

Expression statement.

BinaryExpr

Binary expression.

UnaryExpr

Unary expression.

CallExpr

Function call expression.

LiteralExpr

Literal expression.

IdentifierExpr

Identifier expression.

MemberExpr

Member access expression.

ListExpr

List expression.

ParamList

Parameter list.

ArgList

Argument list.

Block

Code block.

Root

Root node of the AST.

Grouping

Grouping expression.

Error

Error node.

Implementations

impl MojoElementType

pub fn is_trivia(&self) -> bool

Checks if the node is trivia (whitespace, comments, etc.).

Trait Implementations

impl Clone for MojoElementType

fn clone(&self) -> MojoElementType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MojoElementType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MojoElementType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ElementType for MojoElementType

type Role = UniversalElementRole

The associated role type for this element kind.

fn role(&self) -> Self::Role

Returns the general syntactic role of this element.

fn is_role(&self, role: Self::Role) -> bool

Returns true if this element matches the specified language-specific role.

fn is_universal(&self, role: UniversalElementRole) -> bool

Returns true if this element matches the specified universal role.

fn is_root(&self) -> bool

Returns true if this element represents the root of the parsed tree.

fn is_error(&self) -> bool

Returns true if this element represents an error condition.

impl From<MojoTokenType> for MojoElementType

fn from(token: MojoTokenType) -> Self

Converts to this type from the input type.

impl Hash for MojoElementType

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 PartialEq for MojoElementType

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for MojoElementType

impl Eq for MojoElementType

impl StructuralPartialEq for MojoElementType