Enum Expression 

pub enum Expression {
    Literal(Literal),
    Compose {
        ty: Handle<Type>,
        components: Vec<Handle<Expression>>,
    },
    FunctionArgument(u32),
    GlobalVariable(Handle<GlobalVariable>),
    LocalVariable(Handle<LocalVariable>),
    Load {
        pointer: Handle<Expression>,
    },
    Access {
        base: Handle<Expression>,
        index: Handle<Expression>,
    },
    AccessIndex {
        base: Handle<Expression>,
        index: u32,
    },
    Swizzle {
        size: VectorSize,
        vector: Handle<Expression>,
        pattern: [SwizzleComponent; 4],
    },
    Splat {
        size: VectorSize,
        value: Handle<Expression>,
    },
    Unary {
        op: UnaryOp,
        expr: Handle<Expression>,
    },
    Binary {
        op: BinaryOp,
        left: Handle<Expression>,
        right: Handle<Expression>,
    },
    Select {
        condition: Handle<Expression>,
        accept: Handle<Expression>,
        reject: Handle<Expression>,
    },
    Math {
        fun: MathFunction,
        arg: Handle<Expression>,
        arg1: Option<Handle<Expression>>,
        arg2: Option<Handle<Expression>>,
        arg3: Option<Handle<Expression>>,
    },
    As {
        expr: Handle<Expression>,
        kind: ScalarKind,
        convert: Option<Bytes>,
    },
    ArrayLength(Handle<Expression>),
    CallResult(Handle<Function>),
    AtomicResult {
        ty: Handle<Type>,
        comparison: bool,
    },
    ZeroValue(Handle<Type>),
}

An expression in the IR — a pure SSA value with no side effects.

Expressions are stored in per-function or module-level arenas. They are referenced by Handle<Expression>.

Variants

Literal(Literal)

A literal constant.

Compose

Construct a composite type from components.

Fields

ty: Handle<Type>

components: Vec<Handle<Expression>>

FunctionArgument(u32)

Reference to a function argument by index.

GlobalVariable(Handle<GlobalVariable>)

Reference to a global variable (produces a pointer).

LocalVariable(Handle<LocalVariable>)

Reference to a local variable (produces a pointer).

Load

Load a value through a pointer.

Fields

pointer: Handle<Expression>

Access

Dynamic index into a composite (array, vector, matrix).

Fields

base: Handle<Expression>

index: Handle<Expression>

AccessIndex

Static index into a composite.

Fields

base: Handle<Expression>

index: u32

Swizzle

Swizzle vector components.

Fields

size: VectorSize

vector: Handle<Expression>

pattern: [SwizzleComponent; 4]

Splat

Broadcast a scalar to a vector.

Fields

size: VectorSize

value: Handle<Expression>

Unary

Apply a unary operator.

Fields

op: UnaryOp

expr: Handle<Expression>

Binary

Apply a binary operator.

Fields

op: BinaryOp

left: Handle<Expression>

right: Handle<Expression>

Select

Select between two values based on a condition.

Fields

condition: Handle<Expression>

accept: Handle<Expression>

reject: Handle<Expression>

Math

Call a built-in math function.

Fields

fun: MathFunction

arg: Handle<Expression>

arg1: Option<Handle<Expression>>

arg2: Option<Handle<Expression>>

arg3: Option<Handle<Expression>>

As

Type cast / bitcast.

Fields

expr: Handle<Expression>

kind: ScalarKind

convert: Option<Bytes>

ArrayLength(Handle<Expression>)

Get the length of a runtime-sized array.

CallResult(Handle<Function>)

The result of a function call (paired with a Call statement).

AtomicResult

The result of an atomic operation (paired with an Atomic statement).

Fields

ty: Handle<Type>

comparison: bool

ZeroValue(Handle<Type>)

A zero-initialized value of the given type.

Used for vector, matrix, struct, and array zero-initialization where a simple scalar literal would be type-incorrect.

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.