Enum ExpressionKind

pub enum ExpressionKind {
    IntLiteral(i64),
    Identifier(String),
    BinaryOp {
        left: Box<ExpressionAst>,
        op: BinaryOperator,
        right: Box<ExpressionAst>,
    },
    UnaryOp {
        op: UnaryOperator,
        operand: Box<ExpressionAst>,
    },
    Call {
        function: String,
        args: Vec<ExpressionAst>,
    },
    ArrayAccess {
        array: Box<ExpressionAst>,
        indices: Vec<ExpressionAst>,
    },
    Conditional {
        condition: Box<ExpressionAst>,
        then_expr: Box<ExpressionAst>,
        else_expr: Box<ExpressionAst>,
    },
    Parenthesized(Box<ExpressionAst>),
    Complex(String),
}

Common expression patterns in OpenMP directives

Learning: Large Enums with Data

This enum demonstrates Rust’s powerful enum system. Each variant can carry different data:

• IntLiteral(i64) - carries an integer
• Identifier(String) - carries an owned string
• BinaryOp { ... } - carries multiple fields

This is much more powerful than C enums, which can only be simple tags.

Variants

IntLiteral(i64)

Integer literal: 42, 0x10, 0b1010

Identifier(String)

Identifier: N, num_threads, my_var

BinaryOp

Binary operation: a + b, N * 2, i < 10

Fields

left: Box<ExpressionAst>

op: BinaryOperator

right: Box<ExpressionAst>

UnaryOp

Unary operation: -x, !flag, *ptr

Fields

op: UnaryOperator

operand: Box<ExpressionAst>

Call

Function call: foo(a, b), omp_get_num_threads()

Fields

function: String

args: Vec<ExpressionAst>

ArrayAccess

Array subscript: arr[i], matrix[i][j]

Fields

array: Box<ExpressionAst>

indices: Vec<ExpressionAst>

Conditional

Ternary conditional: cond ? a : b

Fields

condition: Box<ExpressionAst>

then_expr: Box<ExpressionAst>

else_expr: Box<ExpressionAst>

Parenthesized(Box<ExpressionAst>)

Parenthesized: (expr)

Complex(String)

Too complex to parse, kept as string

This is our escape hatch for expressions that are valid but not yet supported by the parser.

Trait Implementations

impl Clone for ExpressionKind

fn clone(&self) -> ExpressionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionKind

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

Formats the value using the given formatter.

impl PartialEq for ExpressionKind

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