Enum Expression

pub enum Expression {
    ERROR,
    Nil(Token),
    Boolean(Token),
    Number(Token),
    String(Token),
    Closure(Closure),
    FunctionCall(FunctionCall),
    ExpressionWrap(ExpressionWrap),
    Var(Var),
    Table(Table),
    UnaryExpression {
        operator: Token,
        expression: Pointer<Expression>,
    },
    BinaryExpression {
        left: Pointer<Expression>,
        operator: Token,
        right: Pointer<Expression>,
    },
    TypeCast {
        expression: Pointer<Expression>,
        operator: Token,
        cast_to: Pointer<TypeValue>,
    },
    IfExpression(IfExpression),
}

An enum representing all possible values for an expression.

Variants

ERROR

This Expression had a syntax error.

Nil(Token)

The nil value.

Boolean(Token)

A true or false value.

Number(Token)

Any number, be it a float, an unsigned integer, an integer or a hex digit.

String(Token)

A string, be it double quotes, single quotes, interpolated string, or multi-line.

Closure(Closure)

An anonymous function.

local foo = function(arg1: number): boolean
end

FunctionCall(FunctionCall)

A function call.

local foo = bar()

ExpressionWrap(ExpressionWrap)

An expression wrapped in parenthesis.

local _ = (foo)

Var(Var)

A reference to another variable.

local _ = foo

Table(Table)

A Table.

local _ = { foo = "bar" }

UnaryExpression

A unary expression, these are expressions that have an operator before the actual expression:

local foo = not 1
local bar = -1
local qux = #t

Fields

operator: Token

The operator.

expression: Pointer<Expression>

The actual expression this operator is affecting.

BinaryExpression

A binary expression, this represents any 2 expressions with an operator between them.

local foo = 1 + 1
local bar = 1 == 1
local qux = bar // 2

Fields

left: Pointer<Expression>

The left expression.

operator: Token

The operator between the expressions.

right: Pointer<Expression>

The right expression.

TypeCast

A typecast.

local foo = "hi" :: string
local bar = foo :: number
local qux = {} :: { number }

Fields

expression: Pointer<Expression>

The actual expression.

operator: Token

The :: operator.

cast_to: Pointer<TypeValue>

The type that’s being casted to.

IfExpression(IfExpression)

An if expression.

Implementations

impl Expression

pub fn parse_from_literal(token: Token) -> Option<Self>

Parses an Expression from a literal TokenType::Literal

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Default for Expression

fn default() -> Expression

Returns the “default value” for a type.

impl GetRange for Expression

fn get_range(&self) -> Result<Range, GetRangeError>

Get the range of the node. This will only fail if Cst.status is AstStatus::HasErrors.

impl Hash for Expression

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 Expression

fn cmp(&self, other: &Expression) -> 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 Parse<Expression> for Var

fn parse( token: Token, lexer: &mut Lexer<'_>, errors: &mut Vec<ParseError>, ) -> Option<Expression>

Try parsing the current item, starting from the passed token.

impl Parse for Expression

fn parse( token: Token, lexer: &mut Lexer<'_>, errors: &mut Vec<ParseError>, ) -> Option<Self>

Try parsing the current item, starting from the passed token.

impl PartialEq for Expression

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

fn partial_cmp(&self, other: &Expression) -> 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 Print for Expression

fn print(&self) -> String

Prints the whole token including all surrounding spaces.

impl Eq for Expression

impl StructuralPartialEq for Expression