Enum MetalStmt 

pub enum MetalStmt {
    VarDecl {
        ty: MetalType,
        name: String,
        init: Option<MetalExpr>,
        is_const: bool,
    },
    Assign {
        lhs: MetalExpr,
        rhs: MetalExpr,
    },
    CompoundAssign {
        lhs: MetalExpr,
        op: MetalBinOp,
        rhs: MetalExpr,
    },
    IfElse {
        cond: MetalExpr,
        then_body: Vec<MetalStmt>,
        else_body: Option<Vec<MetalStmt>>,
    },
    ForLoop {
        init: Box<MetalStmt>,
        cond: MetalExpr,
        step: MetalExpr,
        body: Vec<MetalStmt>,
    },
    WhileLoop {
        cond: MetalExpr,
        body: Vec<MetalStmt>,
    },
    Return(Option<MetalExpr>),
    Expr(MetalExpr),
    Barrier(MemFlags),
    Block(Vec<MetalStmt>),
    Break,
    Continue,
}

Metal Shading Language statement AST node.

Variants

VarDecl

Variable declaration with optional initializer: T name [ = init ];

Fields

ty: MetalType

name: String

init: Option<MetalExpr>

is_const: bool

If true, emit const T name = ...

Assign

Simple assignment: lhs = rhs;

Fields

lhs: MetalExpr

rhs: MetalExpr

CompoundAssign

Compound assignment: lhs += rhs; etc.

Fields

lhs: MetalExpr

op: MetalBinOp

rhs: MetalExpr

IfElse

If / optional else

Fields

cond: MetalExpr

then_body: Vec<MetalStmt>

else_body: Option<Vec<MetalStmt>>

ForLoop

C-style for loop

Fields

init: Box<MetalStmt>

cond: MetalExpr

step: MetalExpr

body: Vec<MetalStmt>

WhileLoop

While loop

Fields

cond: MetalExpr

body: Vec<MetalStmt>

Return(Option<MetalExpr>)

return [expr];

Expr(MetalExpr)

Raw expression statement: expr;

Barrier(MemFlags)

threadgroup_barrier(flags);

Block(Vec<MetalStmt>)

Block of statements: { ... }

Break

break;

Continue

continue;

Trait Implementations

impl Clone for MetalStmt

fn clone(&self) -> MetalStmt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetalStmt

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

Formats the value using the given formatter.

impl PartialEq for MetalStmt

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