Enum SwiftExpr 

pub enum SwiftExpr {
    SwiftLitExpr(SwiftLit),
    SwiftVar(String),
    SwiftCall {
        callee: Box<SwiftExpr>,
        args: Vec<(String, SwiftExpr)>,
    },
    SwiftBinOp {
        op: String,
        lhs: Box<SwiftExpr>,
        rhs: Box<SwiftExpr>,
    },
    SwiftMember(Box<SwiftExpr>, String),
    SwiftSubscript(Box<SwiftExpr>, Box<SwiftExpr>),
    SwiftUnary(String, Box<SwiftExpr>),
    SwiftTernary(Box<SwiftExpr>, Box<SwiftExpr>, Box<SwiftExpr>),
    SwiftClosure {
        params: Vec<(String, Option<SwiftType>)>,
        return_type: Option<SwiftType>,
        body: Vec<SwiftStmt>,
    },
    SwiftSwitchExpr {
        subject: Box<SwiftExpr>,
        arms: Vec<(String, SwiftExpr)>,
    },
    SwiftOptionalChain(Box<SwiftExpr>, String),
    SwiftForceUnwrap(Box<SwiftExpr>),
    SwiftArrayLit(Vec<SwiftExpr>),
    SwiftDictLit(Vec<(SwiftExpr, SwiftExpr)>),
    SwiftTupleLit(Vec<SwiftExpr>),
    SwiftAs(Box<SwiftExpr>, SwiftType),
    SwiftTry(Box<SwiftExpr>),
    SwiftAwait(Box<SwiftExpr>),
    SwiftSelf,
    SwiftSuper,
}

Swift expression for code generation.

Variants

SwiftLitExpr(SwiftLit)

A literal value: 42, "hello", true, nil

SwiftVar(String)

A variable or identifier: x, myVar, MyType

SwiftCall

A function/method call: f(a, b)

Fields

callee: Box<SwiftExpr>

The function or method being called

args: Vec<(String, SwiftExpr)>

Labeled arguments: (label, expr) — label is empty for unlabeled

SwiftBinOp

Binary operator: lhs + rhs, a == b

Fields

op: String

lhs: Box<SwiftExpr>

rhs: Box<SwiftExpr>

SwiftMember(Box<SwiftExpr>, String)

Member access: obj.field

SwiftSubscript(Box<SwiftExpr>, Box<SwiftExpr>)

Subscript: arr[idx]

SwiftUnary(String, Box<SwiftExpr>)

Unary prefix operator: !x, -n

SwiftTernary(Box<SwiftExpr>, Box<SwiftExpr>, Box<SwiftExpr>)

Ternary conditional: cond ? then : else

SwiftClosure

Closure expression: { params in body }

Fields

params: Vec<(String, Option<SwiftType>)>

Parameter names with optional types

return_type: Option<SwiftType>

Return type annotation

body: Vec<SwiftStmt>

Body statements

SwiftSwitchExpr

Switch expression (Swift 5.9+): switch x { case .a: expr }

Fields

subject: Box<SwiftExpr>

The scrutinee

arms: Vec<(String, SwiftExpr)>

Arms: (pattern_str, result_expr)

SwiftOptionalChain(Box<SwiftExpr>, String)

Optional chaining: obj?.field

SwiftForceUnwrap(Box<SwiftExpr>)

Force unwrap: expr!

SwiftArrayLit(Vec<SwiftExpr>)

Array literal: [a, b, c]

SwiftDictLit(Vec<(SwiftExpr, SwiftExpr)>)

Dictionary literal: [k1: v1, k2: v2]

SwiftTupleLit(Vec<SwiftExpr>)

Tuple literal: (a, b)

SwiftAs(Box<SwiftExpr>, SwiftType)

Type cast: expr as Type

SwiftTry(Box<SwiftExpr>)

Try expression: try expr

SwiftAwait(Box<SwiftExpr>)

Await expression: await expr

SwiftSelf

Self reference

SwiftSuper

Super reference

Trait Implementations

impl Clone for SwiftExpr

fn clone(&self) -> SwiftExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SwiftExpr

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

Formats the value using the given formatter.

impl Display for SwiftExpr

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

Formats the value using the given formatter.

impl PartialEq for SwiftExpr

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