Enum Expr 

pub enum Expr {
    Lit(Lit),
    Ident(String, Span),
    Binary(BinaryExpr),
    Unary(UnaryExpr),
    Ternary(TernaryExpr),
    Call(CallExpr),
    Member(MemberExpr),
    Swizzle(SwizzleExpr),
    Index(IndexExpr),
    InitList(InitListExpr),
    Assign(AssignExpr),
}

HLSL expression node. Members and swizzles are split because WGSL treats them slightly differently — keeping them separate at the AST level lets the emitter choose the right WGSL form.

Variants

Lit(Lit)

42, 1.5, true

Ident(String, Span)

foo, aspect, texsize

Binary(BinaryExpr)

lhs + rhs, lhs * rhs, lhs && rhs, …

Unary(UnaryExpr)

-x, !x, +x, ~x

Ternary(TernaryExpr)

cond ? then : else_

Call(CallExpr)

f(arg, arg, …) — also covers vector/matrix constructors like float2(x, y), since they share syntax.

Member(MemberExpr)

obj.member — struct field access. Swizzles use Expr::Swizzle.

Swizzle(SwizzleExpr)

vec.xy, color.rgba, m.r — sub-vector / component access. HLSL spells RGBA swizzles equivalently to XYZW.

Index(IndexExpr)

arr[i]

InitList(InitListExpr)

{ 1, 2, 3 } — array initialiser used in float arr[3] = {…}; and matrix initialisers. Kept distinct from Call so the emitter can target WGSL’s array<f32, 3>(…) form.

Assign(AssignExpr)

Assignment as an expression — i = i + 1, x += 2. HLSL allows these inside for headers and other expression contexts. Statement form (<stmt>;) is modelled separately as AssignStmt to keep the common case (top-level statement) cheap to walk.

Implementations

impl Expr

pub fn span(&self) -> Span

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

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