Enum Expression 

pub enum Expression {
    Literal(Literal),
    Identifier(String),
    QualifiedPath {
        segments: Vec<String>,
    },
    FieldAccess {
        base: Box<Self>,
        field: String,
    },
    Call {
        func: Box<Self>,
        args: Vec<Self>,
    },
    MethodCall {
        receiver: Box<Self>,
        method: String,
        args: Vec<Self>,
    },
    StructLiteral {
        struct_name: Option<String>,
        fields: Vec<(String, Self)>,
    },
    BinaryOp {
        lhs: Box<Self>,
        op: Operator,
        rhs: Box<Self>,
    },
    FormatConcat {
        parts: Vec<Self>,
    },
    Array {
        elements: Vec<Self>,
    },
    Index {
        base: Box<Self>,
        key: Box<Self>,
    },
    Not(Box<Self>),
    Len(Box<Self>),
}

Variants

Literal(Literal)

Identifier(String)

QualifiedPath

Fields

segments: Vec<String>

FieldAccess

Fields

base: Box<Self>

field: String

Call

Fields

func: Box<Self>

args: Vec<Self>

MethodCall

Fields

receiver: Box<Self>

method: String

args: Vec<Self>

StructLiteral

Fields

struct_name: Option<String>

The Rust struct name that produced this literal, used by codegen to inject fixed Factorio prototype fields (e.g. type = "bool-setting").

fields: Vec<(String, Self)>

BinaryOp

An operation between a lhs and a rhs with an Operator

Fields

lhs: Box<Self>

op: Operator

rhs: Box<Self>

FormatConcat

String interpolation parts joined with .. in Lua.

Fields

parts: Vec<Self>

Array

Lua array literal { a, b, c }.

Fields

elements: Vec<Self>

Index

Lua table index expression base[key].

Fields

base: Box<Self>

key: Box<Self>

Not(Box<Self>)

Logical not EXPR in Lua.

Len(Box<Self>)

Length operator #EXPR in Lua.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate 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 PartialEq for Expression

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Expression