Enum Rvalue 

pub enum Rvalue {
    Use(Operand),
    BinaryOp {
        op: BinOp,
        left: Operand,
        right: Operand,
    },
    UnaryOp {
        op: UnOp,
        operand: Operand,
    },
    SimdBinaryOp {
        op: SimdOp,
        element_ty: Ty,
        width: SimdWidth,
        left: Operand,
        right: Operand,
    },
    SimdLoad {
        element_ty: Ty,
        width: SimdWidth,
        source: Place,
    },
    SimdStore {
        element_ty: Ty,
        width: SimdWidth,
        value: Operand,
        dest: Place,
    },
    SimdSplat {
        element_ty: Ty,
        width: SimdWidth,
        value: Operand,
    },
    Ref {
        mutable: bool,
        place: Place,
    },
    Aggregate {
        kind: AggregateKind,
        operands: Vec<Operand>,
    },
    Cast {
        operand: Operand,
        target_ty: Ty,
        kind: CastKind,
    },
    Discriminant {
        place: Place,
    },
    Len {
        place: Place,
    },
    ChannelCreate {
        element_ty: Ty,
        capacity: u64,
    },
    ChannelTryRecv {
        channel: Operand,
    },
    ChannelTrySend {
        channel: Operand,
        value: Operand,
    },
    ChannelSender {
        channel: Operand,
    },
    ChannelReceiver {
        channel: Operand,
    },
    ChannelClose {
        channel: Operand,
    },
    IsCancelled,
    CurrentTask,
    Try(Operand),
    EnumVariant {
        variant: Symbol,
        fields: Vec<Operand>,
    },
}

Rvalue - an expression that produces a value

Variants

Use(Operand)

Use an operand (copy or move)

BinaryOp

Binary operation

Fields

op: BinOp

left: Operand

right: Operand

UnaryOp

Unary operation

Fields

op: UnOp

operand: Operand

SimdBinaryOp

SIMD binary operation on vectors

This represents a vectorized operation that processes multiple elements in parallel. The operands are arrays/slices containing width elements.

Fields

op: SimdOp

The SIMD operation to perform

element_ty: Ty

Element type (e.g., f32, i32)

width: SimdWidth

Vector width (number of elements processed in parallel)

left: Operand

Left operand vector (array or pointer to contiguous elements)

right: Operand

Right operand vector (array or pointer to contiguous elements)

SimdLoad

SIMD load - gather elements from memory into a vector register

Fields

element_ty: Ty

Element type

width: SimdWidth

Vector width

source: Place

Source place to load from (must be an array or contiguous memory)

SimdStore

SIMD store - scatter elements from a vector register to memory

Fields

element_ty: Ty

Element type

width: SimdWidth

Vector width

value: Operand

Value to store (SIMD vector operand)

dest: Place

Destination place (must be an array or contiguous memory)

SimdSplat

SIMD splat - broadcast a scalar value to all lanes

Fields

element_ty: Ty

Element type

width: SimdWidth

Vector width

value: Operand

Scalar value to broadcast

Ref

Create a reference (&place or &mut place)

Fields

mutable: bool

place: Place

Aggregate

Aggregate construction (struct, tuple, array)

Fields

kind: AggregateKind

operands: Vec<Operand>

Cast

Type cast

Fields

operand: Operand

target_ty: Ty

kind: CastKind

Discriminant

Discriminant (get enum variant)

Fields

place: Place

Len

Length of array/slice

Fields

place: Place

ChannelCreate

Create a bounded channel

Fields

element_ty: Ty

Element type for the channel

capacity: u64

Channel capacity (number of elements)

ChannelTryRecv

Receive from a channel (non-blocking check) Returns Option - Some(value) if value available, None otherwise

Fields

channel: Operand

Channel to receive from

ChannelTrySend

Send to a channel (non-blocking check) Returns bool - true if sent successfully, false if channel full

Fields

channel: Operand

Channel to send to

value: Operand

Value to send

ChannelSender

Get the sender handle from a channel

Fields

channel: Operand

Channel to get sender from

ChannelReceiver

Get the receiver handle from a channel

Fields

channel: Operand

Channel to get receiver from

ChannelClose

Close a channel

Fields

channel: Operand

Channel to close

IsCancelled

Check if cancelled

CurrentTask

Get the current task handle

Try(Operand)

Try operator: unwrap Result/Option, panicking on error

EnumVariant

Enum unit variant construction (like TokenKind::Arrow)

Fields

variant: Symbol

Name of the variant

fields: Vec<Operand>

Field operands (empty for unit variants)

Trait Implementations

impl Clone for Rvalue

fn clone(&self) -> Rvalue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rvalue

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

Formats the value using the given formatter.